SLSQPMinimizer.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2013 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#pragma once
 
#include "MantidKernel/DllConfig.h"
#include "MantidKernel/Matrix.h"
#include "MantidKernel/System.h"
 
#include <vector>
 
namespace Mantid {
namespace Kernel {
namespace Math {
class MANTID_KERNEL_DLL SLSQPMinimizer {
public:
  template <typename T>
  SLSQPMinimizer(const size_t nparams, const T &objfunc)
      : m_nparams(nparams), m_neq(0), m_nineq(0), m_objfunc(objfunc), m_constraintNorms() {}
 
  template <typename T>
  SLSQPMinimizer(const size_t nparams, const T &objfunc, const DblMatrix &equality, const DblMatrix &inequality)
      : m_nparams(nparams), m_neq(equality.numRows()), m_nineq(inequality.numRows()), m_objfunc(objfunc),
        m_constraintNorms() {
    initializeConstraints(equality, inequality);
  }
 
  SLSQPMinimizer() = delete;
 
  SLSQPMinimizer(const SLSQPMinimizer &) = delete;
 
  SLSQPMinimizer &operator=(const SLSQPMinimizer &) = delete;
 
  inline size_t numParameters() const { return m_nparams; }
  inline size_t numEqualityConstraints() const { return m_neq; }
  inline size_t numInequalityConstraints() const { return m_nineq; }
 
  std::vector<double> minimize(const std::vector<double> &x0) const;
 
private:
  inline double fvalue(const std::vector<double> &x) const { return m_objfunc.eval(x); }
  void fprime(std::vector<double> &grad, const std::vector<double> &x) const;
  void evaluateConstraints(std::vector<double> &constrValues, const std::vector<double> &x) const;
 
  void initializeConstraints(const DblMatrix &equality, const DblMatrix &inequality);
 
  class FunctionWrapper {
  private:
    class BaseHolder {
    public:
      virtual ~BaseHolder() = default;
      virtual double eval(const std::vector<double> &x) const = 0;
    };
    template <typename T> class TypeHolder : public BaseHolder {
    public:
      TypeHolder(const T &func) : func(func) {}
      double eval(const std::vector<double> &x) const override { return func.eval(x); }
      T func;
    };
 
  public:
    template <typename T> FunctionWrapper(const T &func) : m_funcHolder(std::make_unique<TypeHolder<T>>(func)) {}
    double eval(const std::vector<double> &x) const { return m_funcHolder->eval(x); }
    std::unique_ptr<BaseHolder> m_funcHolder;
  };
 
  const size_t m_nparams;
  const size_t m_neq;
  const size_t m_nineq;
 
  FunctionWrapper m_objfunc;
  mutable std::vector<double> m_constraintNorms;
};
 
} // namespace Math
} // namespace Kernel
} // namespace Mantid