nonlinear_algebra.h

/* Copyright (C) 2004-2009 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 NONLINEAR_ALGEBRA_H_
#define NONLINEAR_ALGEBRA_H_
 
#include "fmatvec/fmatvec.h"
#include "mbsim/functions/function.h"
 
namespace MBSim {
 
  class RegulaFalsi {
    public:
      /*
       * \brief constructor
       * \param root function
       */
      RegulaFalsi(Function<double(double)> *f);
 
      /* GETTER / SETTER */
      int getNumberOfIterations() const { return it; };
      int getInfo() const { return info; };
      void setMaximumNumberOfIterations(int itmax_) { itmax = itmax_; }
      void setTolerance(double tol_) { tol = tol_; }
      /***************************************************/
 
      double solve(double a, double b);
 
    private:
      Function<double(double)> *func;
 
      int itmax, it, info;
 
      double tol;
  };
 
  class MultiDimFixPointIteration {
    public:
      /*
       * \brief constructor
       * \param fct pointer to used fix-point-function
       */
      MultiDimFixPointIteration(Function<fmatvec::Vec(fmatvec::Vec)> *function_);
 
      /* GETTER / SETTER */
      /*
       * \brief returns info of iteration progress
       * info == 0 :  a solution has been found
       * info == -1:  no converge
       * info == 1:   process (seems to) converge but hasn't finished
       */
      int getInfo() {
        return info;
      }
      std::vector<double> getNorms() {
        return norms;
      }
      double getNumberOfIterations() {
        return iter;
      }
      double getNumberOfMaximalIterations() {
        return itermax;
      }
      void setNumberOfMaximalIterations(int itermax_) {
        itermax = itermax_;
      }
      double getTolerance() {
        return tol;
      }
      void setTolerance(double tol_) {
        tol = tol_;
      }
      /*******************/
 
      fmatvec::Vec solve(const fmatvec::Vec &initialGuess);
 
    private:
      Function<fmatvec::Vec(fmatvec::Vec)> *function;
 
      double tol;
 
      int iter;
 
      double itermax;
 
      std::vector<double> norms;
 
      int info;
  };
 
  class NewtonMethod {
    public:
      /*
       * \brief constructor
       * \param root function
       * \param Jacobian matrix
       */
      NewtonMethod(Function<double(double)> *fct_, Function<double(double)> *jac_=nullptr);
 
      /* GETTER / SETTER */
      int getNumberOfIterations() const { return iter; }
      int getInfo() const { return info; }
      void setMaximumNumberOfIterations(int itmax_) { itmax = itmax_; }
      void setMaximumDampingSteps(int kmax_) { kmax = kmax_; }
      void setTolerance(double tol_) { tol = tol_; }
      /***************************************************/
 
      double solve(const double &x);
 
    private:
      Function<double(double)> *fct;
 
      Function<double(double)> *jac;
 
      int itmax, iter, kmax, info;
 
      double tol;
  };
 
  class MultiDimNewtonMethod {
    public:
      /*
       * \brief constructor
       * \param root function
       * \param Jacobian matrix
       */
      MultiDimNewtonMethod(Function<fmatvec::Vec(fmatvec::Vec)> *fct_, Function<fmatvec::SqrMat(fmatvec::Vec)> *jac_=nullptr);
 
      /* GETTER / SETTER */
      int getNumberOfIterations() const { return iter; }
      int getNumberOfMaximalIterations() const { return itmax; }
      int getInfo() const { return info; }
      std::vector<double> getNorms() { return norms; }
      void setMaximumNumberOfIterations(int itmax_) { itmax = itmax_; }
      void setMaximumDampingSteps(int kmax_) { kmax = kmax_; }
      void setTolerance(double tol_) { tol = tol_; }
      void setLinearAlgebra(int linAlg_) { linAlg = linAlg_; }
      /***************************************************/
 
      fmatvec::Vec solve(const fmatvec::Vec &x);
 
    private:
      Function<fmatvec::Vec(fmatvec::Vec)> *fct;
 
      Function<fmatvec::SqrMat(fmatvec::Vec)> *jac;
 
      int itmax, iter, kmax, info;
 
      std::vector<double> norms;
 
      double tol;
 
      int linAlg;
  };
  
}
 
#endif /* NONLINEAR_ALGEBRA_H_ */