7#include <initializer_list>
8#include <source_location>
14#include <gch/small_vector.hpp>
16#include "sleipnir/autodiff/expression.hpp"
17#include "sleipnir/autodiff/expression_graph.hpp"
18#include "sleipnir/util/assert.hpp"
19#include "sleipnir/util/concepts.hpp"
20#include "sleipnir/util/symbol_exports.hpp"
22#ifndef SLEIPNIR_DISABLE_DIAGNOSTICS
23#include "sleipnir/util/print.hpp"
30class AdjointExpressionGraph;
32template <
int UpLo = Eigen::Lower | Eigen::Upper>
33 requires(UpLo == Eigen::Lower) || (UpLo == (Eigen::Lower | Eigen::Upper))
34class SLEIPNIR_DLLEXPORT Hessian;
35class SLEIPNIR_DLLEXPORT Jacobian;
50 explicit constexpr Variable(std::nullptr_t) : expr{nullptr} {}
58 : expr{detail::make_expression_ptr<detail::ConstExpression>(value)} {}
66 : expr{detail::make_expression_ptr<detail::ConstExpression>(value)} {}
81 : expr{std::move(expr)} {}
90 expr = detail::make_expression_ptr<detail::ConstExpression>(value);
91 m_graph_initialized =
false;
102#ifndef SLEIPNIR_DISABLE_DIAGNOSTICS
105 if (expr->args[0] !=
nullptr) {
106 auto location = std::source_location::current();
109 "WARNING: {}:{}: {}: Modified the value of a dependent variable",
110 location.file_name(), location.line(), location.function_name());
122 if (!m_graph_initialized) {
123 m_graph = detail::topological_sort(expr);
124 m_graph_initialized =
true;
126 detail::update_values(m_graph);
137 ExpressionType
type()
const {
return expr->type(); }
148 return Variable{lhs.expr * rhs.expr};
171 return Variable{lhs.expr / rhs.expr};
194 return Variable{lhs.expr + rhs.expr};
217 return Variable{lhs.expr - rhs.expr};
252 detail::make_expression_ptr<detail::DecisionVariableExpression>();
256 gch::small_vector<detail::Expression*> m_graph;
259 bool m_graph_initialized =
false;
289 requires(UpLo == Eigen::Lower) || (UpLo == (Eigen::Lower | Eigen::Upper))
290 friend class SLEIPNIR_DLLEXPORT
Hessian;
291 friend class SLEIPNIR_DLLEXPORT
Jacobian;
300 return Variable{detail::abs(x.expr)};
309 return Variable{detail::acos(x.expr)};
318 return Variable{detail::asin(x.expr)};
327 return Variable{detail::atan(x.expr)};
337 return Variable{detail::atan2(y.expr, x.expr)};
346 return Variable{detail::cbrt(x.expr)};
355 return Variable{detail::cos(x.expr)};
364 return Variable{detail::cosh(x.expr)};
373 return Variable{detail::erf(x.expr)};
382 return Variable{detail::exp(x.expr)};
392 return Variable{detail::hypot(x.expr, y.expr)};
403 return Variable{detail::pow(base.expr, power.expr)};
412 return Variable{detail::log(x.expr)};
421 return Variable{detail::log10(x.expr)};
430 return Variable{detail::sign(x.expr)};
439 return Variable{detail::sin(x.expr)};
448 return Variable{detail::sinh(x.expr)};
457 return Variable{detail::sqrt(x.expr)};
466 return Variable{detail::tan(x.expr)};
475 return Variable{detail::tanh(x.expr)};
487 return Variable{slp::sqrt(slp::pow(x, 2) + slp::pow(y, 2) + slp::pow(z, 2))};
501template <
typename LHS,
typename RHS>
505gch::small_vector<Variable> make_constraints(LHS&& lhs, RHS&& rhs) {
506 gch::small_vector<Variable> constraints;
509 constraints.emplace_back(lhs - rhs);
510 }
else if constexpr (ScalarLike<LHS> && MatrixLike<RHS>) {
511 constraints.reserve(rhs.rows() * rhs.cols());
513 for (
int row = 0; row < rhs.rows(); ++row) {
514 for (
int col = 0; col < rhs.cols(); ++col) {
516 if constexpr (EigenMatrixLike<std::decay_t<RHS>>) {
517 constraints.emplace_back(lhs - rhs(row, col));
519 constraints.emplace_back(lhs - rhs[row, col]);
523 }
else if constexpr (MatrixLike<LHS> && ScalarLike<RHS>) {
524 constraints.reserve(lhs.rows() * lhs.cols());
526 for (
int row = 0; row < lhs.rows(); ++row) {
527 for (
int col = 0; col < lhs.cols(); ++col) {
529 if constexpr (EigenMatrixLike<std::decay_t<LHS>>) {
530 constraints.emplace_back(lhs(row, col) - rhs);
532 constraints.emplace_back(lhs[row, col] - rhs);
536 }
else if constexpr (MatrixLike<LHS> && MatrixLike<RHS>) {
537 slp_assert(lhs.rows() == rhs.rows() && lhs.cols() == rhs.cols());
538 constraints.reserve(lhs.rows() * lhs.cols());
540 for (
int row = 0; row < lhs.rows(); ++row) {
541 for (
int col = 0; col < lhs.cols(); ++col) {
543 if constexpr (EigenMatrixLike<std::decay_t<LHS>> &&
544 EigenMatrixLike<std::decay_t<RHS>>) {
545 constraints.emplace_back(lhs(row, col) - rhs(row, col));
546 }
else if constexpr (EigenMatrixLike<std::decay_t<LHS>> &&
547 SleipnirMatrixLike<std::decay_t<RHS>>) {
548 constraints.emplace_back(lhs(row, col) - rhs[row, col]);
549 }
else if constexpr (SleipnirMatrixLike<std::decay_t<LHS>> &&
550 EigenMatrixLike<std::decay_t<RHS>>) {
551 constraints.emplace_back(lhs[row, col] - rhs(row, col));
552 }
else if constexpr (SleipnirMatrixLike<std::decay_t<LHS>> &&
553 SleipnirMatrixLike<std::decay_t<RHS>>) {
554 constraints.emplace_back(lhs[row, col] - rhs[row, col]);
576 std::initializer_list<EqualityConstraints> equality_constraints) {
577 for (
const auto& elem : equality_constraints) {
578 constraints.insert(constraints.end(), elem.constraints.begin(),
579 elem.constraints.end());
591 const std::vector<EqualityConstraints>& equality_constraints) {
592 for (
const auto& elem : equality_constraints) {
593 constraints.insert(constraints.end(), elem.constraints.begin(),
594 elem.constraints.end());
607 template <
typename LHS,
typename RHS>
612 : constraints{make_constraints(lhs, rhs)} {}
618 return std::ranges::all_of(constraints, [](
auto& constraint) {
619 return constraint.value() == 0.0;
638 std::initializer_list<InequalityConstraints> inequality_constraints) {
639 for (
const auto& elem : inequality_constraints) {
640 constraints.insert(constraints.end(), elem.constraints.begin(),
641 elem.constraints.end());
654 const std::vector<InequalityConstraints>& inequality_constraints) {
655 for (
const auto& elem : inequality_constraints) {
656 constraints.insert(constraints.end(), elem.constraints.begin(),
657 elem.constraints.end());
670 template <
typename LHS,
typename RHS>
675 : constraints{make_constraints(lhs, rhs)} {}
681 return std::ranges::all_of(constraints, [](
auto& constraint) {
682 return constraint.value() >= 0.0;
693template <
typename LHS,
typename RHS>
694 requires(ScalarLike<LHS> || MatrixLike<LHS>) &&
695 (ScalarLike<RHS> || MatrixLike<RHS>) &&
696 (SleipnirType<LHS> || SleipnirType<RHS>)
697EqualityConstraints
operator==(LHS&& lhs, RHS&& rhs) {
698 return EqualityConstraints{lhs, rhs};
708template <
typename LHS,
typename RHS>
709 requires(ScalarLike<LHS> || MatrixLike<LHS>) &&
710 (ScalarLike<RHS> || MatrixLike<RHS>) &&
711 (SleipnirType<LHS> || SleipnirType<RHS>)
712InequalityConstraints
operator<(LHS&& lhs, RHS&& rhs) {
723template <
typename LHS,
typename RHS>
724 requires(ScalarLike<LHS> || MatrixLike<LHS>) &&
725 (ScalarLike<RHS> || MatrixLike<RHS>) &&
726 (SleipnirType<LHS> || SleipnirType<RHS>)
727InequalityConstraints
operator<=(LHS&& lhs, RHS&& rhs) {
738template <
typename LHS,
typename RHS>
739 requires(ScalarLike<LHS> || MatrixLike<LHS>) &&
740 (ScalarLike<RHS> || MatrixLike<RHS>) &&
741 (SleipnirType<LHS> || SleipnirType<RHS>)
742InequalityConstraints
operator>(LHS&& lhs, RHS&& rhs) {
753template <
typename LHS,
typename RHS>
754 requires(ScalarLike<LHS> || MatrixLike<LHS>) &&
755 (ScalarLike<RHS> || MatrixLike<RHS>) &&
756 (SleipnirType<LHS> || SleipnirType<RHS>)
757InequalityConstraints
operator>=(LHS&& lhs, RHS&& rhs) {
758 return InequalityConstraints{lhs, rhs};
769struct NumTraits<slp::Variable> : NumTraits<double> {
778 static constexpr int IsComplex = 0;
780 static constexpr int IsInteger = 0;
782 static constexpr int IsSigned = 1;
784 static constexpr int RequireInitialization = 1;
786 static constexpr int ReadCost = 1;
788 static constexpr int AddCost = 3;
790 static constexpr int MulCost = 3;
Definition hessian.hpp:30
Definition jacobian.hpp:26
Definition variable.hpp:40
friend SLEIPNIR_DLLEXPORT Variable operator+(const Variable &lhs)
Definition variable.hpp:245
constexpr Variable(detail::ExpressionPtr &&expr)
Definition variable.hpp:80
friend SLEIPNIR_DLLEXPORT Variable operator*(const Variable &lhs, const Variable &rhs)
Definition variable.hpp:146
Variable & operator=(double value)
Definition variable.hpp:89
Variable & operator-=(const Variable &rhs)
Definition variable.hpp:226
friend SLEIPNIR_DLLEXPORT Variable operator-(const Variable &lhs)
Definition variable.hpp:236
friend SLEIPNIR_DLLEXPORT Variable operator+(const Variable &lhs, const Variable &rhs)
Definition variable.hpp:192
Variable & operator+=(const Variable &rhs)
Definition variable.hpp:203
friend SLEIPNIR_DLLEXPORT Variable operator-(const Variable &lhs, const Variable &rhs)
Definition variable.hpp:215
Variable & operator*=(const Variable &rhs)
Definition variable.hpp:157
Variable(std::floating_point auto value)
Definition variable.hpp:57
constexpr Variable(std::nullptr_t)
Definition variable.hpp:50
friend SLEIPNIR_DLLEXPORT Variable operator/(const Variable &lhs, const Variable &rhs)
Definition variable.hpp:169
Variable(std::integral auto value)
Definition variable.hpp:65
void set_value(double value)
Definition variable.hpp:101
Variable & operator/=(const Variable &rhs)
Definition variable.hpp:180
ExpressionType type() const
Definition variable.hpp:137
double value()
Definition variable.hpp:121
Variable(const detail::ExpressionPtr &expr)
Definition variable.hpp:73
Definition adjoint_expression_graph.hpp:22
Definition concepts.hpp:40
Definition concepts.hpp:13
Definition concepts.hpp:37
Definition variable.hpp:566
gch::small_vector< Variable > constraints
A vector of scalar equality constraints.
Definition variable.hpp:568
EqualityConstraints(std::initializer_list< EqualityConstraints > equality_constraints)
Definition variable.hpp:575
EqualityConstraints(const std::vector< EqualityConstraints > &equality_constraints)
Definition variable.hpp:590
EqualityConstraints(LHS &&lhs, RHS &&rhs)
Definition variable.hpp:611
Definition variable.hpp:627
InequalityConstraints(const std::vector< InequalityConstraints > &inequality_constraints)
Definition variable.hpp:653
InequalityConstraints(std::initializer_list< InequalityConstraints > inequality_constraints)
Definition variable.hpp:637
InequalityConstraints(LHS &&lhs, RHS &&rhs)
Definition variable.hpp:674
gch::small_vector< Variable > constraints
A vector of scalar inequality constraints.
Definition variable.hpp:629