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

openscvx/_version.py

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

openscvx/backend/control.py

@@ -0,0 +1,119 @@
+import numpy as np
+from openscvx.backend.variable import Variable
+
+class Control(Variable):
+    """A class representing the control variables in an optimal control problem.
+
+    The Control class extends Variable to handle control-specific properties and supports
+    both true and augmented control dimensions. It provides methods for appending new control
+    variables and accessing subsets of the control vector.
+
+    Attributes:
+        name (str): Name of the control variable.
+        shape (tuple): Shape of the control variable array.
+        min (np.ndarray): Minimum bounds for the control variables. Shape: (n_controls,).
+        max (np.ndarray): Maximum bounds for the control variables. Shape: (n_controls,).
+        guess (np.ndarray): Used to initialize SCP and contains the current SCP solution for the control trajectory. Shape: (n_nodes, n_controls).
+        _true_dim (int): True dimensionality of the control variables.
+        _true_slice (slice): Slice for accessing true control variables.
+        _augmented_slice (slice): Slice for accessing augmented control variables.
+
+    Notes:
+        Attributes prefixed with underscore (_) are for internal use only and should not be accessed directly.
+
+    Example:
+    ```python
+    control = Control("thrust", (3,))
+    control.min = [-1, -1, 0]
+    control.max = [1, 1, 10]
+    control.guess = np.repeat([[0, 0, 10]], 5, axis=0)
+    ```
+    """
+
+    def __init__(self, name, shape):
+        """Initialize a Control object.
+
+        Args:
+            name (str): Name identifier for the control variable
+            shape (tuple): Shape of the control vector
+        """
+        super().__init__(name, shape)
+        self._true_dim = shape[0]
+        self._update_slices()
+
+    def _update_slices(self):
+        """Update the slice objects for true and augmented controls."""
+        self._true_slice = slice(0, self._true_dim)
+        self._augmented_slice = slice(self._true_dim, self.shape[0])
+
+    def append(self, other=None, *, min=-np.inf, max=np.inf, guess=0.0, augmented=False):
+        """Append another control or create a new control variable.
+
+        Args:
+            other (Control, optional): Another Control object to append
+            min (float, optional): Minimum bound for new control. Defaults to -np.inf
+            max (float, optional): Maximum bound for new control. Defaults to np.inf
+            guess (float, optional): Initial guess for new control. Defaults to 0.0
+            augmented (bool, optional): Whether the new control is augmented. Defaults to False
+        """
+        if isinstance(other, Control):
+            super().append(other=other)
+            if not augmented:
+                self._true_dim += getattr(other, "_true_dim", other.shape[0])
+            self._update_slices()
+        else:
+            temp = Control(name=f"{self.name}_temp_append", shape=(1,))
+            temp.min = min
+            temp.max = max
+            temp.guess = guess
+            self.append(temp, augmented=augmented)
+
+    @property
+    def true(self):
+        """Get the true control variables (excluding augmented controls).
+
+        Returns:
+            Control: A new Control object containing only the true control variables
+        """
+        return self[self._true_slice]
+
+    @property
+    def augmented(self):
+        """Get the augmented control variables.
+
+        Returns:
+            Control: A new Control object containing only the augmented control variables
+        """
+        return self[self._augmented_slice]
+
+    def __getitem__(self, idx):
+        """Get a subset of the control variables.
+
+        Args:
+            idx: Index or slice to select control variables
+
+        Returns:
+            Control: A new Control object containing the selected variables
+        """
+        new_ctrl = super().__getitem__(idx)
+        new_ctrl.__class__ = Control
+
+        if isinstance(idx, slice):
+            selected = np.arange(self.shape[0])[idx]
+        elif isinstance(idx, (list, np.ndarray)):
+            selected = np.array(idx)
+        else:
+            selected = np.array([idx])
+
+        new_ctrl._true_dim = np.sum(selected < self._true_dim)
+        new_ctrl._update_slices()
+
+        return new_ctrl
+
+    def __repr__(self):
+        """String representation of the Control object.
+
+        Returns:
+            str: A string describing the Control object
+        """
+        return f"Control('{self.name}', shape={self.shape})"

openscvx/backend/expr.py

@@ -0,0 +1,62 @@
+import numpy as np
+
+
+class Expr:
+    """
+    Base class for symbolic expressions in optimization problems.
+    
+    Note: This class is currently not being used.
+    """
+    
+    def __add__(self, other):
+        return Add(self, to_expr(other))
+
+    def __mul__(self, other):
+        return Mul(self, to_expr(other))
+
+    def __matmul__(self, other):
+        return MatMul(self, to_expr(other))
+
+    def __neg__(self):
+        return Neg(self)
+
+    def children(self):
+        return []
+
+    def pretty(self, indent=0):
+        pad = '  ' * indent
+        lines = [f"{pad}{self.__class__.__name__}"]
+        for child in self.children():
+            lines.append(child.pretty(indent + 1))
+        return '\n'.join(lines)
+
+
+class Add(Expr):
+    def __init__(self, left, right):
+        self.left = left
+        self.right = right
+    def children(self):
+        return [self.left, self.right]
+
+
+class Mul(Expr):
+    def __init__(self, left, right):
+        self.left = left
+        self.right = right
+    def children(self):
+        return [self.left, self.right]
+
+
+class MatMul(Expr):
+    def __init__(self, left, right):
+        self.left = left
+        self.right = right
+    def children(self):
+        return [self.left, self.right]
+
+
+class Neg(Expr):
+    def __init__(self, operand):
+        self.operand = operand
+    def children(self):
+        return [self.operand]

openscvx/backend/parameter.py

@@ -0,0 +1,95 @@
+import numpy as np
+from openscvx.backend.expr import Expr
+
+
+class Parameter(Expr):
+    """A class representing a parameter in the optimization problem.
+    
+    Parameters are symbolic variables that can be used in expressions and constraints.
+    They maintain a registry of all created parameters and can be indexed or sliced.
+    
+    Attributes:
+        _registry (dict): Class-level dictionary storing all created parameters.
+        name (str): The name of the parameter.
+        _shape (tuple): The shape of the parameter.
+        value (any): The current value of the parameter, initially None.
+    """
+
+    _registry = {}
+
+    def __init__(self, name, shape=()):
+        """Initialize a new Parameter.
+        
+        Args:
+            name (str): The name of the parameter.
+            shape (tuple, optional): The shape of the parameter. Defaults to ().
+        
+        Note:
+            The parameter is automatically registered in the class registry if not already present.
+        """
+        super().__init__()
+        self.name = name
+        self._shape = shape
+        self.value = None
+
+        # Automatically register the parameter if not already present
+        if name not in Parameter._registry:
+            Parameter._registry[name] = self
+
+    @property
+    def shape(self):
+        """Get the shape of the parameter.
+        
+        Returns:
+            tuple: The shape of the parameter.
+        """
+        return self._shape
+
+    def __getitem__(self, idx):
+        """Get a subset of the parameter using indexing or slicing.
+        
+        Args:
+            idx (int or slice): The index or slice to use.
+                - If int: Returns a scalar parameter
+                - If slice: Returns a parameter with shape (length of slice,)
+        
+        Returns:
+            Parameter: A new parameter representing the subset.
+        
+        Raises:
+            TypeError: If idx is neither an int nor a slice.
+        """
+        if isinstance(idx, int):
+            param = Parameter(f"{self.name}[{idx}]", shape=())
+        elif isinstance(idx, slice):
+            length = len(range(*idx.indices(self.shape[0])))
+            param = Parameter(f"{self.name}[{idx.start}:{idx.stop}]", shape=(length,))
+        else:
+            raise TypeError("Parameter indices must be int or slice")
+
+        return param
+
+    def __repr__(self):
+        """Get a string representation of the parameter.
+        
+        Returns:
+            str: A string showing the parameter name and shape.
+        """
+        return f"Parameter('{self.name}', shape={self.shape})"
+
+    @classmethod
+    def get_all(cls):
+        """Get all registered parameters.
+        
+        Returns:
+            dict: A dictionary of all registered parameters, with names as keys.
+        """
+        return dict(cls._registry)
+
+    @classmethod
+    def reset(cls):
+        """Clear the registry of all parameters.
+        
+        This method removes all registered parameters from the class registry.
+        """
+        cls._registry.clear()

openscvx/backend/state.py

@@ -0,0 +1,441 @@
+import numpy as np
+
+from openscvx.backend.variable import Variable
+
+
+class Fix:
+    """Class representing a fixed state variable in the optimization problem.
+    
+    A fixed state variable is one that is constrained to a specific value
+    and cannot be optimized.
+    
+    Attributes:
+        value: The fixed value that the state variable must take.
+    """
+    def __init__(self, value):
+        """Initialize a new fixed state variable.
+        
+        Args:
+            value: The fixed value that the state variable must take.
+        """
+        self.value = value
+
+    def __repr__(self):
+        """Get a string representation of this fixed state variable.
+        
+        Returns:
+            str: A string representation showing the fixed value.
+        """
+        return f"Fix({self.value})"
+
+
+class Free:
+    """Class representing a free state variable in the optimization problem.
+    
+    A free state variable is one that is not constrained to any specific value
+    but can be optimized within its bounds.
+    
+    Attributes:
+        guess: The initial guess value for optimization.
+    """
+    def __init__(self, guess):
+        """Initialize a new free state variable.
+        
+        Args:
+            guess: The initial guess value for optimization.
+        """
+        self.guess = guess
+
+    def __repr__(self):
+        """Get a string representation of this free state variable.
+        
+        Returns:
+            str: A string representation showing the guess value.
+        """
+        return f"Free({self.guess})"
+
+
+class Minimize:
+    """Class representing a state variable to be minimized in the optimization problem.
+    
+    A minimized state variable is one that is optimized to achieve the lowest
+    possible value within its bounds.
+    
+    Attributes:
+        guess: The initial guess value for optimization.
+    """
+    def __init__(self, guess):
+        """Initialize a new minimized state variable.
+        
+        Args:
+            guess: The initial guess value for optimization.
+        """
+        self.guess = guess
+
+    def __repr__(self):
+        """Get a string representation of this minimized state variable.
+        
+        Returns:
+            str: A string representation showing the guess value.
+        """
+        return f"Minimize({self.guess})"
+
+
+class Maximize:
+    """Class representing a state variable to be maximized in the optimization problem.
+    
+    A maximized state variable is one that is optimized to achieve the highest
+    possible value within its bounds.
+    
+    Attributes:
+        guess: The initial guess value for optimization.
+    """
+    def __init__(self, guess):
+        """Initialize a new maximized state variable.
+        
+        Args:
+            guess: The initial guess value for optimization.
+        """
+        self.guess = guess
+
+    def __repr__(self):
+        """Get a string representation of this maximized state variable.
+        
+        Returns:
+            str: A string representation showing the guess value.
+        """
+        return f"Maximize({self.guess})"
+
+class State(Variable):
+    """A class representing the state variables in an optimal control problem.
+
+    The State class extends Variable to handle state-specific properties like initial and final conditions,
+    as well as true and augmented state dimensions. It supports various boundary condition types:
+    - Fixed values (Fix)
+    - Free variables (Free)
+    - Minimization objectives (Minimize)
+    - Maximization objectives (Maximize)
+
+    Attributes:
+        name (str): Name of the state variable.
+        shape (tuple): Shape of the state variable array.
+        min (np.ndarray): Minimum bounds for the state variables. Shape: (n_states,).
+        max (np.ndarray): Maximum bounds for the state variables. Shape: (n_states,).
+        guess (np.ndarray): Used to initialize SCP and contains the current SCP solution for the state trajectory. Shape: (n_nodes, n_states).
+        initial (np.ndarray): Initial state values or boundary condition objects (Free, Fixed, Minimize, Maximize). Shape: (n_states,).
+        final (np.ndarray): Final state values or boundary condition objects (Free, Fixed, Minimize, Maximize). Shape: (n_states,).
+        _initial (np.ndarray): Internal storage for initial state values.
+        _final (np.ndarray): Internal storage for final state values.
+        initial_type (str): Type of initial boundary condition ('fix', 'free', 'minimize', 'maximize').
+        final_type (str): Type of final boundary condition ('fix', 'free', 'minimize', 'maximize').
+        _true_dim (int): True dimensionality of the state variables.
+        _true_slice (slice): Slice for accessing true state variables.
+        _augmented_slice (slice): Slice for accessing augmented state variables.
+
+    Notes:
+        Attributes prefixed with underscore (_) are for internal use only and should not be accessed directly.
+
+    Example:
+    ```python
+    state = State("position", (3,))
+    state.min = np.array([0, 0, 10])
+    state.max = np.array([10, 10, 200])
+    state.guess = np.linspace([0, 1, 2], [10, 5, 8], 3)
+    state.initial = np.array([Fix(0), Free(1), 2])
+    state.final = np.array([Fix(10), Free(5), Maximize(8)])
+    ```
+    """
+
+    def __init__(self, name, shape):
+        """Initialize a State object.
+
+        Args:
+            name (str): Name identifier for the state variable
+            shape (tuple): Shape of the state vector
+        """
+        super().__init__(name, shape)
+        self._initial = None
+        self.initial_type = None
+        self._final = None
+        self.final_type = None
+
+        self._true_dim = shape[0]
+        self._update_slices()
+
+    def _update_slices(self):
+        """Update the slice objects for true and augmented states."""
+        self._true_slice = slice(0, self._true_dim)
+        self._augmented_slice = slice(self._true_dim, self.shape[0])
+
+    @property
+    def min(self):
+        """Get the minimum bounds for the state variables.
+
+        Returns:
+            np.ndarray: Array of minimum values for each state variable
+        """
+        return self._min
+
+    @min.setter
+    def min(self, val):
+        """Set the minimum bounds for the state variables.
+
+        Args:
+            val (np.ndarray): Array of minimum values for each state variable
+
+        Raises:
+            ValueError: If the shape of val doesn't match the state shape
+        """
+        val = np.asarray(val)
+        if val.shape != self.shape:
+            raise ValueError(f"Min shape {val.shape} does not match State shape {self.shape}")
+        self._min = val
+        self._check_bounds_against_initial_final()
+
+    @property
+    def max(self):
+        """Get the maximum bounds for the state variables.
+
+        Returns:
+            np.ndarray: Array of maximum values for each state variable
+        """
+        return self._max
+
+    @max.setter
+    def max(self, val):
+        """Set the maximum bounds for the state variables.
+
+        Args:
+            val (np.ndarray): Array of maximum values for each state variable
+
+        Raises:
+            ValueError: If the shape of val doesn't match the state shape
+        """
+        val = np.asarray(val)
+        if val.shape != self.shape:
+            raise ValueError(f"Max shape {val.shape} does not match State shape {self.shape}")
+        self._max = val
+        self._check_bounds_against_initial_final()
+
+    def _check_bounds_against_initial_final(self):
+        """Check if initial and final values respect the bounds.
+
+        Raises:
+            ValueError: If any fixed initial or final value violates the bounds
+        """
+        for field_name, data, types in [('initial', self._initial, self.initial_type),
+                                        ('final', self._final, self.final_type)]:
+            if data is None or types is None:
+                continue
+            for i, val in np.ndenumerate(data):
+                if types[i] != "Fix":
+                    continue
+                min_i = self._min[i] if self._min is not None else -np.inf
+                max_i = self._max[i] if self._max is not None else np.inf
+                if val < min_i:
+                    raise ValueError(f"{field_name.capitalize()} Fixed value at index {i[0]} is lower then the min: {val} < {min_i}")
+                if val > max_i:
+                    raise ValueError(f"{field_name.capitalize()} Fixed value at index {i[0]} is greater then the max: {val} > {max_i}")
+
+    @property
+    def initial(self):
+        """Get the initial state values.
+
+        Returns:
+            np.ndarray: Array of initial state values
+        """
+        return self._initial
+
+    @initial.setter
+    def initial(self, arr):
+        """Set the initial state values and their types.
+
+        Args:
+            arr (np.ndarray): Array of initial values or boundary condition objects
+                (Fix, Free, Minimize, Maximize)
+
+        Raises:
+            ValueError: If the shape of arr doesn't match the state shape
+        """
+        arr = np.asarray(arr, dtype=object)
+        if arr.shape != self.shape:
+            raise ValueError(f"Initial value shape {arr.shape} does not match State shape {self.shape}")
+        self._initial = np.zeros(arr.shape)
+        self.initial_type = np.full(arr.shape, "Fix", dtype=object)
+
+        for i, v in np.ndenumerate(arr):
+            if isinstance(v, Free):
+                self._initial[i] = v.guess
+                self.initial_type[i] = "Free"
+            elif isinstance(v, Minimize):
+                self._initial[i] = v.guess
+                self.initial_type[i] = "Minimize"
+            elif isinstance(v, Maximize):
+                self._initial[i] = v.guess
+                self.initial_type[i] = "Maximize"
+            elif isinstance(v, Fix):
+                val = v.value
+                self._initial[i] = val
+                self.initial_type[i] = "Fix"
+            else:
+                val = v
+                self._initial[i] = val
+                self.initial_type[i] = "Fix"
+
+        self._check_bounds_against_initial_final()
+
+    @property
+    def final(self):
+        """Get the final state values.
+
+        Returns:
+            np.ndarray: Array of final state values
+        """
+        return self._final
+
+    @final.setter
+    def final(self, arr):
+        """Set the final state values and their types.
+
+        Args:
+            arr (np.ndarray): Array of final values or boundary condition objects
+                (Fix, Free, Minimize, Maximize)
+
+        Raises:
+            ValueError: If the shape of arr doesn't match the state shape
+        """
+        arr = np.asarray(arr, dtype=object)
+        if arr.shape != self.shape:
+            raise ValueError(f"Final value shape {arr.shape} does not match State shape {self.shape}")
+        self._final = np.zeros(arr.shape)
+        self.final_type = np.full(arr.shape, "Fix", dtype=object)
+
+        for i, v in np.ndenumerate(arr):
+            if isinstance(v, Free):
+                self._final[i] = v.guess
+                self.final_type[i] = "Free"
+            elif isinstance(v, Minimize):
+                self._final[i] = v.guess
+                self.final_type[i] = "Minimize"
+            elif isinstance(v, Maximize):
+                self._final[i] = v.guess
+                self.final_type[i] = "Maximize"
+            elif isinstance(v, Fix):
+                val = v.value
+                self._final[i] = val
+                self.final_type[i] = "Fix"
+            else:
+                val = v
+                self._final[i] = val
+                self.final_type[i] = "Fix"
+
+        self._check_bounds_against_initial_final()
+
+    @property
+    def true(self):
+        """Get the true state variables (excluding augmented states).
+
+        Returns:
+            State: A new State object containing only the true state variables
+        """
+        return self[self._true_slice]
+
+    @property
+    def augmented(self):
+        """Get the augmented state variables.
+
+        Returns:
+            State: A new State object containing only the augmented state variables
+        """
+        return self[self._augmented_slice]
+
+    def append(self, other=None, *, min=-np.inf, max=np.inf, guess=0.0, initial=0.0, final=0.0, augmented=False):
+        """Append another state or create a new state variable.
+
+        Args:
+            other (State, optional): Another State object to append
+            min (float, optional): Minimum bound for new state. Defaults to -np.inf
+            max (float, optional): Maximum bound for new state. Defaults to np.inf
+            guess (float, optional): Initial guess for new state. Defaults to 0.0
+            initial (float, optional): Initial value for new state. Defaults to 0.0
+            final (float, optional): Final value for new state. Defaults to 0.0
+            augmented (bool, optional): Whether the new state is augmented. Defaults to False
+        """
+        if isinstance(other, State):
+            super().append(other=other)
+
+            if self._initial is None:
+                self._initial = np.array(other._initial) if other._initial is not None else None
+            elif other._initial is not None:
+                self._initial = np.concatenate([self._initial, other._initial], axis=0)
+
+            if self._final is None:
+                self._final = np.array(other._final) if other._final is not None else None
+            elif other._final is not None:
+                self._final = np.concatenate([self._final, other._final], axis=0)
+
+            if self.initial_type is None:
+                self.initial_type = np.array(other.initial_type) if other.initial_type is not None else None
+            elif other.initial_type is not None:
+                self.initial_type = np.concatenate([self.initial_type, other.initial_type], axis=0)
+
+            if self.final_type is None:
+                self.final_type = np.array(other.final_type) if other.final_type is not None else None
+            elif other.final_type is not None:
+                self.final_type = np.concatenate([self.final_type, other.final_type], axis=0)
+
+            if not augmented:
+                self._true_dim += getattr(other, "_true_dim", other.shape[0])
+            self._update_slices()
+        else:
+            temp_state = State(name=f"{self.name}_temp_append", shape=(1,))
+            temp_state.min = min
+            temp_state.max = max
+            temp_state.guess = guess
+            temp_state.initial = initial
+            temp_state.final = final
+            self.append(temp_state, augmented=augmented)
+
+    def __getitem__(self, idx):
+        """Get a subset of the state variables.
+
+        Args:
+            idx: Index or slice to select state variables
+
+        Returns:
+            State: A new State object containing the selected variables
+        """
+        new_state = super().__getitem__(idx)
+        new_state.__class__ = State
+
+        def slice_attr(attr):
+            if attr is None:
+                return None
+            if attr.ndim == 2 and attr.shape[1] == self.shape[0]:
+                return attr[:, idx]
+            return attr[idx]
+
+        new_state._initial = slice_attr(self._initial)
+        new_state.initial_type = slice_attr(self.initial_type)
+        new_state._final = slice_attr(self._final)
+        new_state.final_type = slice_attr(self.final_type)
+
+        if isinstance(idx, slice):
+            selected = np.arange(self.shape[0])[idx]
+        elif isinstance(idx, (list, np.ndarray)):
+            selected = np.array(idx)
+        else:
+            selected = np.array([idx])
+
+        new_state._true_dim = np.sum(selected < self._true_dim)
+        new_state._update_slices()
+
+        return new_state
+
+    def __repr__(self):
+        """String representation of the State object.
+
+        Returns:
+            str: A string describing the State object
+        """
+        return f"State('{self.name}', shape={self.shape})"

openscvx/backend/utils.py

@@ -0,0 +1,27 @@
+# utils.py
+
+from expr import Const, Add, Mul, MatMul, Neg
+
+def pretty_print(expr):
+    print(expr.pretty())
+
+def evaluate(expr, values):
+    if hasattr(expr, 'name'):
+        return values[expr.name]
+
+    if isinstance(expr, Const):
+        return expr.value
+
+    if isinstance(expr, Add):
+        return evaluate(expr.a, values) + evaluate(expr.b, values)
+
+    if isinstance(expr, Mul):
+        return evaluate(expr.a, values) * evaluate(expr.b, values)
+
+    if isinstance(expr, MatMul):
+        return evaluate(expr.a, values) @ evaluate(expr.b, values)
+
+    if isinstance(expr, Neg):
+        return -evaluate(expr.a, values)
+
+    raise NotImplementedError(f"Evaluation not implemented for {type(expr)}")

openscvx/backend/variable.py

@@ -0,0 +1,209 @@
+import numpy as np
+
+from openscvx.backend.expr import Expr
+
+class Variable(Expr):
+    """A base class for variables in an optimal control problem.
+
+    The Variable class provides the fundamental structure for state and control variables,
+    handling their shapes, bounds, and initial guesses. It supports operations like
+    appending new variables and slicing.
+
+    Attributes:
+        name (str): Name identifier for the variable
+        _shape (tuple): Shape of the variable vector
+        _min (np.ndarray): Minimum bounds for the variable
+        _max (np.ndarray): Maximum bounds for the variable
+        _guess (np.ndarray): Initial guess for the variable trajectory
+
+    """
+
+    def __init__(self, name, shape):
+        """Initialize a Variable object.
+
+        Args:
+            name (str): Name identifier for the variable
+            shape (tuple): Shape of the variable vector
+        """
+        super().__init__()
+        self.name = name
+        self._shape = shape
+        self._min = None
+        self._max = None
+        self._guess = None
+
+    @property
+    def shape(self):
+        """Get the shape of the variable.
+
+        Returns:
+            tuple: Shape of the variable vector
+        """
+        return self._shape
+
+    @property
+    def min(self):
+        """Get the minimum bounds for the variable.
+
+        Returns:
+            np.ndarray: Array of minimum values for each variable
+        """
+        return self._min
+
+    @min.setter
+    def min(self, arr):
+        """Set the minimum bounds for the variable.
+
+        Args:
+            arr (np.ndarray): Array of minimum values for each variable
+
+        Raises:
+            ValueError: If the shape of arr doesn't match the variable shape
+        """
+        arr = np.asarray(arr, dtype=float)
+        if arr.ndim != 1 or arr.shape[0] != self.shape[0]:
+            raise ValueError(f"{self.__class__.__name__} min must be 1D with shape ({self.shape[0]},), got {arr.shape}")
+        self._min = arr
+
+    @property
+    def max(self):
+        """Get the maximum bounds for the variable.
+
+        Returns:
+            np.ndarray: Array of maximum values for each variable
+        """
+        return self._max
+
+    @max.setter
+    def max(self, arr):
+        """Set the maximum bounds for the variable.
+
+        Args:
+            arr (np.ndarray): Array of maximum values for each variable
+
+        Raises:
+            ValueError: If the shape of arr doesn't match the variable shape
+        """
+        arr = np.asarray(arr, dtype=float)
+        if arr.ndim != 1 or arr.shape[0] != self.shape[0]:
+            raise ValueError(f"{self.__class__.__name__} max must be 1D with shape ({self.shape[0]},), got {arr.shape}")
+        self._max = arr
+
+    @property
+    def guess(self):
+        """Get the initial guess for the variable trajectory.
+
+        Returns:
+            np.ndarray: Array of initial guesses for each variable at each time point
+        """
+        return self._guess
+
+    @guess.setter
+    def guess(self, arr):
+        """Set the initial guess for the variable trajectory.
+
+        Args:
+            arr (np.ndarray): 2D array of initial guesses with shape (n_guess_points, n_variables)
+
+        Raises:
+            ValueError: If the shape of arr doesn't match the expected dimensions
+        """
+        arr = np.asarray(arr)
+        if arr.ndim != 2:
+            raise ValueError(f"Guess must be a 2D array of shape (n_guess_points, {self.shape[0]}), got shape {arr.shape}")
+        if arr.shape[1] != self.shape[0]:
+            raise ValueError(f"Guess must have second dimension equal to variable dimension {self.shape[0]}, got {arr.shape[1]}")
+        self._guess = arr
+
+    def append(self, other=None, *, min=-np.inf, max=np.inf, guess=0.0):
+        """Append another variable or create a new variable.
+
+        Args:
+            other (Variable, optional): Another Variable object to append
+            min (float, optional): Minimum bound for new variable. Defaults to -np.inf
+            max (float, optional): Maximum bound for new variable. Defaults to np.inf
+            guess (float, optional): Initial guess for new variable. Defaults to 0.0
+        """
+        def process_array(val, is_guess=False):
+            """Process input array to ensure correct shape and type.
+
+            Args:
+                val: Input value to process
+                is_guess (bool): Whether the value is a guess array
+
+            Returns:
+                np.ndarray: Processed array with correct shape and type
+            """
+            arr = np.asarray(val, dtype=float)
+            if is_guess:
+                return np.atleast_2d(arr)
+            return np.atleast_1d(arr)
+
+        if isinstance(other, Variable):
+            self._shape = (self.shape[0] + other.shape[0],)
+
+            if self._min is not None and other._min is not None:
+                self._min = np.concatenate([self._min, process_array(other._min)], axis=0)
+
+            if self._max is not None and other._max is not None:
+                self._max = np.concatenate([self._max, process_array(other._max)], axis=0)
+
+            if self._guess is not None and other._guess is not None:
+                self._guess = np.concatenate([self._guess, process_array(other._guess, is_guess=True)], axis=1)
+
+        else:
+            self._shape = (self.shape[0] + 1,)
+
+            if self._min is not None:
+                self._min = np.concatenate([self._min, process_array(min)], axis=0)
+
+            if self._max is not None:
+                self._max = np.concatenate([self._max, process_array(max)], axis=0)
+
+            if self._guess is not None:
+                guess_arr = process_array(guess, is_guess=True)
+                if guess_arr.shape[1] != 1:
+                    guess_arr = guess_arr.T
+                self._guess = np.concatenate([self._guess, guess_arr], axis=1)
+
+    def __getitem__(self, idx):
+        """Get a subset of the variable.
+
+        Args:
+            idx (int or slice): Index or slice to select variables
+
+        Returns:
+            Variable: A new Variable object containing the selected variables
+
+        Raises:
+            TypeError: If idx is not an int or slice
+        """
+        if isinstance(idx, int):
+            new_shape = ()
+        elif isinstance(idx, slice):
+            new_shape = (len(range(*idx.indices(self.shape[0]))),)
+        else:
+            raise TypeError("Variable indices must be int or slice")
+
+        sliced = Variable(f"{self.name}[{idx}]", new_shape)
+
+        def slice_attr(attr):
+            """Slice an attribute array based on the index.
+
+            Args:
+                attr (np.ndarray): Attribute array to slice
+
+            Returns:
+                np.ndarray: Sliced attribute array
+            """
+            if attr is None:
+                return None
+            if attr.ndim == 2 and attr.shape[1] == self.shape[0]:
+                return attr[:, idx]
+            return attr[idx]
+
+        sliced._min = slice_attr(self._min)
+        sliced._max = slice_attr(self._max)
+        sliced._guess = slice_attr(self._guess)
+
+        return sliced

{openscvx-0.2.1.dist-info → openscvx-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.2.1
+Version: 0.2.2
 Summary: A general Python-based successive convexification implementation which uses a JAX backend.
 Home-page: https://haynec.github.io/openscvx/
 Author: Chris Hayner and Griffin Norris

{openscvx-0.2.1.dist-info → openscvx-0.2.2.dist-info}/RECORD

@@ -1,5 +1,5 @@
 openscvx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-openscvx/_version.py,sha256=UoNvMtd4wCG76RwoSpNCUtaFyTwakGcZolfjXzNVSMY,511
+openscvx/_version.py,sha256=OjGGK5TcHVG44Y62aAqeJH4CskkZoY9ydbHOtCDew50,511
 openscvx/config.py,sha256=BsMAZUWCBUMl43nvakQ2OOdf2iszsFv9VP27J4xDXEs,16106
 openscvx/discretization.py,sha256=FBpJKoVTXYAxeE6PvaekbRFbLWeKY6EJfl214ib2tX8,7908
 openscvx/dynamics.py,sha256=TQosmwDXpWvR22-ZL2JawDDjVkyoL-DN45Xuv7ecCnc,6417
@@ -16,12 +16,19 @@ openscvx/utils.py,sha256=CEd_kjh-MUhRInZjoxogUjMddU5ExJ-IAOXq_Hn4KGY,4166
 openscvx/augmentation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 openscvx/augmentation/ctcs.py,sha256=m1jdALXSqHq3WD6lCBAUI7FR0Sfs8aCYr66h0EwE4z4,1707
 openscvx/augmentation/dynamics_augmentation.py,sha256=4lEeSRl3LJxvcclwGSI1Yp21kc_oKoIVga08uzaKXE0,4702
+openscvx/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+openscvx/backend/control.py,sha256=vOAZNzVZy6-sft5OzP6ZavQiaaDTLSJhjVJHvgPH9Vo,4457
+openscvx/backend/expr.py,sha256=GQfnQxizogUONQ4oBtSQZMlFQYesunBbT95n1EMAPRo,1374
+openscvx/backend/parameter.py,sha256=WmH_MiruQ8rSdf_mS0RfRYJLVgIRU-nlA794GMrbOLU,3047
+openscvx/backend/state.py,sha256=UbyerDHm_BTE1T5vI1HFYvBXxDwBl-ocdY2knJrJOGA,15952
+openscvx/backend/utils.py,sha256=pxh-YG1pSkcxzaPe9Lx8bkmwcd-RSCs0mdaaZNMg4CE,707
+openscvx/backend/variable.py,sha256=AqyLc13PKMm_eK1SDnqns6Fkx7hQdG--r5dnEBUfMf8,7104
 openscvx/constraints/__init__.py,sha256=J3_UyJMUVYzvhjfyBM_m9WIRDlHQV7Q4CiI-TzRapAs,165
 openscvx/constraints/ctcs.py,sha256=-VJZE8O0xq8n9mzSiDNikax-xo6CpWJtjwMbAPzu1-8,10121
 openscvx/constraints/nodal.py,sha256=qT_U8Go0n0rzv4MupwQYGL8H5P8ShA7ZGATJ7IHnIqU,8185
 openscvx/constraints/violation.py,sha256=curg7R6ER4YtKzdqmd1tgS2kWICGon5ab_Y4YGbeibw,2875
-openscvx-0.2.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-openscvx-0.2.1.dist-info/METADATA,sha256=2SUNu4T25V27sB60rayMSyHFozYtFb-ObDDbGszsybw,9052
-openscvx-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-openscvx-0.2.1.dist-info/top_level.txt,sha256=nUT4Ybefzh40H8tVXqc1RzKESy_MAowElb-CIvAbd4Q,9
-openscvx-0.2.1.dist-info/RECORD,,
+openscvx-0.2.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+openscvx-0.2.2.dist-info/METADATA,sha256=EBYY6LZeEvcvaId2WQEne9tNtnSk0IyMszpXK3-2vfE,9052
+openscvx-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+openscvx-0.2.2.dist-info/top_level.txt,sha256=nUT4Ybefzh40H8tVXqc1RzKESy_MAowElb-CIvAbd4Q,9
+openscvx-0.2.2.dist-info/RECORD,,