copp 0.2.2

Convex-objective path parameterization for robotic trajectory planning.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

from __future__ import annotations

from typing import Any, Callable, ClassVar, Literal, Protocol, TypedDict, overload

import numpy as np
from numpy.typing import ArrayLike, NDArray

from .core import CoppError

class TimeObjectiveDict(TypedDict):
    """Dictionary form for ``Time`` objectives."""

    kind: Literal["time"]
    weight: float


class LinearObjectiveDict(TypedDict):
    """Dictionary form for ``Linear`` objectives."""

    kind: Literal["linear"]
    weight: float
    alpha: ArrayLike
    beta: ArrayLike


class ThermalEnergyObjectiveDict(TypedDict):
    """Dictionary form for ``ThermalEnergy`` objectives."""

    kind: Literal["thermal_energy", "thermal"]
    weight: float
    normalize: ArrayLike


class TotalVariationTorqueObjectiveDict(TypedDict):
    """Dictionary form for ``TotalVariationTorque`` objectives."""

    kind: Literal["total_variation_torque", "tv_torque"]
    weight: float
    normalize: ArrayLike


ObjectiveDict = (
    TimeObjectiveDict
    | LinearObjectiveDict
    | ThermalEnergyObjectiveDict
    | TotalVariationTorqueObjectiveDict
)


class Time:
    """Time objective ``weight * integral(dt)``.

    Public user code should construct this as ``copp.objective.Time(...)``.
    """

    weight: float
    """Objective weight."""

    def __init__(self, weight: float) -> None:
        """Construct a time objective."""
        ...


class Linear:
    """Linear objective over profile variables.

    Public user code should construct this as ``copp.objective.Linear(...)``.
    For COPP2, ``alpha`` is node-based and must have length ``problem.s_len``;
    ``beta`` is interval-based and must have length ``problem.s_len - 1``.
    For COPP3, both ``alpha`` and ``beta`` are node-based and must have length
    ``problem.s_len``.
    """

    weight: float
    """Objective weight."""

    alpha: NDArray[np.float64]
    """Node-based coefficient for ``a``."""

    beta: NDArray[np.float64]
    """Interval-based coefficient for ``b`` in COPP2."""

    def __init__(
        self,
        weight: float,
        alpha: ArrayLike,
        beta: ArrayLike,
    ) -> None:
        """Construct a linear objective."""
        ...


class ThermalEnergy:
    """Thermal-energy objective using the robot inverse-dynamics model.

    Public user code should construct this as
    ``copp.objective.ThermalEnergy(...)``.
    """

    weight: float
    """Objective weight."""

    normalize: NDArray[np.float64]
    """Per-axis torque normalization vector with length ``robot.dim``."""

    def __init__(self, weight: float, normalize: ArrayLike) -> None:
        """Construct a thermal-energy objective."""
        ...


class TotalVariationTorque:
    """Total-variation torque objective.

    Public user code should construct this as
    ``copp.objective.TotalVariationTorque(...)``.
    This objective is supported by the SOCP-backed COPP solvers.
    """

    weight: float
    """Objective weight."""

    normalize: NDArray[np.float64]
    """Per-axis torque normalization vector with length ``robot.dim``."""

    def __init__(self, weight: float, normalize: ArrayLike) -> None:
        """Construct a total-variation torque objective."""
        ...


ObjectiveLike = (
    Time
    | Linear
    | ThermalEnergy
    | TotalVariationTorque
    | ObjectiveDict
)