function_traits.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
#include <kernel/base_header.hpp>
#include <kernel/analytic/common.hpp>
#include <kernel/util/tiny_algebra.hpp>
 
#include <deque>
namespace FEAT
{
  namespace Solver
  {
    template<typename DT_, typename Function_>
#ifndef DOXYGEN
    struct OptimizationTestTraits;
#else
    struct OptimizationTestTraits
    {
      typedef Function_ FunctionType;
      typedef Analytic::EvalTraits<DT_, FunctionType> FuncEvalTraits;
      typedef typename FunctionType::template Evaluator<FuncEvalTraits> EvalType;
      typedef typename EvalType::ValueType ValueType;
      typedef typename EvalType::PointType PointType;
 
      static void get_starting_point(PointType& start)
      {
      }
 
        static void get_minimal_points(std::deque<PointType>& min_points)
        {
        }
 
        template<int sn_>
        static void get_domain_bounds(Tiny::Vector<DT_, 2, sn_>& domain, int dim)
        {
        }
 
        static String name()
        {
        }
    };
#endif
 
    template<typename DT_>
    struct OptimizationTestTraits<DT_, Analytic::Common::BazaraaShettyFunction>
    {
      public:
        typedef Analytic::Common::BazaraaShettyFunction FunctionType;
        typedef Analytic::EvalTraits<DT_, FunctionType> FuncEvalTraits;
        typedef typename FunctionType::template Evaluator<FuncEvalTraits> EvalType;
        typedef typename EvalType::ValueType ValueType;
        typedef typename EvalType::PointType PointType;
 
        static void get_starting_point(PointType& start)
        {
          start(0) = DT_(4);
          start(1) = DT_(2);
        }
 
        static void get_minimal_points(std::deque<PointType>& min_points)
        {
          min_points.clear();
          PointType tmp(DT_(0));
          tmp(0) = DT_(2);
          tmp(1) = DT_(1);
          min_points.push_back(tmp);
        }
 
        template<int sn_>
        static void get_domain_bounds(Tiny::Vector<DT_, 2, sn_>& domain, int dim)
        {
          XASSERTM((dim >= 0) && (dim <= 2), "get_domain_bounds defined up to dim = 2, but got "+stringify(dim));
 
          domain(0) = -DT_(0.5);
          domain(1) = DT_(4.5);
        }
 
        static String name()
        {
          return "BazaraaShettyFunction";
        }
    };
 
    template<typename DT_>
    struct OptimizationTestTraits<DT_, Analytic::Common::GoldsteinPriceFunction>
    {
      public:
        typedef Analytic::Common::GoldsteinPriceFunction FunctionType;
        typedef Analytic::EvalTraits<DT_, FunctionType> FuncEvalTraits;
        typedef typename FunctionType::template Evaluator<FuncEvalTraits> EvalType;
        typedef typename EvalType::ValueType ValueType;
        typedef typename EvalType::PointType PointType;
 
        static void get_starting_point(PointType& start)
        {
          // This is a nice starting point
          //start(0) = -DT_(0.5);
          //start(1) = DT_(0.25);
 
          // Is is a hard starting point
          start(0) = DT_(1.5);
          start(1) = DT_(1.17);
        }
 
        static void get_minimal_points(std::deque<PointType>& min_points)
        {
          min_points.clear();
          PointType tmp(DT_(0));
 
          tmp(0) = DT_(0);
          tmp(1) = -DT_(1);
          min_points.push_back(tmp);
 
          tmp(0) = -DT_(0.6);
          tmp(1) = -DT_(0.4);
          min_points.push_back(tmp);
 
          tmp(0) = DT_(1.2);
          tmp(1) = DT_(0.8);
          min_points.push_back(tmp);
 
          tmp(0) = DT_(1.8);
          tmp(1) = DT_(0.2);
          min_points.push_back(tmp);
        }
 
        template<int sn_>
        static void get_domain_bounds(Tiny::Vector<DT_, 2, sn_>& domain, int dim)
        {
          XASSERTM((dim >= 0) && (dim <= 2), "get_domain_bounds defined up to dim = 2, but got "+stringify(dim));
 
          domain(0) = -DT_(0.2);
          domain(1) = DT_(0.2);
        }
 
        static String name()
        {
          return "GoldsteinPriceFunction";
        }
    };
 
    template<typename DT_>
    struct OptimizationTestTraits<DT_, Analytic::Common::HimmelblauFunction>
    {
      public:
        typedef Analytic::Common::HimmelblauFunction FunctionType;
        typedef Analytic::EvalTraits<DT_, FunctionType> FuncEvalTraits;
        typedef typename FunctionType::template Evaluator<FuncEvalTraits> EvalType;
        typedef typename EvalType::ValueType ValueType;
        typedef typename EvalType::PointType PointType;
 
        static void get_starting_point(PointType& start)
        {
          start(0) = DT_(1.5);
          start(1) = DT_(4);
        }
 
        static void get_minimal_points(std::deque<PointType>& min_points)
        {
          min_points.clear();
 
          PointType tmp(DT_(0));
 
          tmp(0) = -DT_(3.77931025337774689189076584129);
          tmp(1) = -DT_(3.28318599128616941226600051437);
          min_points.push_back(tmp);
 
          tmp(0) = -DT_(2.80511808695274485305357239809);
          tmp(1) =  DT_(3.13131251825057296580430072341);
          min_points.push_back(tmp);
 
          tmp(0) =  DT_(3);
          tmp(1) =  DT_(2);
          min_points.push_back(tmp);
 
          tmp(0) =  DT_(3.58442834033049174494433823938);
          tmp(1) = -DT_(1.84812652696440355353830020904);
          min_points.push_back(tmp);
        }
 
        template<int sn_>
        static void get_domain_bounds(Tiny::Vector<DT_, 2, sn_>& domain, int dim)
        {
          XASSERTM((dim >= 0) && (dim <= 2), "get_domain_bounds defined up to dim = 2, but got "+stringify(dim));
 
          domain(0) = DT_(1);
          domain(1) = DT_(4.5);
        }
 
        static String name()
        {
          return "HimmelblauFunction";
        }
    };
 
    template<typename DT_>
    struct OptimizationTestTraits<DT_, Analytic::Common::RosenbrockFunction>
    {
      public:
        typedef Analytic::Common::RosenbrockFunction FunctionType;
        typedef Analytic::EvalTraits<DT_, FunctionType> FuncEvalTraits;
        typedef typename FunctionType::template Evaluator<FuncEvalTraits> EvalType;
        typedef typename EvalType::ValueType ValueType;
        typedef typename EvalType::PointType PointType;
 
        static void get_starting_point(PointType& start)
        {
          start(0) = -DT_(1.9);
          start(1) = DT_(2);
        }
 
        static void get_minimal_points(std::deque<PointType>& min_points)
        {
          min_points.clear();
          min_points.push_back(PointType(DT_(1)));
        }
 
        template<int sn_>
        static void get_domain_bounds(Tiny::Vector<DT_, 2, sn_>& domain, int dim)
        {
          if(dim == 0)
          {
            domain(0) = -DT_(3);
            domain(1) = DT_(2);
          }
          else if(dim == 1)
          {
            domain(0) = -DT_(0.5);
            domain(1) = DT_(3.5);
          }
          else
            XABORTM("get_domain_bounds defined up to dim = 2, but got "+stringify(dim));
        }
 
        static String name()
        {
          return "RosenbrockFunction";
        }
    };
 
  } // namespace Solver
} // namespace FEAT