criteria_functions.h

/* Copyright (C) 2004-2012 MBSim Development Team
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 *
 * Contact: martin.o.foerg@googlemail.com
 */
 
#ifndef NUMERICSCRITERIAFUNCTIONS_H_
#define NUMERICSCRITERIAFUNCTIONS_H_
 
#include <fmatvec/fmatvec.h>
#include <mbsim/functions/function.h>
 
#include <map>
 
namespace MBSim {
 
  class CriteriaFunction : public Function<int(fmatvec::Vec)> {
 
    public:
      CriteriaFunction();
 
      ~CriteriaFunction() override;
 
      /* GETTER / SETTER*/
      void setFunction(Function<fmatvec::Vec(fmatvec::Vec)> *function_) {
        function = function_;
      }
      /*****************/
 
      int operator ()(const fmatvec::Vec & vector) override = 0;
 
      virtual void clear() = 0;
 
      virtual bool isBetter(const fmatvec::Vec & vector, const fmatvec::Vec & fVal = fmatvec::Vec(0,fmatvec::NONINIT)) = 0;
 
    protected:
      Function<fmatvec::Vec(fmatvec::Vec)> *function{nullptr};
 
  };
 
  class GlobalCriteriaFunction : public CriteriaFunction {
 
    public:
      GlobalCriteriaFunction(const double & tolerance_ = 1e-10);
 
      ~GlobalCriteriaFunction() override;
 
      /* INHERITED INTERFACE */
      int operator ()(const fmatvec::Vec & vector) override;
      bool isBetter(const fmatvec::Vec & vector, const fmatvec::Vec & fVal = fmatvec::Vec(0,fmatvec::NONINIT)) override;
      void clear() override;
      /*END - INHERITED INTERFACE*/
 
      const std::vector<double> & getResults() {
        return criteriaResults;
      }
 
      void setTolerance(double tol) {
        tolerance = tol;
      }
 
    protected:
      /*INHERITED INTERFACE*/
      virtual double computeResults(const fmatvec::Vec & x, const fmatvec::Vec & fVal = fmatvec::Vec(0,fmatvec::NONINIT)) = 0;
      /********************/
 
      double tolerance;
 
      std::vector<double> criteriaResults;
  };
 
  class LocalCriteriaFunction : public CriteriaFunction {
 
    public:
      LocalCriteriaFunction(std::map<fmatvec::RangeV, double>  tolerances_);
 
      ~LocalCriteriaFunction() override;
 
      /* INHERITED INTERFACE */
      int operator ()(const fmatvec::Vec & vector) override;
      bool isBetter(const fmatvec::Vec & vector, const fmatvec::Vec & fVal = fmatvec::Vec(0,fmatvec::NONINIT)) override;
      void clear() override;
      /*END - INHERITED INTERFACE*/
 
      virtual void setTolerances(const std::map<fmatvec::RangeV, double> & tolerances_) {
        tolerances = tolerances_;
      }
 
    protected:
      virtual std::vector<double> computeResults(const fmatvec::Vec & x, const fmatvec::Vec & fVal = fmatvec::Vec(0,fmatvec::NONINIT)) = 0;
 
      /*
       * \brief saves the tolerance for a specified index sets
       */
      std::map<fmatvec::RangeV, double> tolerances;
 
      std::vector<std::vector<double>> criteriaResults;
  };
 
  class GlobalResidualCriteriaFunction : public GlobalCriteriaFunction {
 
    public:
      GlobalResidualCriteriaFunction(const double & tolerance_ = 1e-10);
 
      ~GlobalResidualCriteriaFunction() override;
 
    protected:
      /* INHERITED INTERFACE */
      double computeResults(const fmatvec::Vec & x, const fmatvec::Vec & fVal = fmatvec::Vec(0,fmatvec::NONINIT)) override;
      /*END - INHERITED INTERFACE*/
  };
 
  class LocalResidualCriteriaFunction : public LocalCriteriaFunction {
 
    public:
      LocalResidualCriteriaFunction(const std::map<fmatvec::RangeV, double> & tolerances_);
 
      ~LocalResidualCriteriaFunction() override;
 
    protected:
 
      std::vector<double> computeResults(const fmatvec::Vec & x, const fmatvec::Vec & fVal = fmatvec::Vec(0,fmatvec::NONINIT)) override;
  };
 
  class GlobalShiftCriteriaFunction : public GlobalCriteriaFunction {
    public:
      GlobalShiftCriteriaFunction(const double & tolerance_ = 1e-10);
 
      ~GlobalShiftCriteriaFunction() override;
 
      virtual fmatvec::Vec getLastPoint() {
        return lastPoint;
      }
 
    protected:
      /* INHERITED INTERFACE */
      double computeResults(const fmatvec::Vec & x, const fmatvec::Vec & fVal = fmatvec::Vec(0,fmatvec::NONINIT)) override;
      /*END - INHERITED INTERFACE*/
 
      fmatvec::Vec lastPoint;
 
  };
 
  class LocalShiftCriteriaFunction : public LocalCriteriaFunction {
 
    public:
      LocalShiftCriteriaFunction(const std::map<fmatvec::RangeV, double> & tolerances_);
 
      ~LocalShiftCriteriaFunction() override;
 
      virtual fmatvec::Vec getLastPoint() {
        return lastPoint;
      }
 
    protected:
      std::vector<double> computeResults(const fmatvec::Vec & x, const fmatvec::Vec & fVal = fmatvec::Vec(0,fmatvec::NONINIT)) override;
 
      fmatvec::Vec lastPoint;
  };
 
  inline CriteriaFunction::~CriteriaFunction()= default;
  inline GlobalCriteriaFunction::~GlobalCriteriaFunction()= default;
  inline LocalCriteriaFunction::~LocalCriteriaFunction()= default;
  inline GlobalResidualCriteriaFunction::~GlobalResidualCriteriaFunction() = default;
  inline GlobalShiftCriteriaFunction::~GlobalShiftCriteriaFunction() = default;
  inline LocalResidualCriteriaFunction::~LocalResidualCriteriaFunction() = default;
  inline LocalShiftCriteriaFunction::~LocalShiftCriteriaFunction() = default;
}
#endif //NUMERICSCRITERIAFUNCTIONS_H_