dartpy 7.0.0.dev0__cp312-cp312-manylinux_2_39_x86_64.whl

include/dart/optimizer/MultiObjectiveProblem.hpp

@@ -0,0 +1,168 @@
+/*
+ * 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_MULTIOBJECTIVEPROBLEM_HPP_
+#define DART_OPTIMIZER_MULTIOBJECTIVEPROBLEM_HPP_
+
+#include <dart/optimizer/Function.hpp>
+
+#include <Eigen/Dense>
+
+#include <vector>
+
+#include <cstddef>
+
+namespace dart {
+namespace optimizer {
+
+class MultiObjectiveProblem
+{
+public:
+  /// Constructor
+  explicit MultiObjectiveProblem(std::size_t dim, std::size_t integerDim = 0u);
+
+  /// Destructor
+  virtual ~MultiObjectiveProblem() = default;
+
+  /// \{ \name Solution
+
+  /// Sets the dimension of the solution.
+  ///
+  /// The element type of the solution can be either \c double or \c int. In the
+  /// case that the solution partially contains integers, we assume the integer
+  /// part takes place the tail of the solution, and the size of the integer
+  /// part is \p integerDim. For example, a solution vector can be
+  /// <tt>[floating1, floating2, ..., int1, int2]</tt>.
+  ///
+  /// Note that the \p dim represents the whole dimension of the solution so
+  /// that the dimension of floating-point part is to be (\p dim -
+  /// \p integerDim).
+  ///
+  /// By default, we assume the solution is homogeneously floating-point type (
+  /// i.e., \p integerDim is zero).
+  ///
+  /// \param[in] dim Total dimension of the solution.
+  /// \param[in] integerDim The dimension of integer part in the solution.
+  virtual void setSolutionDimension(
+      std::size_t dim, std::size_t integerDim = 0u);
+
+  /// Returns dimension of the solution
+  virtual std::size_t getSolutionDimension() const;
+
+  /// Returns dimension of the floating-point part of the solution
+  std::size_t getDoubleDimension() const;
+
+  /// Sets dimension of the integers in the decision vector
+  virtual void setIntegerDimension(std::size_t dim);
+
+  /// Returns dimension of the integers in the decision vector
+  virtual std::size_t getIntegerDimension() const;
+
+  /// Sets lower bounds for optimization parameters
+  void setLowerBounds(const Eigen::VectorXd& lb);
+
+  /// Returns lower bounds for optimization parameters
+  const Eigen::VectorXd& getLowerBounds() const;
+
+  /// Sets upper bounds for optimization parameters
+  void setUpperBounds(const Eigen::VectorXd& ub);
+
+  /// Returns upper bounds for optimization parameters
+  const Eigen::VectorXd& getUpperBounds() const;
+
+  /// \}
+
+  /// \{ \name Objectives
+
+  /// Returns the total dimension of objective functions.
+  virtual std::size_t getObjectiveDimension() const = 0;
+
+  /// \}
+
+  /// \{ \name Equality Constraints
+
+  /// Returns the total dimension of equality constraints.
+  virtual std::size_t getEqConstraintDimension() const;
+
+  /// \}
+
+  /// \{ \name Inequality Constraints
+
+  /// Returns the total dimension of inequality constraints.
+  virtual std::size_t getIneqConstraintDimension() const;
+
+  /// \}
+
+  /// \{ \name Evaluations
+
+  /// Evaluates objectives
+  virtual Eigen::VectorXd evaluateObjectives(
+      const Eigen::VectorXd& x) const = 0;
+
+  /// Evaluates equality constraints
+  virtual Eigen::VectorXd evaluateEqConstraints(const Eigen::VectorXd& x) const;
+
+  /// Evaluates inequality constraints
+  virtual Eigen::VectorXd evaluateIneqConstraints(
+      const Eigen::VectorXd& x) const;
+
+  /// Return dimension of fitness
+  std::size_t getFitnessDimension() const;
+
+  /// Evaluates fitness, which is [objectives, equality constraints, inequality
+  /// constraints].
+  Eigen::VectorXd evaluateFitness(const Eigen::VectorXd& x) const;
+
+  /// \}
+
+  /// Prints information of this class to a stream.
+  virtual std::ostream& print(std::ostream& os) const;
+
+protected:
+  /// Dimension of the decision vector (or optimization parameters)
+  std::size_t mDimension;
+
+  /// Dimension of integer in the decision vector. The integers are placed in
+  /// the tail of the decision vector.
+  std::size_t mIntegerDimension;
+
+  /// Lower bounds for optimization parameters
+  Eigen::VectorXd mLowerBounds;
+
+  /// Upper bounds for optimization parameters
+  Eigen::VectorXd mUpperBounds;
+};
+
+} // namespace optimizer
+} // namespace dart
+
+#endif // DART_OPTIMIZER_MULTIOBJECTIVEPROBLEM_HPP_

include/dart/optimizer/MultiObjectiveSolver.hpp

@@ -0,0 +1,168 @@
+/*
+ * 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_MULTIOBJECTIVESOLVER_HPP_
+#define DART_OPTIMIZER_MULTIOBJECTIVESOLVER_HPP_
+
+#include <dart/optimizer/Population.hpp>
+
+#include <Eigen/Dense>
+
+#include <iostream>
+#include <memory>
+#include <vector>
+
+namespace dart {
+namespace optimizer {
+
+class MultiObjectiveProblem;
+
+/// Abstract class that provides a common interface for different
+/// multi-objective optimization solvers.
+///
+/// The different MultiObjectiveSolver implementations each use a different
+/// Pareto-optimization library, which could lead to differences in performance
+/// for various problem types. This base class allows the different
+/// MultiObjectiveSolver implementations to be swapped out with each other
+/// quickly and easily to help with testing, benchmarking, and experimentation.
+class MultiObjectiveSolver
+{
+public:
+  /// The MultiObjectiveSolver::Properties class contains Solver parameters that
+  /// are common to all MultiObjectiveSolver 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
+  {
+    /// Multi-objective optimization problem to be solved
+    std::shared_ptr<MultiObjectiveProblem> mProblem;
+
+    /// Number of populations
+    std::size_t mNumPopulations;
+
+    /// Number of decision vectors in one population
+    std::size_t mPopulationSize;
+
+    /// The maximum step size allowed for the Problem to be considered converged
+    double mTolerance;
+
+    /// How many iterations per evolution.
+    std::size_t mIterationsPerEvolution;
+
+    /// 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;
+
+    /// Constructor
+    Properties(
+        std::shared_ptr<MultiObjectiveProblem> problem = nullptr,
+        std::size_t numPopulations = 1u,
+        std::size_t populationSize = 100u,
+        double tolerance = 1e-9,
+        std::size_t numMaxIterations = 500u,
+        std::size_t iterationsPerPrint = 0u,
+        std::ostream* ostream = &std::cout,
+        bool printFinalResult = false);
+  };
+
+  /// Default constructor
+  explicit MultiObjectiveSolver(const Properties& properties = Properties());
+
+  /// Destructor
+  virtual ~MultiObjectiveSolver() = default;
+
+  /// Solve optimization problem
+  virtual bool solve(std::size_t numEvolutions = 1u) = 0;
+
+  /// Returns the type (implementation) of this Solver
+  virtual std::string getType() const = 0;
+
+  /// Creates an identical clone of this Solver
+  virtual std::shared_ptr<MultiObjectiveSolver> 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;
+
+  virtual void setProblem(std::shared_ptr<MultiObjectiveProblem> problem);
+
+  /// Get nonlinear optimization problem
+  std::shared_ptr<MultiObjectiveProblem> getProblem() const;
+
+  /// \{ \name Population
+
+  /// Sets the number of decision vectors in one population
+  void setPopulationSize(std::size_t size);
+
+  /// Return sthe number of decision vectors in one population
+  std::size_t getPopulationSize() const;
+
+  /// Sets the number of populations.
+  void setNumPopulations(std::size_t size);
+
+  /// Returns the number of populations.
+  std::size_t getNumPopulations() const;
+
+  /// Returns a population at \c index.
+  const Population& getPopulation(std::size_t index) const;
+
+  /// Returns all the populations.
+  const std::vector<Population>& getPopulations() const;
+
+  /// \}
+
+  /// Sets the number of iterations per evolution
+  void setNumIterationsPerEvolution(std::size_t maxIterations);
+
+  /// Returns the number of iterations per evolution
+  std::size_t getNumIterationsPerEvolution() const;
+
+protected:
+  /// Properties
+  Properties mProperties;
+
+  /// Populations
+  std::vector<Population> mPopulations;
+};
+
+} // namespace optimizer
+} // namespace dart
+
+#endif // DART_OPTIMIZER_MULTIOBJECTIVESOLVER_HPP_

include/dart/optimizer/Population.hpp

@@ -0,0 +1,108 @@
+/*
+ * 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_POPULATION_HPP_
+#define DART_OPTIMIZER_POPULATION_HPP_
+
+#include <dart/optimizer/MultiObjectiveProblem.hpp>
+
+#include <Eigen/Dense>
+
+#include <iostream>
+#include <memory>
+#include <random>
+
+namespace dart {
+namespace optimizer {
+
+class MultiObjectiveProblem;
+
+class Population
+{
+public:
+  /// Constructor
+  ///
+  /// Population stores a clone of a \p problem.
+  Population(
+      std::shared_ptr<MultiObjectiveProblem> problem,
+      std::size_t populationSize = 0u);
+
+  /// Returns the associated problem, which is always not null.
+  MultiObjectiveProblem* getProblem();
+
+  /// Returns the associated problem, which is always not null.
+  const MultiObjectiveProblem* getProblem() const;
+
+  /// Adds the decision vector at the back of the population. The corresponding
+  /// fitness vector will be evaulated and set.
+  void pushBack(const Eigen::VectorXd& x);
+
+  /// Adds the decision vector and the fitness vector at the back of the
+  /// population.
+  void pushBack(const Eigen::VectorXd& x, const Eigen::VectorXd& f);
+
+  /// Sets the decision vector. The corresponding fitness vector will be
+  /// evaulated and set.
+  void set(std::size_t index, const Eigen::VectorXd& x);
+
+  /// Sets the decision vector and fitness vector at \c index in the population
+  void set(
+      std::size_t index, const Eigen::VectorXd& x, const Eigen::VectorXd& f);
+
+  /// Returns the size of this population
+  std::size_t getSize() const;
+
+  /// Returns a decision vectors at \c index.
+  Eigen::VectorXd getDecisionVector(std::size_t index) const;
+
+  /// Returns a fitness vectors at \c index.
+  Eigen::VectorXd getFitnessVector(std::size_t index) const;
+
+  /// Prints information of this class to a stream.
+  std::ostream& print(std::ostream& os) const;
+
+protected:
+  /// Multi-objective problem that this population is accosiated with. This is
+  /// always not null.
+  std::shared_ptr<MultiObjectiveProblem> mProblem;
+
+  /// Decision vectors. A column represents a decision vector.
+  Eigen::MatrixXd mPopulation;
+
+  /// Fitness vectors. A column represents a fitness vector.
+  Eigen::MatrixXd mFitness;
+};
+
+} // namespace optimizer
+} // namespace dart
+
+#endif // DART_OPTIMIZER_POPULATION_HPP_

include/dart/optimizer/Problem.hpp

@@ -0,0 +1,191 @@
+/*
+ * 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_PROBLEM_HPP_
+#define DART_OPTIMIZER_PROBLEM_HPP_
+
+#include <dart/optimizer/Function.hpp>
+
+#include <Eigen/Dense>
+
+#include <vector>
+
+#include <cstddef>
+
+namespace dart {
+namespace optimizer {
+
+/// \brief class Problem
+class Problem
+{
+public:
+  /// \brief Constructor
+  explicit Problem(std::size_t _dim = 0);
+
+  /// \brief Destructor
+  virtual ~Problem() = default;
+
+  //--------------------------- Problem Setting --------------------------------
+  /// \brief Set dimension. Note: Changing the dimension will clear out the
+  /// initial guess and any seeds that have been added.
+  void setDimension(std::size_t _dim);
+
+  /// \brief Get dimension
+  std::size_t getDimension() const;
+
+  /// \brief Set initial guess for opimization parameters
+  void setInitialGuess(const Eigen::VectorXd& _initGuess);
+
+  /// \brief Set initial guess for opimization parameters
+  const Eigen::VectorXd& getInitialGuess() const;
+
+  /// \brief Add a seed for the Solver to use as a hint for the neighborhood of
+  /// the solution.
+  void addSeed(const Eigen::VectorXd& _seed);
+
+  /// \brief Get a mutable reference of the seed for the specified index. If an
+  /// out-of-bounds index is provided a warning will print, and a reference to
+  /// the initial guess will be returned instead.
+  Eigen::VectorXd& getSeed(std::size_t _index);
+
+  /// \brief An immutable version of getSeed(std::size_t)
+  const Eigen::VectorXd& getSeed(std::size_t _index) const;
+
+  /// \brief Get a mutable reference to the full vector of seeds that this
+  /// Problem currently contains
+  std::vector<Eigen::VectorXd>& getSeeds();
+
+  /// \brief An immutable version of getSeeds()
+  const std::vector<Eigen::VectorXd>& getSeeds() const;
+
+  /// \brief Clear the seeds that this Problem currently contains
+  void clearAllSeeds();
+
+  /// \brief Set lower bounds for optimization parameters
+  void setLowerBounds(const Eigen::VectorXd& _lb);
+
+  /// \brief Get lower bounds for optimization parameters
+  const Eigen::VectorXd& getLowerBounds() const;
+
+  /// \brief Set upper bounds for optimization parameters
+  void setUpperBounds(const Eigen::VectorXd& _ub);
+
+  /// \brief Get upper bounds for optimization parameters
+  const Eigen::VectorXd& getUpperBounds() const;
+
+  /// \brief Set minimum objective function
+  void setObjective(FunctionPtr _obj);
+
+  /// \brief Get objective function
+  FunctionPtr getObjective() const;
+
+  /// \brief Add equality constraint
+  void addEqConstraint(FunctionPtr _eqConst);
+
+  /// \brief Add inequality constraint. Inequality constraints must evaluate
+  /// to LESS THAN or equal to zero (within some tolerance) to be satisfied.
+  void addIneqConstraint(FunctionPtr _ineqConst);
+
+  /// \brief Get number of equality constraints
+  std::size_t getNumEqConstraints() const;
+
+  /// \brief Get number of inequality constraints
+  std::size_t getNumIneqConstraints() const;
+
+  /// \brief Get equality constraint
+  FunctionPtr getEqConstraint(std::size_t _idx) const;
+
+  /// \brief Get inequality constraint
+  FunctionPtr getIneqConstraint(std::size_t _idx) const;
+
+  /// \brief Remove equality constraint
+  void removeEqConstraint(FunctionPtr _eqConst);
+
+  /// \brief Remove inequality constraint
+  void removeIneqConstraint(FunctionPtr _ineqConst);
+
+  /// \brief Remove all equality constraints
+  void removeAllEqConstraints();
+
+  /// \brief Remove all inequality constraints
+  void removeAllIneqConstraints();
+
+  //------------------------------ Result --------------------------------------
+  /// \brief Set optimum value of the objective function. This function called
+  ///        by Solver.
+  void setOptimumValue(double _val);
+
+  /// \brief Get optimum value of the objective function
+  double getOptimumValue() const;
+
+  /// \brief Set optimal solution. This function called by Solver.
+  void setOptimalSolution(const Eigen::VectorXd& _optParam);
+
+  /// \brief Get optimal solution
+  const Eigen::VectorXd& getOptimalSolution();
+
+protected:
+  /// \brief Dimension of this problem
+  std::size_t mDimension;
+
+  /// \brief Initial guess for optimization parameters
+  Eigen::VectorXd mInitialGuess;
+
+  /// \brief Additional guess hints for the Solver.
+  std::vector<Eigen::VectorXd> mSeeds;
+
+  /// \brief Lower bounds for optimization parameters
+  Eigen::VectorXd mLowerBounds;
+
+  /// \brief Upper bounds for optimization parameters
+  Eigen::VectorXd mUpperBounds;
+
+  /// \brief Objective function
+  FunctionPtr mObjective;
+
+  /// \brief Equality constraint functions
+  std::vector<FunctionPtr> mEqConstraints;
+
+  /// \brief Inequality constraint functions
+  std::vector<FunctionPtr> mIneqConstraints;
+
+  /// \brief Optimal objective value
+  double mOptimumValue;
+
+  /// \brief Optimal solution
+  Eigen::VectorXd mOptimalSolution;
+};
+
+} // namespace optimizer
+} // namespace dart
+
+#endif // #ifndef DART_OPTIMIZER_PROBLEM_HPP_