dartpy 7.0.0.dev0__cp312-cp312-manylinux_2_39_x86_64.whl

include/dart/optimizer/Solver.hpp

@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *   POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef DART_OPTIMIZER_SOLVER_HPP_
+#define DART_OPTIMIZER_SOLVER_HPP_
+
+#include <Eigen/Dense>
+
+#include <iostream>
+#include <memory>
+
+namespace dart {
+namespace optimizer {
+
+class Problem;
+
+/// Abstract class that provides a common interface for different Solvers. The
+/// different Solver implementations each use a different nonlinear problem
+/// solving library, which could lead to differences in performance for various
+/// problem types. This base class allows the different Solver implementations
+/// to be swapped out with each other quickly and easily to help with testing,
+/// benchmarking, and experimentation.
+class Solver
+{
+public:
+  /// The Solver::Properties class contains Solver parameters that are common
+  /// to all Solver types. Most (but not necessarily all) Solvers will make use
+  /// of these parameters, and these parameters can be directly copied or
+  /// transferred between all Solver types.
+  struct Properties
+  {
+    /// Nonlinear optimization Problem to be solved
+    std::shared_ptr<Problem> mProblem;
+
+    /// The relative tolerance on the optimization parameters. For example, the
+    /// distance between the last parameters and the current parameters to be
+    /// considered converged.
+    double mTolerance;
+
+    /// The maximum number of iterations that the solver should use. Use 0 for
+    /// infinite iterations.
+    std::size_t mNumMaxIterations;
+
+    /// How many iterations between printing the Solver's progress to the
+    /// terminal. Use 0 for no printing.
+    std::size_t mIterationsPerPrint;
+
+    /// Stream for printing the Solver's progress. Default is std::cout.
+    std::ostream* mOutStream;
+
+    /// Set to true if the final result should be printed to the terminal.
+    bool mPrintFinalResult;
+
+    /// Publish the results of the optimization to a file. Leave this string
+    /// empty to avoid publishing anything.
+    std::string mResultFile;
+
+    Properties(
+        std::shared_ptr<Problem> _problem = nullptr,
+        double _tolerance = 1e-9,
+        std::size_t _numMaxIterations = 500,
+        std::size_t _iterationsPerPrint = 0,
+        std::ostream* _ostream = &std::cout,
+        bool _printFinalResult = false,
+        const std::string& _resultFile = "");
+  };
+
+  /// Default Constructor
+  explicit Solver(const Properties& _properties = Properties());
+
+  /// Alternative Constructor
+  explicit Solver(std::shared_ptr<Problem> _problem);
+
+  /// \brief Destructor
+  virtual ~Solver() = default;
+
+  /// Solve optimization problem
+  virtual bool solve() = 0;
+
+  /// Get the type (implementation) of this Solver
+  virtual std::string getType() const = 0;
+
+  /// Create an identical clone of this Solver
+  virtual std::shared_ptr<Solver> clone() const = 0;
+
+  /// Set the generic Properties of this Solver
+  void setProperties(const Properties& _properties);
+
+  /// Get the generic Properties of this Solver
+  const Properties& getSolverProperties() const;
+
+  /// Copy the generic Properties of another Solver
+  void copy(const Solver& _otherSolver);
+
+  /// Copy the generic Properties of another Solver
+  Solver& operator=(const Solver& _otherSolver);
+
+  /// Set the nonlinear optimization problem
+  virtual void setProblem(std::shared_ptr<Problem> _newProblem);
+
+  /// Get nonlinear optimization problem
+  std::shared_ptr<Problem> getProblem() const;
+
+  /// Set the maximum step size allowed for the Problem to be considered
+  /// converged
+  virtual void setTolerance(double _newTolerance);
+
+  /// Get the maximum step size allowed for the Problem to be considered
+  /// converged
+  double getTolerance() const;
+
+  /// Set the maximum number of iterations that the Solver should use
+  virtual void setNumMaxIterations(std::size_t _newMax);
+
+  /// Get the maximum number of iterations that the Solver should use
+  std::size_t getNumMaxIterations() const;
+
+  /// Set the number of iterations that should pass between printing progress to
+  /// the terminal. Use 0 for no printing.
+  virtual void setIterationsPerPrint(std::size_t _newRatio);
+
+  /// Get the number of iterations that should pass between printing progress to
+  /// the terminal. A value of 0 means there will be no printing.
+  std::size_t getIterationsPerPrint() const;
+
+  /// Set the output stream that prints the Solver's progress.
+  virtual void setOutStream(std::ostream* _os);
+
+  /// Get the output stream that prints the Solver's progress.
+  std::ostream* getOutStream() const;
+
+  /// Set to true if the final result should be printed to the terminal
+  virtual void setPrintFinalResult(bool _print);
+
+  /// Returns true if the final result should be printed to the terminal
+  bool getPrintFinalResult() const;
+
+  /// Set the name of the file that results should be printed to. Use an empty
+  /// string to indicate that results should not be printed to a file.
+  virtual void setResultFileName(const std::string& _resultFile);
+
+  /// Get the name of the file that results should be printed to. An empty
+  /// string indicates that results should not be printed to a file.
+  const std::string& getResultFileName() const;
+
+protected:
+  Properties mProperties;
+};
+
+} // namespace optimizer
+} // namespace dart
+
+#endif // DART_OPTIMIZER_SOLVER_HPP_

include/dart/optimizer/all.hpp

@@ -0,0 +1,10 @@
+// Automatically generated file by cmake
+
+#include "dart/optimizer/Function.hpp"
+#include "dart/optimizer/GenericMultiObjectiveProblem.hpp"
+#include "dart/optimizer/GradientDescentSolver.hpp"
+#include "dart/optimizer/MultiObjectiveProblem.hpp"
+#include "dart/optimizer/MultiObjectiveSolver.hpp"
+#include "dart/optimizer/Population.hpp"
+#include "dart/optimizer/Problem.hpp"
+#include "dart/optimizer/Solver.hpp"

include/dart/optimizer/ipopt/BackwardCompatibility.hpp

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *   POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef DART_OPTIMIZER_IPOPT_BACKWARDCOMPATIBILITY_HPP_
+#define DART_OPTIMIZER_IPOPT_BACKWARDCOMPATIBILITY_HPP_
+
+// clang-format off
+#define IPOPT_VERSION_GE(x,y,z) \
+  (IPOPT_VERSION_MAJOR > x || (IPOPT_VERSION_MAJOR >= x && \
+  (IPOPT_VERSION_MINOR > y || (IPOPT_VERSION_MINOR >= y && \
+  IPOPT_VERSION_PATCH >= z))))
+// clang-format on
+
+#endif // DART_OPTIMIZER_IPOPT_BACKWARDCOMPATIBILITY_HPP_

include/dart/optimizer/ipopt/IpoptSolver.hpp

@@ -0,0 +1,223 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *   POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef DART_OPTIMIZER_IPOPT_IPOPTSOLVER_HPP_
+#define DART_OPTIMIZER_IPOPT_IPOPTSOLVER_HPP_
+
+#include <dart/optimizer/ipopt/BackwardCompatibility.hpp>
+
+#include <memory>
+#if IPOPT_VERSION_GE(3, 13, 0)
+  #include <IpIpoptApplication.hpp>
+  #include <IpTNLP.hpp>
+#else
+  #include <coin/IpIpoptApplication.hpp>
+  #include <coin/IpTNLP.hpp>
+#endif
+
+#include <dart/optimizer/Solver.hpp>
+
+namespace dart {
+namespace optimizer {
+
+class Problem;
+class DartTNLP;
+
+/// \brief class IpoptSolver
+class IpoptSolver : public Solver
+{
+public:
+  /// Default constructor
+  IpoptSolver(const Solver::Properties& _properties = Solver::Properties());
+
+  /// Alternative Constructor
+  explicit IpoptSolver(std::shared_ptr<Problem> _problem);
+
+  /// Destructor
+  virtual ~IpoptSolver();
+
+  // Documentation inherited
+  bool solve() override;
+
+  // Documentation inherited
+  std::string getType() const override;
+
+  // Documentation inherited
+  std::shared_ptr<Solver> clone() const override;
+
+  /// Get the application interface for this IpoptSolver
+  const Ipopt::SmartPtr<Ipopt::IpoptApplication>& getApplication();
+
+  /// Get a const application interface for this IpoptSolver
+  Ipopt::SmartPtr<const Ipopt::IpoptApplication> getApplication() const;
+
+private:
+  /// Constructor used during cloning
+  IpoptSolver(
+      const Properties& _properties,
+      const Ipopt::SmartPtr<Ipopt::IpoptApplication>& _app);
+
+  /// IPOPT nonlinear programming problem
+  Ipopt::SmartPtr<Ipopt::TNLP> mNlp;
+
+  /// Main application class for making calls to Ipopt
+  Ipopt::SmartPtr<Ipopt::IpoptApplication> mIpoptApp;
+};
+
+/// class DartTNLP
+class DartTNLP : public Ipopt::TNLP
+{
+public:
+  friend class IpoptSolver;
+
+  /// \brief
+  virtual ~DartTNLP();
+
+  //------------------------- Ipopt::TNLP --------------------------------------
+  /// \brief Method to return some info about the nlp
+  bool get_nlp_info(
+      Ipopt::Index& n,
+      Ipopt::Index& m,
+      Ipopt::Index& nnz_jac_g,
+      Ipopt::Index& nnz_h_lag,
+      Ipopt::TNLP::IndexStyleEnum& index_style) override;
+
+  /// \brief Method to return the bounds for my problem
+  bool get_bounds_info(
+      Ipopt::Index n,
+      Ipopt::Number* x_l,
+      Ipopt::Number* x_u,
+      Ipopt::Index m,
+      Ipopt::Number* g_l,
+      Ipopt::Number* g_u) override;
+
+  /// \brief Method to return the starting point for the algorithm
+  bool get_starting_point(
+      Ipopt::Index n,
+      bool init_x,
+      Ipopt::Number* x,
+      bool init_z,
+      Ipopt::Number* z_L,
+      Ipopt::Number* z_U,
+      Ipopt::Index m,
+      bool init_lambda,
+      Ipopt::Number* lambda) override;
+
+  /// \brief Method to return the objective value
+  bool eval_f(
+      Ipopt::Index _n,
+      const Ipopt::Number* _x,
+      bool _new_x,
+      Ipopt::Number& _obj_value) override;
+
+  /// \brief Method to return the gradient of the objective
+  bool eval_grad_f(
+      Ipopt::Index _n,
+      const Ipopt::Number* _x,
+      bool _new_x,
+      Ipopt::Number* _grad_f) override;
+
+  /// \brief Method to return the constraint residuals
+  bool eval_g(
+      Ipopt::Index _n,
+      const Ipopt::Number* _x,
+      bool _new_x,
+      Ipopt::Index _m,
+      Ipopt::Number* _g) override;
+
+  /// \brief Method to return:
+  ///        1) The structure of the jacobian (if "values" is nullptr)
+  ///        2) The values of the jacobian (if "values" is not nullptr)
+  bool eval_jac_g(
+      Ipopt::Index _n,
+      const Ipopt::Number* _x,
+      bool _new_x,
+      Ipopt::Index _m,
+      Ipopt::Index _nele_jac,
+      Ipopt::Index* _iRow,
+      Ipopt::Index* _jCol,
+      Ipopt::Number* _values) override;
+
+  /// \brief Method to return:
+  ///        1) The structure of the hessian of the lagrangian (if "values" is
+  ///           nullptr)
+  ///        2) The values of the hessian of the lagrangian (if "values" is not
+  ///           nullptr)
+  bool eval_h(
+      Ipopt::Index _n,
+      const Ipopt::Number* _x,
+      bool _new_x,
+      Ipopt::Number _obj_factor,
+      Ipopt::Index _m,
+      const Ipopt::Number* _lambda,
+      bool _new_lambda,
+      Ipopt::Index _nele_hess,
+      Ipopt::Index* _iRow,
+      Ipopt::Index* _jCol,
+      Ipopt::Number* _values) override;
+
+  /// \brief This method is called when the algorithm is complete so the TNLP
+  ///        can store/write the solution
+  void finalize_solution(
+      Ipopt::SolverReturn _status,
+      Ipopt::Index _n,
+      const Ipopt::Number* _x,
+      const Ipopt::Number* _z_L,
+      const Ipopt::Number* _z_U,
+      Ipopt::Index _m,
+      const Ipopt::Number* _g,
+      const Ipopt::Number* _lambda,
+      Ipopt::Number _obj_value,
+      const Ipopt::IpoptData* _ip_data,
+      Ipopt::IpoptCalculatedQuantities* _ip_cq) override;
+
+private:
+  /// \brief
+  explicit DartTNLP(IpoptSolver* _solver);
+
+  /// \brief DART optimization problem
+  IpoptSolver* mSolver;
+
+  /// \brief Objective value
+  Ipopt::Number mObjValue;
+
+  /// \brief Objective gradient
+  Eigen::VectorXd mObjGradient;
+
+  /// \brief Objective Hessian
+  Eigen::MatrixXd mObjHessian;
+};
+
+} // namespace optimizer
+} // namespace dart
+
+#endif // DART_OPTIMIZER_IPOPT_IPOPTSOLVER_HPP_

include/dart/optimizer/ipopt/all.hpp

@@ -0,0 +1,4 @@
+// Automatically generated file by cmake
+
+#include "dart/optimizer/ipopt/BackwardCompatibility.hpp"
+#include "dart/optimizer/ipopt/IpoptSolver.hpp"

include/dart/optimizer/ipopt/ipopt.hpp

@@ -0,0 +1,14 @@
+// Automatically generated file by cmake
+
+// DEPRECATED: This header is deprecated and will be removed in the next major release.
+// Please use <dart/optimizer/ipopt/all.hpp> instead of <dart/optimizer/ipopt/ipopt.hpp>
+
+#ifndef DART_SUPPRESS_DEPRECATED_HEADER_WARNING
+#if defined(_MSC_VER)
+#  pragma message("Warning: dart/optimizer/ipopt/ipopt.hpp is deprecated. Use dart/optimizer/ipopt/all.hpp instead.")
+#elif defined(__GNUC__) || defined(__clang__)
+#  warning "dart/optimizer/ipopt/ipopt.hpp is deprecated. Use dart/optimizer/ipopt/all.hpp instead."
+#endif
+#endif // DART_SUPPRESS_DEPRECATED_HEADER_WARNING
+
+#include "dart/optimizer/ipopt/all.hpp"

include/dart/optimizer/nlopt/NloptSolver.hpp

@@ -0,0 +1,212 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *   POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef DART_OPTIMIZER_NLOPT_NLOPTSOLVER_HPP_
+#define DART_OPTIMIZER_NLOPT_NLOPTSOLVER_HPP_
+
+#include <dart/optimizer/Solver.hpp>
+
+#include <dart/common/Deprecated.hpp>
+
+#include <nlopt.hpp>
+
+#define NLOPT_VERSION_GE(x, y, z)                                              \
+  ((NLOPT_MAJOR_VERSION > (x))                                                 \
+   || (NLOPT_MAJOR_VERSION == (x) && NLOPT_MINOR_VERSION > (y))                \
+   || (NLOPT_MAJOR_VERSION == (x) && NLOPT_MINOR_VERSION == (y)                \
+       && NLOPT_PATCH_VERSION >= (z)))
+
+namespace dart {
+namespace optimizer {
+
+class Problem;
+
+/// NloptSolver is a nonlinear programming solver that provides many underlying
+/// algorithms through nlopt (an third-party library:
+/// https://nlopt.readthedocs.io/).
+///
+/// The algorithms falls into four categories:
+///   (1) Global derivative-free
+///   (2) Global gradient-based
+///   (3) Local derivative-free
+///   (4) Local gradient-based,
+/// which can be specified by NloptSolver::Algorithm. The element of NloptSolver
+/// are mostly of the form NLOPT_{G,L}{N,D}_xxxx, where G/L denotes global/local
+/// optimization and N/D denotes derivative-free/gradient-based algorithms,
+/// respectively. For the details, please see:
+/// https://nlopt.readthedocs.io/en/latest/NLopt_Algorithms/
+class NloptSolver : public Solver
+{
+public:
+  enum Algorithm
+  {
+    GN_DIRECT = 0,
+    GN_DIRECT_L,
+    GN_DIRECT_L_RAND,
+    GN_DIRECT_NOSCAL,
+    GN_DIRECT_L_NOSCAL,
+    GN_DIRECT_L_RAND_NOSCAL,
+    GN_ORIG_DIRECT,
+    GN_ORIG_DIRECT_L,
+    GD_STOGO,
+    GD_STOGO_RAND,
+#if !NLOPT_VERSION_GE(2, 9, 0)
+    LD_LBFGS_NOCEDAL,
+#endif
+    LD_LBFGS,
+    LN_PRAXIS,
+    LD_VAR1,
+    LD_VAR2,
+    LD_TNEWTON,
+    LD_TNEWTON_RESTART,
+    LD_TNEWTON_PRECOND,
+    LD_TNEWTON_PRECOND_RESTART,
+    GN_CRS2_LM,
+    GN_MLSL,
+    GD_MLSL,
+    GN_MLSL_LDS,
+    GD_MLSL_LDS,
+    LD_MMA,
+    LN_COBYLA,
+    LN_NEWUOA,
+    LN_NEWUOA_BOUND,
+    LN_NELDERMEAD,
+    LN_SBPLX,
+    LN_AUGLAG,
+    LD_AUGLAG,
+    LN_AUGLAG_EQ,
+    LD_AUGLAG_EQ,
+    LN_BOBYQA,
+    GN_ISRES,
+    AUGLAG,
+    AUGLAG_EQ,
+    G_MLSL,
+    G_MLSL_LDS,
+    LD_SLSQP,
+    LD_CCSAQ,
+    GN_ESCH,
+    NUM_ALGORITHMS ///< Not an algorithm, just the number of them
+  };
+
+  /// Default Constructor
+  DART_DEPRECATED(6.9)
+  NloptSolver(const Solver::Properties& properties, nlopt::algorithm alg);
+
+  /// Default Constructor
+  NloptSolver(
+      const Solver::Properties& properties = Solver::Properties(),
+      Algorithm alg = LN_COBYLA);
+
+  /// Alternative Constructor
+  DART_DEPRECATED(6.9)
+  NloptSolver(std::shared_ptr<Problem> problem, nlopt::algorithm alg);
+
+  /// Alternative Constructor
+  NloptSolver(std::shared_ptr<Problem> problem, Algorithm alg = LN_COBYLA);
+
+  /// Destructor
+  ~NloptSolver() override;
+
+  // Documentation inherited
+  bool solve() override;
+
+  // Documentation inherited
+  Eigen::VectorXd getLastConfiguration() const;
+
+  // Documentation inherited
+  std::string getType() const override;
+
+  // Documentation inherited
+  std::shared_ptr<Solver> clone() const override;
+
+  /// Copy the Properties of another NloptSolver
+  void copy(const NloptSolver& other);
+
+  /// Copy the Properties of another NloptSolver
+  NloptSolver& operator=(const NloptSolver& other);
+
+  /// Set the algorithm that is to be used by the nlopt solver
+  DART_DEPRECATED(6.9)
+  void setAlgorithm(nlopt::algorithm alg);
+
+  /// Set the algorithm that is to be used by the nlopt solver
+  void setAlgorithm(Algorithm alg);
+
+  /// Get the algorithm that is to be used by the nlopt solver
+  DART_DEPRECATED(6.9)
+  nlopt::algorithm getAlgorithm() const;
+
+  /// Get the algorithm that is to be used by the nlopt solver
+  Algorithm getAlgorithm2() const;
+  // TODO(JS): Rename to getAlgorithm2() once getAlgorithm() is removed in
+  // DART 7
+
+private:
+  /// Converts nlopt::algorithm to NloptSolver::Algorithm
+  static nlopt::algorithm convertAlgorithm(Algorithm algorithm);
+
+  /// Converts NloptSolver::Algorithm to nlopt::algorithm
+  static Algorithm convertAlgorithm(nlopt::algorithm algorithm);
+
+  /// Wrapping function for nlopt callback function, nlopt_func
+  static double _nlopt_func(
+      unsigned n,
+      const double* x,
+      double* gradient, // nullptr if not needed
+      void* func_data);
+
+  /// Wrapping function for nlopt callback function, nlopt_mfunc
+  static void _nlopt_mfunc(
+      unsigned m,
+      double* result,
+      unsigned n,
+      const double* x,
+      double* gradient, // nullptr if not needed
+      void* func_data);
+
+  /// NLOPT data structure
+  std::unique_ptr<nlopt::opt> mOpt;
+
+  /// Algorithm to be used by the nlopt::opt
+  nlopt::algorithm mAlg;
+
+  /// Optimization parameters
+  std::vector<double> mX;
+
+  /// Optimum value of the objective function
+  double mMinF;
+};
+
+} // namespace optimizer
+} // namespace dart
+
+#endif // DART_OPTIMIZER_NLOPT_NLOPTSOLVER_HPP_

include/dart/optimizer/nlopt/all.hpp

@@ -0,0 +1,3 @@
+// Automatically generated file by cmake
+
+#include "dart/optimizer/nlopt/NloptSolver.hpp"