-
Notifications
You must be signed in to change notification settings - Fork 15
Expand file tree
/
Copy pathmain.cpp
More file actions
124 lines (97 loc) · 4.71 KB
/
Copy pathmain.cpp
File metadata and controls
124 lines (97 loc) · 4.71 KB
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
// Copyright (c) Sleipnir contributors
#include <nanobind/eigen/dense.h>
#include <nanobind/nanobind.h>
#include <Eigen/Core>
#include <sleipnir/autodiff/expression_type.hpp>
#include <sleipnir/autodiff/gradient.hpp>
#include <sleipnir/autodiff/variable.hpp>
#include <sleipnir/autodiff/variable_block.hpp>
#include <sleipnir/autodiff/variable_matrix.hpp>
#include <sleipnir/optimization/ocp.hpp>
#include <sleipnir/optimization/ocp/dynamics_type.hpp>
#include <sleipnir/optimization/ocp/timestep_method.hpp>
#include <sleipnir/optimization/ocp/transcription_method.hpp>
#include <sleipnir/optimization/problem.hpp>
#include <sleipnir/optimization/solver/exit_status.hpp>
#include <sleipnir/optimization/solver/iteration_info.hpp>
#include "binders.hpp"
#include "docstrings.hpp"
#include "for_each_type.hpp"
namespace nb = nanobind;
namespace slp {
NB_MODULE(_sleipnir, m) {
using namespace nb::literals;
m.doc() =
"A linearity-exploiting reverse mode autodiff library and nonlinear "
"program solver DSL.";
nb::module_ autodiff = m.def_submodule("autodiff");
nb::module_ optimization = m.def_submodule("optimization");
nb::enum_<ExpressionType> expression_type{autodiff, "ExpressionType",
DOC(slp, ExpressionType)};
nb::class_<Variable<double>> variable{autodiff, "Variable",
DOC(slp, Variable)};
nb::class_<VariableMatrix<double>> variable_matrix{autodiff, "VariableMatrix",
DOC(slp, VariableMatrix)};
nb::class_<VariableBlock<VariableMatrix<double>>> variable_block{
autodiff, "VariableBlock", DOC(slp, VariableBlock)};
nb::class_<Gradient<double>> gradient{autodiff, "Gradient",
DOC(slp, Gradient)};
nb::class_<Hessian<double>> hessian{autodiff, "Hessian", DOC(slp, Hessian)};
nb::class_<Jacobian<double>> jacobian{autodiff, "Jacobian",
DOC(slp, Jacobian)};
nb::class_<EqualityConstraints<double>> equality_constraints{
optimization, "EqualityConstraints", DOC(slp, EqualityConstraints)};
nb::class_<InequalityConstraints<double>> inequality_constraints{
optimization, "InequalityConstraints", DOC(slp_InequalityConstraints)};
// Bounds function
for_each_type<
double, int, const Variable<double>&, const VariableMatrix<double>&,
const VariableBlock<VariableMatrix<double>>&, nb::DRef<Eigen::MatrixXd>>(
[&]<typename L> {
for_each_type<const Variable<double>&, const VariableMatrix<double>&,
const VariableBlock<VariableMatrix<double>>&>(
[&]<typename X> {
for_each_type<double, int, const Variable<double>&,
const VariableMatrix<double>&,
const VariableBlock<VariableMatrix<double>>&,
nb::DRef<Eigen::MatrixXd>>([&]<typename U> {
optimization.def("bounds", &bounds<L&&, X&&, U&&>, "l"_a, "x"_a,
"u"_a, DOC(slp, bounds));
});
});
});
nb::enum_<ExitStatus> exit_status{optimization, "ExitStatus",
DOC(slp, ExitStatus)};
nb::class_<IterationInfo<double>> iteration_info{
optimization, "IterationInfo", DOC(slp, IterationInfo)};
nb::class_<Problem<double>> problem{optimization, "Problem",
DOC(slp, Problem)};
nb::enum_<DynamicsType> dynamics_type{optimization, "DynamicsType",
DOC(slp, DynamicsType)};
nb::enum_<TimestepMethod> timestep_method{optimization, "TimestepMethod",
DOC(slp, TimestepMethod)};
nb::enum_<TranscriptionMethod> transcription_method{
optimization, "TranscriptionMethod", DOC(slp, TranscriptionMethod)};
nb::class_<OCP<double>, Problem<double>> ocp{optimization, "OCP",
DOC(slp, OCP)};
bind_expression_type(expression_type);
bind_variable(autodiff, variable);
bind_variable_matrix(autodiff, variable_matrix);
bind_variable_block(variable_block);
// Implicit conversions
variable_matrix.def(
nb::init_implicit<VariableBlock<VariableMatrix<double>>>());
bind_gradient(gradient);
bind_hessian(hessian);
bind_jacobian(jacobian);
bind_equality_constraints(equality_constraints);
bind_inequality_constraints(inequality_constraints);
bind_exit_status(exit_status);
bind_iteration_info(iteration_info);
bind_problem(problem);
bind_dynamics_type(dynamics_type);
bind_timestep_method(timestep_method);
bind_transcription_method(transcription_method);
bind_ocp(ocp);
}
} // namespace slp