精华内容
下载资源
问答
  • 这是一种计算函数最小值的简单遗传算法。 它没有任何改进,但我有一些像精英主义、代沟和重整化这样的改进。
  • Matlab数学实验 - 斐波那契(Fibonacci)方法计算一元函数最小值一、斐波那契(Fibonacci)方法简介斐波那契(Fibonacci)方法基于斐波那契(Fibonacci)数列,关于fei数斐波那契以百度,在这就不说了。斐波那契方法,是一种...

    Matlab数学实验 - 斐波那契(Fibonacci)方法计算一元函数最小值

    一、斐波那契(Fibonacci)方法简介

    斐波那契(Fibonacci)方法基于斐波那契(Fibonacci)数列,关于fei数斐波那契以百度,在这就不说了。

    斐波那契方法,是一种计算最值的方法,其基本思想类似二分法,不断缩小区间,从而实现计算最小值。

    其缺点也是显而易见的,类似于二分法,只能求得局部的极值。是一种较为简单的计算方法。

    二、算法实现步骤

    (后续补上)

    三、算法代码

    斐波那契方法的代码如下:

    function anwser=method_fibonacci(a,b,e,formula)

    %% 斐波那契方法计算最小值(说明与示例)

    % a: 区间左端点

    % b: 区间右端点

    % e: 精确度(最终区间与初始区间的比值,小于1)

    % formula: 对应的公式,格式为文本格式,具体参见例子

    %

    % 例1:

    % method_fibonacci(-1,3,0.32,'x^2-x+2');

    %

    % 最小值横坐标为:

    % 0.5385

    %

    % 最小值解为:

    % 1.7515

    %

    %

    % 例2:

    % method_fibonacci(-1,3,0.01,'x^2-x+2');

    % 最小值横坐标为:

    % 0.5016

    %

    % 最小值解为:

    % 1.7500

    %% Step1 初始化

    c=(b-a)/e;

    n=1;

    f=formula;

    while fibonacci(n)=F2

    a=x1;

    x1=x2;

    F1=F2;

    x2=a+fibonacci(n-k-1)/fibonacci(n-k)*(b-a);

    F2=eval(f2);

    end

    end

    %% 精确值判断

    if F1=F2

    a=x1;

    end

    x1=x2-0.1*(b-a);

    F1=eval(f1);

    if F1F2

    anwser=0.5*(x1+b);

    end

    disp('最小值横坐标为:')

    disp(anwser)

    disp('最小值解为:')

    disp(eval(fa))

    % X1

    % X2

    % F1

    % F2

    end

    斐波那契数列函数代码如下:

    function f=fibonacci(n)

    % 用于产生斐波那契数

    n=n+1;

    if n>=0

    a=(1+sqrt(5))/2;

    b=(1-sqrt(5))/2;

    c=a.^n-b.^n;

    f=c/sqrt(5);

    else

    error('输入有误!请输入正整数(列)');

    end

    end

    四、样例

    ca701b7672b047242e94adb97262e4fc.png

    7b4e7cd18d64a2527295b18904f3606a.png

    展开全文
  • 牛顿法寻找函数最小值 %目标函数:f % 初始点:x0 % 精度:eps
  • 遗传算法求解函数最小值问题

    万次阅读 2019-05-17 10:21:51
    遗传算法求解函数最小值问题 继上一次用遗传算法求解TSP问题问题以后,万万没有想到,实验的时候,老师居然改了题目,改成了求解函数的最小值问题(有点坑哈),而且要求结果尽量的稳定,可以确定得到最小值,并且,...

    遗传算法求解函数最小值问题

    继上一次用遗传算法求解TSP问题问题以后,万万没有想到,实验的时候,老师居然改了题目,改成了求解函数的最小值问题(有点坑哈),而且要求结果尽量的稳定,可以确定得到最小值,并且,精度尽可能的高……虽然有点坑,不过老师还是简单的说明了一下基本的思路,思路和上一次没有太大的变化,唯一的难点就是怎样尽可能的提高解的精度。
    不管怎样,终究在实验课的时候解决了这个问题,唯一的问题就是进度最多10的负六次方,老师说他的精度可以达到10的负几百次方(膜拜……)。
    思路不变,选择用轮盘赌,变异要稍微变一下,具体会在下面讲解,废话少说,进入正题。.

    问题描述:

    设计高效遗传算法,求解下列函数在-5<=x1,x2<=5上的最小值:在这里插入图片描述
    在正式的开始求解之前,老师先将函数的图片展示了出来,如下图所示:
    在这里插入图片描述并且公布结果,在(0,0)的位置取得最小值0。
    在这个结果的基础上,我们开始试验。

    代码编写:

    首先是个体的类代码:

    class problem1_individual(object):
        def __init__(self, n1, n2):
            self.gene = [n1, n2]
            self.score = 0
        pass
    

    接着轮盘赌选择的代码,和上一次没有多少变化,同样是采用倒数的方式来作为个体的适配值,因为事先知道结果的最小值为0,所以采用倒数的方式很好,因为越接近0,倒数越大,被选中的概率就越大。
    代码如下所示:

    def roulette_wheel(self):
        """
        轮盘赌普通方法得到被选中的基因型
        :param individuals: 种群中各个基因类型的数量
        :return: 返回被选中的基因型的代号
        """
        all_individual = 0
        for i in range(len(self.list)):
            all_individual += 1 / self.list[i].score
        probabilities = []
        for i in range(len(self.list)):
            probabilities.append((1 / self.list[i].score) / all_individual)
        selected_individual = random.uniform(0, 1)
        now_individual = 0.0
        for ind, val in enumerate(probabilities):
            now_individual += val
            if now_individual > selected_individual:
                return self.list[ind]
    

    接着是交叉的代码。在编写之前还没有办法,个体是两个自变量,但是交叉怎么办?上网查了一下,有了思路,很简单,就是用不同的比例进行划分。
    随机生成一0-1的数字,作为其中一个父个体的基因比例,再用1减去这个数字,得到另一个父个体的基因比例,两者相加得到的就是最后的孩子的基因序列:

    def crossgene(self, parent1, parent2, index1, index2):
        child = [0, 0]
        child[0] = parent1.gene[0] * index1 + parent2.gene[0] * index2
        child[1] = parent1.gene[1] * index1 + parent2.gene[1] * index2
        return child
    
    def crossover(self, father, mother):
        """
        :param father: 需要进行遗传的父类个体
        :param mother: 需要进行遗传的母类个体
        :return:
        """
        x = random.randint(0, 9999)
        # 变异有概率,大于某个值就不发生,小于某个值就发生变异
        k = 10000 * self.variationrate
        if x < k:
            # 进行单点交换
            index1 = random.uniform(0, 1)
            index2 = 1 - index1
            child1 = self.crossgene(father, mother, index1, index2)
            child2 = self.crossgene(mother, father, index1, index2)
        else:
            child1 = father.gene
            child2 = mother.gene
        return child1, child2
    

    结果测试:

    代码编写完毕,现在进行测试,看看结果如何:

    from problem1_GA import problem1_GA
    
    test = problem1_GA(1, 1)
    test.initpopulation()
    for i in range(10000):
        test.next_generation()
        generation, answer, score = test.get_what_we_need()
        print(str(answer[0])+" "+str(answer[1])+" "+str(score))
        print()
        pass
    

    迭代次数就采用10000次,看看最后的结果达到什么样的精度:
    在这里插入图片描述
    运气不错,最后的结果精度可以达到10^-9次方的水平。当然这次是运气好,但是不是每一次都可以重现这种操作,我还会继续的进行代码的优化,下一次让结果有更好的精度。
    当然这都是后话。
    最后完整的代码就放在以下链接中
    遗传算法求解函数最小值问题
    提取码:v2y6
    还有上一次的文章缺少的CSDN链接,是tomcat的安装包和eclipse插件:
    CSDN—tomcat
    谢谢大家阅读!

    展开全文
  • 差分进化算法求解平方和函数最小值,VS2013编程,C++语言
  • 主要介绍了python使用梯度下降和牛顿法寻找Rosenbrock函数最小值实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • C语言 单纯形法求解函数最小值 单纯形法求解二位函数的最小值 初始单纯形顶点
  • scipy:fmin函数最小值和fsolve方程求解1.0 马玉华 2020.5.14 """ from scipy import optimize #函数最小值求解 def f(p): x,y = p z = (1-x)**2+100*(y-x**2)**2 return z minimun = optimize.fmin(f,[0,1]) #...

    标量(一元)函数定义域内最小值fminbound

    求给定范围内函数的最小值

    scipy.optimize.fminbound(func, x1, x2, args=(), xtol=1e-05, maxfun=500, full_output=0, disp=1)[source]

    return:
    xopt: 取最小值时自变量的值
    fval: 函数最小值
    ierr: 错误标志(如果收敛则为0,如果达到最大函数调用数则为1)
    numfunc: 迭代时调用函数的次数

    默认full_output=0,只返回数值xopt:最小值的自变量的值
    改为full_output=True,返回元组(xopt, fval, ierr, numfunc)

    示例:

    def H1(x):
        z = 4/5 *( ((3-x)**2)/4 + 1/x)
        return z
    
    p = optimize.fminbound(H1,1,5,full_output=True)
    print(p)
    

    输出

    (3.1958227932467116, 0.25799608410776015, 0, 9)
    

    标量(一元)、多元函数最小值fmin

    fmin本人暂时还不能在给定的定义域内求最值
    “”“2020.5.14"”"

    from scipy import optimize
    #函数最小值求解
    
    def f(p):
        x,y = p
        z = (1-x)**2+100*(y-x**2)**2+2
        return z
    coordinate = optimize.fmin(f,[0,1]) #迭代初始值p,从x,y=[0,1]开始寻找最小值
    print('坐标点:',coordinate)
    print('最小值:',f(coordinate))
    """
    

    输出结果

    Optimization terminated successfully.
             Current function value: 2.000000
             Iterations: 101
             Function evaluations: 191
    坐标点: [1.00000205 1.00000565]
    最小值: 2.000000000242887
    
    若出现超过最大计算次数Maximum number of function evaluations has been exceeded
    可以将输出的x,y值替换初始值,不断重复此操作。(较大可能是在这个区间内没有最小值)
    """
    

    若求最大值,只需要先求-f(x)的最小值min,就可以得到函数的最大值为-min了。

    非线性方程求解fsolve

    python的
    fsolve缺点:
    1.不完备解:只能给出多解中的一个解。
    2.无法求解:较难的情况时无法求解,会报错,并同时给出使用最小二乘法的错误解。

    fsolve优点:比matlab更精确(当与matlab不同结果时可进行验证,确实更精确)

    此外:
    非线性方程组的fsolve的数值方法采用的是牛顿法,原理同一元非线性函数求根,将一元推广到多元将一个函数推广到多个函数。
    在这里插入图片描述
    其中运算时会有雅可比行列式
    在这里插入图片描述
    雅可比行列式中的元素会影响牛顿法的收敛阶,甚至是牛顿的的收敛性。可将雅可比行列式中的元素缩小,如牛顿下山法。但是不可将其放大,因为牛顿法的收敛性依赖于迭代初值,如果给的迭代初值不合适可能会导致牛顿法发散。

    源码
    from scipy import optimize
    from math import sin
    #非线性方程求解
    
    def g(p):
        x0,x1,x2 = p   #此处的p为数组array
        return [
            x0+3*x1+3,
            x0**2+x2-25,
            x1*x2+sin(x0)
        ]
    
    result = optimize.fsolve(g,[5,-3,2])  #同样也要设置方程组自变量p的初始值
    print('解为',result)
    
    #验证结果,看每一个方程是否为零,因为此处的方程都写的是等于0的
    print('验证结果',g(result))
    

    输出结果:

    E:\Python\python科学计算\scipy\venv\Scripts\python.exe E:/Python/python科学计算/scipy/scipy2.2-optimize-函数最小值fmin和方程求解fsolve.py
    Optimization terminated successfully.
             Current function value: 0.000000
             Iterations: 101
             Function evaluations: 191
    [1.00000205 1.00000565]
    解为 [ 5.03528143 -2.67842714 -0.35405913]
    验证结果 [8.881784197001252e-16, -1.2434497875801753e-13, -1.5021317523178368e-12]
    
    进程已结束,退出代码 0
    
    展开全文
  • 求解函数最小值的自适应遗传算法 (Matlab程序)
  • 单纯形法求解多元函数最小值,自带约束,可以更好的求解带带约束条件的反演问题
  • boost::math模块使用 Brent 方法求函数最小值的示例实现功能C++实现代码 实现功能 boost::math模块使用 Brent 方法求函数最小值的示例 C++实现代码 #include <boost/math/tools/minima.hpp> #include <...

    boost::math模块使用 Brent 方法求函数最小值的示例

    实现功能

    boost::math模块使用 Brent 方法求函数最小值的示例

    C++实现代码

    #include <boost/math/tools/minima.hpp>
    #include <boost/math/special_functions/next.hpp>
    #include <boost/multiprecision/cpp_dec_float.hpp>
    #include <boost/math/special_functions/pow.hpp>
    #include <boost/math/constants/constants.hpp>
    #include <boost/test/tools/floating_point_comparison.hpp> // For is_close_at)tolerance and 
    #include <boost/multiprecision/cpp_dec_float.hpp> // For decimal boost::multiprecision::cpp_dec_float_50.
    #include <boost/multiprecision/cpp_bin_float.hpp> // For binary boost::multiprecision::cpp_bin_float_50;
    #ifdef BOOST_HAVE_QUADMATH  // Define only if GCC or Intel, and have quadmath.lib or .dll library available.
    #  include <boost/multiprecision/float128.hpp>
    #endif
    #include <iostream>
    // using std::cout; using std::endl;
    #include <iomanip>
    // using std::setw; using std::setprecision;
    #include <limits>
    using std::numeric_limits;
    #include <tuple>
    #include <utility> // pair, make_pair
    #include <type_traits>
    #include <typeinfo>
    double f(double x)
    {
      return (x + 3) * (x - 1) * (x - 1);
    }
    struct funcdouble
    {
      double operator()(double const& x)
      {
        return (x + 3) * (x - 1) * (x - 1); // (x + 3)(x - 1)^2
      }
    };
    struct func
    {
      template <class T>
      T operator()(T const& x)
      {
        return (x + 3) * (x - 1) * (x - 1); // (x + 3)(x - 1)^2
      }
    };
    template<typename FPT>
    inline bool
    is_close_to(FPT left, FPT right, FPT tolerance)
    {
      return boost::math::fpc::close_at_tolerance<FPT>(tolerance) (left, right);
    }
    template <class T>
    bool is_close(T expect, T got, T tolerance)
    {
      using boost::math::fpc::close_at_tolerance;
      using boost::math::fpc::is_small;
      using boost::math::fpc::FPC_STRONG;
    
      if (is_small<T>(expect, tolerance))
      {
        return is_small<T>(got, tolerance);
      }
    
      return close_at_tolerance<T>(tolerance, FPC_STRONG) (expect, got);
    } 
    template <class T>
    void show_minima()
    {
      using boost::math::tools::brent_find_minima;
      using std::sqrt;
      try
      { // Always use try'n'catch blocks with Boost.Math to ensure you get any error messages.
    
        int bits = std::numeric_limits<T>::digits/2; // Maximum is digits/2;
        std::streamsize prec = static_cast<int>(2 + sqrt((double)bits));  // Number of significant decimal digits.
        std::streamsize precision = std::cout.precision(prec); // Save and set.
    
        std::cout << "\n\nFor type: " << typeid(T).name()
          << ",\n  epsilon = " << std::numeric_limits<T>::epsilon()
          // << ", precision of " << bits << " bits"
          << ",\n  the maximum theoretical precision from Brent's minimization is "
          << sqrt(std::numeric_limits<T>::epsilon())
          << "\n  Displaying to std::numeric_limits<T>::digits10 " << prec << ", significant decimal digits."
          << std::endl;
    
        const boost::uintmax_t maxit = 20;
        boost::uintmax_t it = maxit;
        T bracket_min = static_cast<T>(-4);
        T bracket_max = static_cast<T>(1.3333333333333333333333333333333333333333333333333);
    
        std::pair<T, T> r = brent_find_minima<func, T>(func(), bracket_min, bracket_max, bits, it);
    
        std::cout << "  x at minimum = " << r.first << ", f(" << r.first << ") = " << r.second;
        if (it < maxit)
        {
          std::cout << ",\n  met " << bits << " bits precision" << ", after " << it << " iterations." << std::endl;
        }
        else
        {
          std::cout << ",\n  did NOT meet " << bits << " bits precision" << " after " << it << " iterations!" << std::endl;
        }
        // Check that result is that expected (compared to theoretical uncertainty).
        T uncertainty = sqrt(std::numeric_limits<T>::epsilon());
        std::cout << std::boolalpha << "x == 1 (compared to uncertainty " << uncertainty << ") is "
          << is_close(static_cast<T>(1), r.first, uncertainty) << std::endl;
        std::cout << std::boolalpha << "f(x) == (0 compared to uncertainty " << uncertainty << ") is "
          << is_close(static_cast<T>(0), r.second, uncertainty) << std::endl;
        // Problems with this using multiprecision with expression template on?
        std::cout.precision(precision);  // Restore.
      }
      catch (const std::exception& e)
      {
        std::cout <<
          "\n""Message from thrown exception was:\n   " << e.what() << std::endl;
      }
    } // void show_minima()
    
    int main()
    {
      using boost::math::tools::brent_find_minima;
      using std::sqrt;
      std::cout << "Brent's minimisation examples." << std::endl;
      std::cout << std::boolalpha << std::endl;
      std::cout << std::showpoint << std::endl; // Show trailing zeros.
      {
        std::cout << "\nType double - unlimited iterations (unwise?)" << std::endl;
      //[brent_minimise_double_1
        const int double_bits = std::numeric_limits<double>::digits;
        std::pair<double, double> r = brent_find_minima(funcdouble(), -4., 4. / 3, double_bits);
    
        std::streamsize precision_1 = std::cout.precision(std::numeric_limits<double>::digits10);
        // Show all double precision decimal digits and trailing zeros.
        std::cout << "x at minimum = " << r.first
          << ", f(" << r.first << ") = " << r.second << std::endl;
        //] [/brent_minimise_double_1]
        std::cout << "x at minimum = " << (r.first - 1.) / r.first << std::endl;
        // x at minimum = 1.00000000112345, f(1.00000000112345) = 5.04852568272458e-018
        double uncertainty = sqrt(std::numeric_limits<double>::epsilon());
        std::cout << "Uncertainty sqrt(epsilon) =  " << uncertainty << std::endl;
        // sqrt(epsilon) =  1.49011611938477e-008
        // (epsilon is always > 0, so no need to take abs value).
    
        std::cout.precision(precision_1); // Restore.
      //[brent_minimise_double_1a
    
      using boost::math::fpc::close_at_tolerance;
      using boost::math::fpc::is_small;
    
      std::cout << "x = " << r.first << ", f(x) = " << r.second << std::endl;
      std::cout << std::boolalpha << "x == 1 (compared to uncertainty "
        << uncertainty << ") is " << is_close(1., r.first, uncertainty) << std::endl; // true
      std::cout << std::boolalpha << "f(x) == 0 (compared to uncertainty "
        << uncertainty << ") is " << is_close(0., r.second, uncertainty) << std::endl; // true
    //] [/brent_minimise_double_1a]
    
      }
      std::cout << "\nType double with limited iterations." << std::endl;
      {
        const int bits = std::numeric_limits<double>::digits;
        // Specific type double - limit maxit to 20 iterations.
        std::cout << "Precision bits = " << bits << std::endl;
      //[brent_minimise_double_2
        const boost::uintmax_t maxit = 20;
        boost::uintmax_t it = maxit;
        std::pair<double, double> r = brent_find_minima(funcdouble(), -4., 4. / 3, bits, it);
        std::cout << "x at minimum = " << r.first << ", f(" << r.first << ") = " << r.second
          << " after " << it << " iterations. " << std::endl;
        //] [/brent_minimise_double_2]
          // x at minimum = 1.00000000112345, f(1.00000000112345) = 5.04852568272458e-018
    //[brent_minimise_double_3
      std::streamsize prec = static_cast<int>(2 + sqrt((double)bits));  // Number of significant decimal digits.
      std::streamsize precision_3 = std::cout.precision(prec); // Save and set new precision.
      std::cout << "Showing " << bits << " bits "
        "precision with " << prec
        << " decimal digits from tolerance " << sqrt(std::numeric_limits<double>::epsilon())
        << std::endl;
    
      std::cout << "x at minimum = " << r.first
        << ", f(" << r.first << ") = " << r.second
        << " after " << it << " iterations. " << std::endl;
      std::cout.precision(precision_3); // Restore.
      }
    
      std::cout << "\nType double with limited iterations and half double bits." << std::endl;
      {
    
    //[brent_minimise_double_4
      const int bits_div_2 = std::numeric_limits<double>::digits / 2; // Half digits precision (effective maximum).
      double epsilon_2 = boost::math::pow<-(std::numeric_limits<double>::digits/2 - 1), double>(2);
      std::streamsize prec = static_cast<int>(2 + sqrt((double)bits_div_2));  // Number of significant decimal digits.
    
      std::cout << "Showing " << bits_div_2 << " bits precision with " << prec
        << " decimal digits from tolerance " << sqrt(epsilon_2)
        << std::endl;
      std::streamsize precision_4 = std::cout.precision(prec); // Save.
      const boost::uintmax_t maxit = 20;
      boost::uintmax_t it_4 = maxit;
      std::pair<double, double> r = brent_find_minima(funcdouble(), -4., 4. / 3, bits_div_2, it_4);
      std::cout << "x at minimum = " << r.first << ", f(" << r.first << ") = " << r.second << std::endl;
      std::cout << it_4 << " iterations. " << std::endl;
      std::cout.precision(precision_4); // Restore.
      }
    
      {
        std::cout << "\nType double with limited iterations and quarter double bits." << std::endl;
      //[brent_minimise_double_5
        const int bits_div_4 = std::numeric_limits<double>::digits / 4; // Quarter precision.
        double epsilon_4 = boost::math::pow<-(std::numeric_limits<double>::digits / 4 - 1), double>(2);
        std::streamsize prec = static_cast<int>(2 + sqrt((double)bits_div_4));  // Number of significant decimal digits.
        std::cout << "Showing " << bits_div_4 << " bits precision with " << prec
          << " decimal digits from tolerance " << sqrt(epsilon_4)
          << std::endl;
        std::streamsize precision_5 = std::cout.precision(prec); // Save & set.
        const boost::uintmax_t maxit = 20;
    
        boost::uintmax_t it_5 = maxit;
        std::pair<double, double> r = brent_find_minima(funcdouble(), -4., 4. / 3, bits_div_4, it_5);
        std::cout << "x at minimum = " << r.first << ", f(" << r.first << ") = " << r.second
        << ", after " << it_5 << " iterations. " << std::endl;
        std::cout.precision(precision_5); // Restore.
      }
    
      {
        std::cout << "\nType long double with limited iterations and all long double bits." << std::endl;
    //[brent_minimise_template_1
        std::streamsize precision_t1 = std::cout.precision(std::numeric_limits<long double>::digits10); // Save & set.
        long double bracket_min = -4.;
        long double bracket_max = 4. / 3;
        const int bits = std::numeric_limits<long double>::digits;
        const boost::uintmax_t maxit = 20;
        boost::uintmax_t it = maxit;
    
        std::pair<long double, long double> r = brent_find_minima(func(), bracket_min, bracket_max, bits, it);
        std::cout << "x at minimum = " << r.first << ", f(" << r.first << ") = " << r.second
          << ", after " << it << " iterations. " << std::endl;
        std::cout.precision(precision_t1);  // Restore.
    //] [/brent_minimise_template_1]
      }
      show_minima<float>();
      show_minima<double>();
      show_minima<long double>();
    
     //] [/brent_minimise_template_fd]
    
    //[brent_minimise_mp_include_1
    #ifdef BOOST_HAVE_QUADMATH  // Defined only if GCC or Intel and have quadmath.lib or .dll library available.
      using boost::multiprecision::float128;
    #endif
    //] [/brent_minimise_mp_include_1]
    
    //[brent_minimise_template_quad
    #ifdef BOOST_HAVE_QUADMATH  // Defined only if GCC or Intel and have quadmath.lib or .dll library available.
      show_minima<float128>(); // Needs quadmath_snprintf, sqrtQ, fabsq that are in in quadmath library.
    #endif
    
      using boost::multiprecision::cpp_bin_float_50; // binary multiprecision typedef.
      using boost::multiprecision::cpp_dec_float_50; // decimal multiprecision typedef.
    
      // One might also need typedefs like these to switch expression templates off and on (default is on).
      typedef boost::multiprecision::number<boost::multiprecision::cpp_bin_float<50>,
        boost::multiprecision::et_on>
        cpp_bin_float_50_et_on;  // et_on is default so is same as cpp_bin_float_50.
    
      typedef boost::multiprecision::number<boost::multiprecision::cpp_bin_float<50>,
        boost::multiprecision::et_off>
        cpp_bin_float_50_et_off;
    
      typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>,
        boost::multiprecision::et_on> // et_on is default so is same as cpp_dec_float_50.
        cpp_dec_float_50_et_on;
    
      typedef boost::multiprecision::number<boost::multiprecision::cpp_dec_float<50>,
        boost::multiprecision::et_off>
        cpp_dec_float_50_et_off;
    //] [/brent_minimise_mp_typedefs]
    
      { // binary ET on by default.
    //[brent_minimise_mp_1
        std::cout.precision(std::numeric_limits<cpp_bin_float_50>::digits10);
        int bits = std::numeric_limits<cpp_bin_float_50>::digits / 2 - 2;
        cpp_bin_float_50 bracket_min = static_cast<cpp_bin_float_50>("-4");
        cpp_bin_float_50 bracket_max = static_cast<cpp_bin_float_50>("1.3333333333333333333333333333333333333333333333333");
    
        std::cout << "Bracketing " << bracket_min << " to " << bracket_max << std::endl;
        const boost::uintmax_t maxit = 20;
        boost::uintmax_t it = maxit; // Will be updated with actual iteration count.
        std::pair<cpp_bin_float_50, cpp_bin_float_50> r
          = brent_find_minima(func(), bracket_min, bracket_max, bits, it);
    
        std::cout << "x at minimum = " << r.first << ",\n f(" << r.first << ") = " << r.second
        // x at minimum = 1, f(1) = 5.04853e-018
          << ", after " << it << " iterations. " << std::endl;
    
        is_close_to(static_cast<cpp_bin_float_50>("1"), r.first, sqrt(std::numeric_limits<cpp_bin_float_50>::epsilon()));
        is_close_to(static_cast<cpp_bin_float_50>("0"), r.second, sqrt(std::numeric_limits<cpp_bin_float_50>::epsilon()));
        show_minima<cpp_bin_float_50_et_on>(); //
    //] [/brent_minimise_mp_2]
    
    
      }
    
      { // binary ET on explicit
        std::cout.precision(std::numeric_limits<cpp_bin_float_50_et_on>::digits10);
    
        int bits = std::numeric_limits<cpp_bin_float_50_et_on>::digits / 2 - 2;
    
        cpp_bin_float_50_et_on bracket_min = static_cast<cpp_bin_float_50_et_on>("-4");
        cpp_bin_float_50_et_on bracket_max = static_cast<cpp_bin_float_50_et_on>("1.3333333333333333333333333333333333333333333333333");
    
        std::cout << bracket_min << " " << bracket_max << std::endl;
        const boost::uintmax_t maxit = 20;
        boost::uintmax_t it = maxit;
        std::pair<cpp_bin_float_50_et_on, cpp_bin_float_50_et_on> r = brent_find_minima(func(), bracket_min, bracket_max, bits, it);
    
        std::cout << "x at minimum = " << r.first << ", f(" << r.first << ") = " << r.second << std::endl;
        // x at minimum = 1, f(1) = 5.04853e-018
        std::cout << it << " iterations. " << std::endl;
    
        show_minima<cpp_bin_float_50_et_on>(); //
    
      }
      return 0;
    
      // Some examples of switching expression templates on and off follow.
    
      { // binary ET off
        std::cout.precision(std::numeric_limits<cpp_bin_float_50_et_off>::digits10);
    
        int bits = std::numeric_limits<cpp_bin_float_50_et_off>::digits / 2 - 2;
        cpp_bin_float_50_et_off bracket_min = static_cast<cpp_bin_float_50_et_off>("-4");
        cpp_bin_float_50_et_off bracket_max = static_cast<cpp_bin_float_50_et_off>("1.3333333333333333333333333333333333333333333333333");
    
        std::cout << bracket_min << " " << bracket_max << std::endl;
        const boost::uintmax_t maxit = 20;
        boost::uintmax_t it = maxit;
        std::pair<cpp_bin_float_50_et_off, cpp_bin_float_50_et_off> r = brent_find_minima(func(), bracket_min, bracket_max, bits, it);
    
        std::cout << "x at minimum = " << r.first << ", f(" << r.first << ") = " << r.second << std::endl;
        // x at minimum = 1, f(1) = 5.04853e-018
        std::cout << it << " iterations. " << std::endl;
    
        show_minima<cpp_bin_float_50_et_off>(); //
      }
    
      { // decimal ET on by default
        std::cout.precision(std::numeric_limits<cpp_dec_float_50>::digits10);
    
        int bits = std::numeric_limits<cpp_dec_float_50>::digits / 2 - 2;
    
        cpp_dec_float_50 bracket_min = static_cast<cpp_dec_float_50>("-4");
        cpp_dec_float_50 bracket_max = static_cast<cpp_dec_float_50>("1.3333333333333333333333333333333333333333333333333");
    
        std::cout << bracket_min << " " << bracket_max << std::endl;
        const boost::uintmax_t maxit = 20;
        boost::uintmax_t it = maxit;
        std::pair<cpp_dec_float_50, cpp_dec_float_50> r = brent_find_minima(func(), bracket_min, bracket_max, bits, it);
    
        std::cout << "x at minimum = " << r.first << ", f(" << r.first << ") = " << r.second << std::endl;
        // x at minimum = 1, f(1) = 5.04853e-018
        std::cout << it << " iterations. " << std::endl;
    
        show_minima<cpp_dec_float_50>();
      }
    
      { // decimal ET on
        std::cout.precision(std::numeric_limits<cpp_dec_float_50_et_on>::digits10);
    
        int bits = std::numeric_limits<cpp_dec_float_50_et_on>::digits / 2 - 2;
    
        cpp_dec_float_50_et_on bracket_min = static_cast<cpp_dec_float_50_et_on>("-4");
        cpp_dec_float_50_et_on bracket_max = static_cast<cpp_dec_float_50_et_on>("1.3333333333333333333333333333333333333333333333333");
        std::cout << bracket_min << " " << bracket_max << std::endl;
        const boost::uintmax_t maxit = 20;
        boost::uintmax_t it = maxit;
        std::pair<cpp_dec_float_50_et_on, cpp_dec_float_50_et_on> r = brent_find_minima(func(), bracket_min, bracket_max, bits, it);
    
        std::cout << "x at minimum = " << r.first << ", f(" << r.first << ") = " << r.second << std::endl;
        // x at minimum = 1, f(1) = 5.04853e-018
        std::cout << it << " iterations. " << std::endl;
    
        show_minima<cpp_dec_float_50_et_on>();
    
      }
    
      { // decimal ET off
        std::cout.precision(std::numeric_limits<cpp_dec_float_50_et_off>::digits10);
    
        int bits = std::numeric_limits<cpp_dec_float_50_et_off>::digits / 2 - 2;
    
        cpp_dec_float_50_et_off bracket_min = static_cast<cpp_dec_float_50_et_off>("-4");
        cpp_dec_float_50_et_off bracket_max = static_cast<cpp_dec_float_50_et_off>("1.3333333333333333333333333333333333333333333333333");
    
        std::cout << bracket_min << " " << bracket_max << std::endl;
        const boost::uintmax_t maxit = 20;
        boost::uintmax_t it = maxit;
        std::pair<cpp_dec_float_50_et_off, cpp_dec_float_50_et_off> r = brent_find_minima(func(), bracket_min, bracket_max, bits, it);
    
        std::cout << "x at minimum = " << r.first << ", f(" << r.first << ") = " << r.second << std::endl;
        // x at minimum = 1, f(1) = 5.04853e-018
        std::cout << it << " iterations. " << std::endl;
    
        show_minima<cpp_dec_float_50_et_off>();
      }
    
      return 0;
    } 
    
    
    展开全文
  • 一、传统遗传算法求解函数最小值 ①对于函数 其最小值位于时,最小值为0 matlab多次结果如下: 从上图能够看到传统能够得到最终结果,但是稳定性较差,不易得到较好的结果 ②对函数做平移,即可得到 其...
  • 粒子群优化算法求函数最小值

    千次阅读 2020-11-01 21:08:15
    粒子群优化算法求函数最小值1.算法简介2.流程图及算法实现3.具体代码实现 1.算法简介 粒子群算法(简称PSO)是一种有效的全局寻优算法,最早由美国的Kennedy和Eberhart于1995年提出。基于群体智能理论的优化算法,...
  • 如果想要获取往期每日一题电子版,可以加我微信:daigemath166,备注:知乎 每日一题呆哥解析:这是一道求多元函数最小值的问题首先看到中括号里面的东西,我们有没有想到要化简一下呢没错,这里可以运用我们熟悉的...
  • 布谷鸟求解函数最小值,这是布谷鸟算法与莱维飞行的详细讲解(https://blog.csdn.net/zyqblog/article/details/80905019) 。
  • TensorFlow应用(8)——利用优化器寻找函数最小值(一)引 言(二)问题分析(三)模型构建(四)总 结 (一)引 言 在开始更加复杂的机器学习模型实践之前,我们先来做一个有趣的小项目来放松放松心情,这个项目的...
  • #用梯度下降法求函数最小值 # coding: utf-8 import numpy as np import matplotlib.pylab as plt def _numerical_gradient_no_batch(f, x): #求函数的梯度值 h = 1e-4 # 0.0001 grad = np.zeros_like(x) for idx...
  • 遗传算法GA两个变量求函数最小值,仅供参考学习交流
  • 遗传算法计算函数最小值f(x)=∑xi^2 基于matlib与python对比 采用种群数100,实数编码,进化100代交叉概率0.8,变异概率0.1 # -*- coding: utf-8 -*- """ """ import numpy as np #适应度函数 def func2(x):...
  • 求下列二元函数的最大值,f(x1,x2)=x1^2+x2^2,x1与x2的取值区间为{0,1,2,...,7}
  • 求助Matlab关于三个自变量的函数最小值优化求解重发-需要解决的问题.doc 本人一直做解析理论物理推导的,可惜不幸的事情是,本人的数值计算功底很差,看到附件里面的三个自变量参数的最小值优化就呆了,带有三个...
  • 梯度下降(Gradient Descent)是用于寻找函数最小值的一种优化算法。我们常常利用梯度下降法来使损失函数Loss function的值尽可能小,即让神经网络的预测值(实际输出)和标签值(预期的输出)尽可能接近。在这个过程...
  • Matlab数学实验 - 斐波那契(Fibonacci)方法计算一元函数最小值 一、斐波那契(Fibonacci)方法简介 斐波那契(Fibonacci)方法基于斐波那契(Fibonacci)数列,关于fei数斐波那契以百度,在这就不说了。 ...
  • 函数最小值

    千次阅读 2016-11-06 11:28:59
    f[x_] := (x^4 + 1)/(x^3 - x);Plot[f[x], {x, -9, 9}]Show[%4, PlotLabel -> HoldForm[老师让我们找的极小值在这], LabelStyle -> {GrayLevel[0]}]Show[%3, AxesStyle -> Black]Show[%4, AxesLabel -> {HoldForm...
  • 布谷鸟求解函数最小值,这是布谷鸟算法与莱维飞行的详细讲解;带注释的布谷鸟算法,清晰易懂,简洁好用,可以更改适应度函数应用不同的场景。
  • 2D函数最小值优化

    千次阅读 2020-07-03 22:33:47
    import numpy as np import ... f(x) = 0.0 strp18000: x = [3.0, 2.0], f(x) = 0.0 可以看到初始值为(0,0)时函数最小值的坐标为(3,2)。 而不同的初始值得到的结果也是不同的,所以初始值不能随意设置。
  • 求正则化代价函数最小值 梯度下降法 在求解之前的线性回归方程的代价函数的最小值时,我们使用了以下的方程来迭代θ值。 我们知道正则化后的代价函数中我们是从θ1开始惩罚,θ0并未动。所以我们将θ从迭代方程中...
  • 该脚本提供了不确定性的最终区间,其中单变量非线性/线性函数最小值。 该函数在区间内应该是单峰的。 该脚本检查函数的单峰性。用户输入初始间隔和迭代次数。 根据迭代次数,获得最终间隔。 迭代次数越大,不确定...
  • 本文利用Nelder-Mead算法求解函数最小值问题。 当应用Nelder-Mead时,若函数有n个变量,则数据集合(simplex)需要构建n+1个元素。利用这n+1个元素,不停地替换掉函数值最大(小)的元素,同时维护更新中心点的值,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 292,387
精华内容 116,954
关键字:

函数最小值