优化方法（C++）——0.618法、平均值法、单纯形法

最新推荐文章于 2023-03-21 22:10:58 发布
最新推荐文章于 2023-03-21 22:10:58 发布
阅读量2.6k 收藏 20
点赞数
分类专栏： C/C++ 文章标签： C++ 单纯形法 优化方法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/akadiao/article/details/77568279
版权

1、0.618法

// 0.618.cpp : 优化方法：0.618法确定一维搜索问题的搜索区间。
//

#include "stdio.h"
#include "iostream"
#include "math.h"
using namespace std;

//#define Lambda 0.618

double f(double x)  //输入 min f(x)  f(x)的函数体
{
    return (x*x-1)*(x*x-1);
    //return exp(-x)+x*x;
}

void main()
{
    double a, b, Epsilon;
    double Lambda, Mu;
    a=2, b=5;
    Epsilon=0.5;
    //cout<<"输入搜索区间左值：\n";
    //cin>>a;
    //cout<<"输入搜索区间右值：\n";
    //cin>>b;

    Lambda=a+(1-0.618)*(b-a);
    Mu=a+0.618*(b-a);

        while((b-a)>=Epsilon)
        {
            if(f(Lambda)>f(Mu))//步骤3
            {
            a=Lambda;
            b=b;
            Lambda=Mu;
            Mu=a+0.618*(b-a);
            }
            else //步骤4
            {
            a=a;
            b=Mu;
            Mu=Lambda;
            Lambda=a+(1-0.618)*(b-a);
            }
        }
        cout<<"搜索区间为：["<<a<<","<<b<<"]"<<"\n"<<"最优解为："<<(a+b)/2<<"\n";
        system("pause");
    return ;
}

2、平均值法

// mean.cpp : 优化方法：平均法确定一维搜索问题的搜索区间。
//

#include "stdio.h"
#include "iostream"
#include "math.h"
using namespace std;
double f(double x) ;
double d_f(double x);

void main()
{
    double a, b, Epsilon;
    double x0;
    Epsilon=0.001;

    cout<<"输入搜索区间左值：\n";
    cin>>a;
    cout<<"输入搜索区间右值：\n";
    cin>>b;
    if(d_f(a)<0 && d_f(b)>0)
    {
        x0=(a+b)/2;
        while(fabs(d_f(x0))>Epsilon)
        {
            x0=(a+b)/2;
            if(d_f(x0)>0)
            {
            b=x0;
            }
            else
            {
            a=x0;
            }
        }
        cout<<"最优解为："<<x0<<"\n";
    }
    else
    {
        cout<<"该区间内不存在最优解 \n";  
    }   
    return ;
}

double f(double x)  //输入 min f(x)  f(x)的函数体
{
    //return x*x+2.0*x;
    //return exp(-x)+x*x;
    //return x*x*x*x/4-4*x*x*x/3+5*x*x/2-2*x;
    return 3*x*x*x*x-16*x*x*x+30*x*x-24*x+8;
}

double d_f(double x)
{
    double Delte=0.00001;
    return (f(x+Delte)-f(x))/Delte;
}

3、单纯形法

 //simplex.cpp : 单纯形法。
//ex1、ex2

#include "stdio.h"
#include "iostream"
#include <vector>
using namespace std;

#define m 3  //初始表大小：m行n列 (m<n)
#define n 5
//*************************************************************************************

double A[m][n], b[m], C[n], c[n], A2[m][n];//c[n] 标准型的目标函数系数
int BaseVariable[m];    //基变量
int NotBaseVariable[n-m];   //非基变量
int ArtificalVariable[m];   //人工变量
double f=0;
int C_min_mark;
int b_min_mark;
double r[n];//二阶段法的向量r

void input2();
void input2(double **a,int len1,int len2);
void input();
void input(double **a,int len1,int len2);
void output();
void output(double **a,int len1,int len2);
double determine();
double determine(int len1,int len2);
double determine2();
double determine2(int len1,int len2);
void exchange();
void newexchange(double **a,int len1,int len2);
void one_stage();
void two_stage();
void two_stage2();
void main()
{
    one_stage();//一阶段
    //two_stage();//两阶段
    system("pause");
    return ;
}

void two_stage2()
{
    input2();
    //double a[m][n];
    //input2((double **)a,m,n);
    output();
    //output((double**)a,m,n);
    while(determine2())
        {
            exchange();
            //newexchange((double**)a,m,n);
            output();
        }
    if(f==0)
        {
            //double a2[m][n-m];
            //for(int i=0;i<m;i++)
            //  for(int j=0;j<n-m;j++)
            //      (*((int *)a2+i*m+j))=(*((int *)a+i*m+j));
            //int k=0,K[n-m-m];
            //for(int i=0;i<n-m;i++)
            //{
            //  
            //  for(int j=0;j<m;j++)
            //  {
            //      if(NotBaseVariable[j]!=BaseVariable[i])
            //          K[k];
            //  }
            //}
            //while(determine(m,n-m))
            //  {
            //  newexchange((double**)a2,m,n-m);
            //  output((double**)a,m-m,n-m);
            //  }
            cout<<"最优解f为：\n"<<-f<<endl;
        }
    else
        cout<<"原问题无可行解，故无最优解. \n"<<endl;    

}



void two_stage()
{
    double a[m][n];
    input2((double **)a,m,n);
    output((double**)a,m,n);
    while(determine2(m,n))
        {
            newexchange((double**)a,m,n);
            output((double**)a,m,n);
        }
    if(f==0)
        {
            double a2[m][n-m];
            for(int i=0;i<m;i++)
                for(int j=0;j<n-m;j++)
                    (*((int *)a2+i*n+j))=(*((int *)a+i*n+j));

            while(determine(m,n-m))
                {
                newexchange((double**)a2,m,n-m);
                output((double**)a,m-m,n-m);
                }
            cout<<"最优解f为：\n"<<-f<<endl;
        }
    else
        cout<<"原问题无可行解，故无最优解. \n"<<endl;    

}

void one_stage()//一阶段单纯形法
{
    double a[m][n];
    //input();
    input((double**)a,m,n);
    //output();
    output((double**)a,m,n);
    while(!determine())
        {
            //exchange();
            newexchange((double**)a,m,n);
            output((double**)a,m,n);
        }
    cout<<"最优解f为：\n"<<-f<<endl;
}


void input2(double **a,int len1,int len2)   //输入A[m][n], b[m], C[m]，并确定基变量BaseVariable[m]
{
    //double a[len1][len2];
    cout<<"输入系数矩阵A：\n";
    for(int i=0;i<len1;i++)
    {
        for(int j=0;j<len2;j++)
        {
            cout<<"A["<<i<<"]"<<"["<<j<<"]=";
            {
                cin>>(*((int *)a+i*len2+j));
                //A[i][j]=(*((int *)a+i*len1+j));
            }
        }
        cout<<"\n";
    }

    cout<<"输入右端项b：\n";
    for(int i=0;i<len1;i++)
    {
        cout<<"b["<<i<<"]=";
        cin>>b[i];
    }

    int j=0,k=0;
    for(int i=0;i<len2;i++)
    {
        if(i<len2-len1)
        {
            C[i]=0;
            NotBaseVariable[j]=i;
            j++;
        }
        else
        {
            C[i]=1;
            BaseVariable[k]=i;
            ArtificalVariable[k]=i;//记录人工变量
            k++;
        }
    }
    for(int j=0;j<len2;j++)
    {
        for(int i=0;i<len1;i++)
            C[j]=C[j]-(*((int *)a+i*len2+j));//即  C0[n]->r[n]  过程
    }
    for(int i=0;i<len1;i++)
    {
        f=f-b[i];
    }

    cout<<"输入标准型的目标函数系数 C：\n";
    for(int i=0;i<len2-len1;i++)
    {
        cout<<"c["<<i<<"]=";
        cin>>c[i];
    }

}





void input()  //输入A[m][n], b[m], C[m]，并确定基变量BaseVariable[m]
{
    cout<<"输入系数矩阵A：\n";
    for(int i=0;i<m;i++)
    {
        for(int j=0;j<n;j++)
        {
            cout<<"A["<<i<<"]"<<"["<<j<<"]=";
            cin>>A[i][j];
        }
        cout<<"\n";
    }
    cout<<"输入右端项b：\n";
    for(int i=0;i<m;i++)
    {
        cout<<"b["<<i<<"]=";
        cin>>b[i];
    }
    cout<<"输入约束条件系数C：\n";
    int j=0,k=0;
    for(int i=0;i<n;i++)
    {
        cout<<"C["<<i<<"]=";
        cin>>C[i];
        if(C[i]==0)
        {
            BaseVariable[j]=i;          //确定基变量 x2 x3 x4
            j++;
        }
        else    
        {
            NotBaseVariable[k]=i;       //确定非基变量 x0 x1
            k++;
        }
    }
}

void output()
{
    cout<<"矩阵A为：\n";
    for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            cout<<A[i][j]<<"    ";
            cout<<"\n";
        }
    cout<<"右端项b：\n";
    for(int i=0;i<m;i++)
        {
            cout<<b[i]<<"   ";
        }
    cout<<"\n";
    cout<<"约束条件系数C：\n";
    for(int i=0;i<n;i++)
        {
            cout<<C[i]<<"   ";
        }
    cout<<"\n";
    cout<<"f="<<f<<"\n";
}


double determine2()
{
    int BaseVariableIncludeArtificalVariable=0;
    for(int i=0;i<m;i++)
    {
        for(int j=0;j<m;j++)
        {
            if(BaseVariable[i]==ArtificalVariable[j])
                BaseVariableIncludeArtificalVariable++;
        }
    }
    if(BaseVariableIncludeArtificalVariable)//基变量中若含有人工变量则继续交换
        return 1;
    else
        return 0;
}

double determine()//判定C
{
    int C_BaseVariable_M0=0, C_BaseVariable_L0=0, C_BaseVariable_E0=0;
    int C_NotBaseVariable_M0=0, C_NotBaseVariable_L0=0, C_NotBaseVariable_E0=0;//大于、小于、等于M L E
    //double C_min=0;
    for(int i=0;i<m;i++)
    {
        if(C[BaseVariable[i]]==0)
            C_BaseVariable_E0++;
        else
        {
            if(C[BaseVariable[i]]<0)
                C_BaseVariable_L0++;
            else
                C_BaseVariable_M0++;
        }
    }
    for(int i=0;i<(n-m);i++)
    {
        if(C[NotBaseVariable[i]]>0)
            C_NotBaseVariable_M0++;
        else
        {
            if(C[NotBaseVariable[i]]<0)
            {
                C_NotBaseVariable_L0++;
            }   
            else
                C_NotBaseVariable_E0++;
        }           
    }
    if(C_BaseVariable_E0==m && C_NotBaseVariable_L0==0)//基变量的检验数都等于0，非基变量的检验数都大于0
        return 1;
    if(C_BaseVariable_E0==m && C_NotBaseVariable_L0!=0)//基变量的检验数都等于0，非基变量的检验数都大于0
        return 0;
}

void exchange()
{
    double C_min=C[0];
    int C_min_mark=0;
    for(int i=0;i<sizeof(C)/sizeof(double);i++)
    {
        if(C[i]<C_min)
        {
            C_min=C[i];
            C_min_mark=i;
        }
    }


    double b_min;
    for(int i=0;i<m;i++)
    {
        if(A[i][C_min_mark]!=0 && b[i]/A[i][C_min_mark]>0)
        {
            b_min=b[i]/A[i][C_min_mark]; //记录min(b[m])的下标
            b_min_mark=i;
            for(int j=i;j<m;j++)
            {
                if(A[j][C_min_mark]!=0 && b[j]/A[j][C_min_mark]>0 && b[j]/A[j][C_min_mark]<b_min)//0与负数不参加比值
                {
                    b_min=b[j]/A[j][C_min_mark];//记录min(b[m])的下标
                    b_min_mark=j;
                }
            }
            break;
        }
    }

    //确定主元A[b_min_mark][C_min_mark]
    double A0[m][n], C0[n];
    for(int i=0;i<m;i++)
    {
        for(int j=0;j<n;j++)
        {
            A0[i][j]=A[i][j];
        }
    }
    for(int j=0;j<n;j++)
    {
        C0[j]=C[j];
    }
    for(int i=0;i<m;i++)
    {
        if(i!=b_min_mark && A[i][C_min_mark]!=0)//主元所在行不变；
        {
            for(int j=0;j<n;j++)
            {
                A0[i][j]=A[i][j]-1.0*A[b_min_mark][j]*A[i][C_min_mark]/A[b_min_mark][C_min_mark];//利用主元将对应列消去；
            }
                b[i]=b[i]-b[b_min_mark]*A[i][C_min_mark]/A[b_min_mark][C_min_mark];
        }   
    }
    for(int i=0;i<m;i++)
    {
        for(int j=0;j<n;j++)
        {
            A[i][j]=A0[i][j];
        }
    }

    f=f-1.0*b[b_min_mark]*C[C_min_mark]/A[b_min_mark][C_min_mark];
    for(int j=0;j<n;j++)
    {
        C0[j]=C[j]-A[b_min_mark][j]*C[C_min_mark]/A[b_min_mark][C_min_mark];    
    }
    for(int j=0;j<n;j++)
    {
        C[j]=C0[j];
    }
    NotBaseVariable[C_min_mark]=BaseVariable[b_min_mark];
    BaseVariable[b_min_mark]=C_min_mark; // x C_min_mark进基，x b_min_mark出基

}



void exchange2()
{
    double C_min=C[0];
    int C_min_mark=0;
    for(int i=0;i<sizeof(C)/sizeof(double);i++)
    {
        if(C[i]<C_min)
        {
            C_min=C[i];
            C_min_mark=i;
        }
    }

    double b_min;
    for(int i=0;i<m;i++)
    {
        if(A2[i][C_min_mark]!=0 && b[i]/A2[i][C_min_mark]>0)
        {
            b_min=b[i]/A2[i][C_min_mark]; //记录min(b[m])的下标
            b_min_mark=i;
            for(int j=i;j<m;j++)
            {
                if(A2[j][C_min_mark]!=0 && b[j]/A2[j][C_min_mark]>0 && b[j]/A2[j][C_min_mark]<b_min)//0与负数不参加比值
                {
                    b_min=b[j]/A2[j][C_min_mark];//记录min(b[m])的下标
                    b_min_mark=j;
                }
            }
            break;
        }
    }

    //确定主元A[b_min_mark][C_min_mark]
    double A0[m][n], C0[n];
    for(int i=0;i<m;i++)
    {
        for(int j=0;j<n;j++)
        {
            A0[i][j]=A2[i][j];
        }
    }
    for(int j=0;j<n;j++)
    {
        C0[j]=C[j];
    }
    for(int i=0;i<m;i++)
    {
        if(i!=b_min_mark && A2[i][C_min_mark]!=0)//主元所在行不变；
        {
            for(int j=0;j<n;j++)
            {
                A0[i][j]=A2[i][j]-1.0*A2[b_min_mark][j]*A2[i][C_min_mark]/A2[b_min_mark][C_min_mark];//利用主元将对应列消去；
            }
                b[i]=b[i]-b[b_min_mark]*A2[i][C_min_mark]/A2[b_min_mark][C_min_mark];
        }   
    }
    for(int i=0;i<m;i++)
    {
        for(int j=0;j<n;j++)
        {
            A2[i][j]=A0[i][j];
        }
    }

    f=f-1.0*b[b_min_mark]*C[C_min_mark]/A2[b_min_mark][C_min_mark];
    for(int j=0;j<n;j++)
    {
        C0[j]=C[j]-A2[b_min_mark][j]*C[C_min_mark]/A2[b_min_mark][C_min_mark];  
    }
    for(int j=0;j<n;j++)
    {
        C[j]=C0[j];
    }
    NotBaseVariable[C_min_mark]=BaseVariable[b_min_mark];
    BaseVariable[b_min_mark]=C_min_mark; // x C_min_mark进基，x b_min_mark出基

}




void newexchange(double **a,int len1,int len2)//    len1=m, len2=n      ((int *)a+i*len1+j))=A2[i][j]
{

    double C_min=C[0];
    int C_min_mark=0;
    for(int i=0;i<sizeof(C)/sizeof(double);i++)
    {
        if(C[i]<C_min)
        {
            C_min=C[i];
            C_min_mark=i;
        }
    }

    double b_min;
    for(int i=0;i<len1;i++)
    {
        if((*((int *)a+i*len2+C_min_mark))!=0 && b[i]/(*((int *)a+i*len2+C_min_mark))>0)    //A2[i][C_min_mark]=(*((int *)a+i*len1+C_min_mark))
        {
            b_min=b[i]/(*((int *)a+i*len2+C_min_mark)); //记录min(b[m])的下标
            b_min_mark=i;
            for(int j=i;j<len1;j++)
            {
                if((*((int *)a+j*len2+C_min_mark))!=0 && b[j]/(*((int *)a+j*len2+C_min_mark))>0 && b[j]/(*((int *)a+j*len2+C_min_mark))<b_min)//0与负数不参加比值
                {
                    b_min=b[j]/(*((int *)a+j*len2+C_min_mark));//记录min(b[m])的下标
                    b_min_mark=j;
                }
            }
            break;
        }
    }

    //确定主元A[b_min_mark][C_min_mark]
    double A0[m][n], C0[n];
    for(int i=0;i<len1;i++)
    {
        for(int j=0;j<len2;j++)
        {
            A0[i][j]=(*((int *)a+i*len2+j));
        }
    }
    for(int j=0;j<len2;j++)
    {
        C0[j]=C[j];
    }
    for(int i=0;i<len1;i++)
    {
        if(i!=b_min_mark && (*((int *)a+i*len1+C_min_mark))!=0)//主元所在行不变；
        {
            for(int j=0;j<len2;j++)
            {
                A0[i][j]=(*((int *)a+i*len2+j))-1.0*(*((int *)a+b_min_mark*len2+j))*(*((int *)a+i*len2+C_min_mark))/(*((int *)a+b_min_mark*len2+C_min_mark));//利用主元将对应列消去；
            }
            b[i]=b[i]-b[b_min_mark]*(*((int *)a+i*len2+C_min_mark))/(*((int *)a+b_min_mark*len2+C_min_mark));
        }   
    }
    for(int i=0;i<len1;i++)
    {
        for(int j=0;j<len2;j++)
        {
            (*((int *)a+i*len2+j))=A0[i][j];
        }
    }

    f=f-1.0*b[b_min_mark]*C[C_min_mark]/(*((int *)a+b_min_mark*len2+C_min_mark));
    for(int j=0;j<len2;j++)
    {
        C0[j]=C[j]-(*((int *)a+b_min_mark*len2+j))*C[C_min_mark]/(*((int *)a+b_min_mark*len2+C_min_mark));  
    }
    for(int j=0;j<len2;j++)
    {
        C[j]=C0[j];
    }
    NotBaseVariable[C_min_mark]=BaseVariable[b_min_mark];
    BaseVariable[b_min_mark]=C_min_mark; // x C_min_mark进基，x b_min_mark出基

}




void input(double **a,int len1,int len2)  //输入A[m][n], b[m], C[m]，并确定基变量BaseVariable[m]
{
    cout<<"输入系数矩阵A：\n";
    for(int i=0;i<len1;i++)
    {
        for(int j=0;j<len2;j++)
        {
            cout<<"A["<<i<<"]"<<"["<<j<<"]=";
            cin>>(*((int *)a+i*len2+j));
        }
        cout<<"\n";
    }
    cout<<"输入右端项b：\n";
    for(int i=0;i<len1;i++)
    {
        cout<<"b["<<i<<"]=";
        cin>>b[i];
    }
    cout<<"输入约束条件系数C：\n";
    int j=0,k=0;
    for(int i=0;i<len2;i++)
    {
        cout<<"C["<<i<<"]=";
        cin>>C[i];
        if(C[i]==0)
        {
            BaseVariable[j]=i;          //确定基变量 x2 x3 x4
            j++;
        }
        else    
        {
            NotBaseVariable[k]=i;       //确定非基变量 x0 x1
            k++;
        }
    }
}


void output(double **a,int len1,int len2) 
{
    cout<<"矩阵A为：\n";
    for(int i=0;i<len1;i++)
        {
            for(int j=0;j<len2;j++)
            cout<<(*((int *)a+i*len2+j))<<" ";
            cout<<"\n";
        }
    cout<<"右端项b：\n";
    for(int i=0;i<len1;i++)
        {
            cout<<b[i]<<"   ";
        }
    cout<<"\n";
    cout<<"约束条件系数C：\n";
    for(int i=0;i<len2;i++)
        {
            cout<<C[i]<<"   ";
        }
    cout<<"\n";
    cout<<"f="<<f<<"\n";
}


void input2()  //输入A[m][n], b[m], C[m]，并确定基变量BaseVariable[m]
{
    cout<<"输入系数矩阵A：\n";
    for(int i=0;i<m;i++)
    {
        for(int j=0;j<n;j++)
        {
            cout<<"A["<<i<<"]"<<"["<<j<<"]=";
            cin>>A[i][j];
        }
        cout<<"\n";
    }
    cout<<"输入右端项b：\n";
    for(int i=0;i<m;i++)
    {
        cout<<"b["<<i<<"]=";
        cin>>b[i];
    }

    int j=0,k=0;
    for(int i=0;i<n;i++)
    {
        if(i<n-m)
        {
            C[i]=0;
            NotBaseVariable[j]=i;
            j++;
        }
        else
        {
            C[i]=1;
            BaseVariable[k]=i;
            ArtificalVariable[k]=i;//记录人工变量
            k++;
        }
    }
    for(int j=0;j<n;j++)
    {
        for(int i=0;i<m;i++)
            C[j]=C[j]-A[i][j];//即  C0[n]->r[n]  过程
    }
    for(int i=0;i<m;i++)
    {
        f=f-b[i];
    }

    cout<<"输入标准型的目标函数系数 C：\n";
    for(int i=0;i<n-m;i++)
    {
        cout<<"c["<<i<<"]=";
        cin>>c[i];
    }

}


double determine2(int len1,int len2)
{
    int BaseVariableIncludeArtificalVariable=0;
    for(int i=0;i<len1;i++)
    {
        for(int j=0;j<len1;j++)
        {
            if(BaseVariable[i]==ArtificalVariable[j])
                BaseVariableIncludeArtificalVariable++;
        }
    }
    if(BaseVariableIncludeArtificalVariable)//基变量中若含有人工变量则继续交换
        return 1;
    else
        return 0;
}



double determine(int len1,int len2)//判定C
{
    int C_BaseVariable_M0=0, C_BaseVariable_L0=0, C_BaseVariable_E0=0;
    int C_NotBaseVariable_M0=0, C_NotBaseVariable_L0=0, C_NotBaseVariable_E0=0;//大于、小于、等于M L E
    //double C_min=0;
    for(int i=0;i<len1;i++)
    {
        if(C[BaseVariable[i]]==0)
            C_BaseVariable_E0++;
        else
        {
            if(C[BaseVariable[i]]<0)
                C_BaseVariable_L0++;
            else
                C_BaseVariable_M0++;
        }
    }
    for(int i=0;i<(len2-len1);i++)
    {
        if(C[NotBaseVariable[i]]>0)
            C_NotBaseVariable_M0++;
        else
        {
            if(C[NotBaseVariable[i]]<0)
            {
                C_NotBaseVariable_L0++;
            }   
            else
                C_NotBaseVariable_E0++;
        }           
    }
    if(C_BaseVariable_E0==len1 && C_NotBaseVariable_L0==0)//基变量的检验数都等于0，非基变量的检验数都大于0
        return 1;
    if(C_BaseVariable_E0==len1 && C_NotBaseVariable_L0!=0)//基变量的检验数都等于0，非基变量的检验数都大于0
        return 0;
}

4、确定搜索区间和初始点

// mean.cpp : 优化方法：平均法确定一维搜索问题的搜索区间。
//

#include "stdio.h"
#include "iostream"
#include "math.h"
using namespace std;

double f(double x) ;

void main()
{
    double t0, t1, t2, h;
    double a, b;
    h=0.2;
    cout<<"输入一个初始点的估计值：\n";
    cin>>t0;
    t2=t0+h;
    if(f(t2)<=f(t0))//步骤3
    {
    t1=t0+h;//步骤4
    //f(t1);
    }
    else//步骤3
    {
    h=-h;
    t1=t0+h;//步骤4
    //f(t1);
    }
    while(f(t1)<=f(t0))//步骤5
    {
    h=2*h;
    t2=t0;
    t0=t1;
    t1=t0+h;//步骤4
    //f(t1);
    }
    a=min(t1,t2);
    b=max(t1,t2);
    cout<<"搜索区间为：["<<a<<","<<b<<"]"<<"\n"<<"初始点为："<<(a+b)/2<<"\n";  
    system("pause");
    return ;
}

double f(double x)  //输入 min f(x)  f(x)的函数体
{
    //return x*x+2.0*x;
    //return exp(-x)+x*x;
    //return x*x*x*x/4-4*x*x*x/3+5*x*x/2-2*x;
    //return x*x*x*x*x+2*x*x*x*x-4*x*x*x+x*x+x+2;
    return (x+1)*(x+1);
}

这里写图片描述

阿卡蒂奥
关注
专栏目录
zip压缩包的格式不标准导致C++开源unzip.cpp解压失败问题的排查
dvlinker的技术专栏
08-11 1万+
本文详细讲述zip压缩包的格式不标准导致C++开源unzip.cpp解压失败问题的排查过程。
0.618法C程序
09-25
0.618法C程序
优化方法——0.618法（黄金分割法）
qq_36250209的博客
10-16 786
#include <iostream> using namespace std; //0.618法 class Solution { public: Solution(double x, double y) :a(x), b(y) { cout << "init parameter success\n"; } double func(double& x) const//计算函数值 { return x*(x + 2); } double solve(do
0.618算法C++实现
11-16
使用C++模拟的0.618算法。使用的人可以直接更改其中的参数，然后运行程序就可以求出方程的解了。 适合初学算法的人练习使用
最优化方法之0.618法（java）
weixin_49858823的博客
07-19 1599
最优化方法之0.618法（java） 算法原理 题目 试用0.618法求目标函数f(X)=x^3-2*x+1的最优解。给定初始区间[0,2]，收敛精度sgm=0.002。 代码 主类 package project; public class main1 { public static void main(String []args) { double a=0.0; double b=2.0; double miu=0.002; f_618 h=new f_618(a,b,miu);
0.618法C语言编程,c语言编程题--0.618法求最小值
weixin_39984201的博客
05-18 1197
c语言编程题--0.618法求最小值0题目:1.函数f(x)=x+10/x,初始量a=2,b=10,c=0.32.步骤:(1)取a1=a+0.382*(b-a),b1=b+0.618*(b-a).计算:f(a1),f(b1),比较这两个值的大小.(2)如果f(a1)>f(b1),令a=a1,b不变;否则b=b1,a不变.(3)求出|b-a|,如果|b-a|<=0.3,得出k=(b-a)...
单纯形法中大m法_单纯形法（大M法）
weixin_28994403的博客
01-14 3166
function [x,fval,flag,iteration]=originalsimpleM(C,A,b)%原始单纯形法(大M法，无需给出初始基变量)%Programmed by Liyang(faruto's Studio~!) BNU MATH%Email:liyangbnu@mail.bnu.edu.cnQQ:516667408%last modified 2008.4.27%求解标准...
VS2019 C++的跨平台开发——Android .so开发
luoyu510183的博客
07-03 3万+
这篇介绍下怎么用VS开发Android使用的.so动态链接库文件。 Android环境配置 1.先打开VS installer ​ 2.选中C++移动开发​ 3.如果VS没有下载NDK和SDK的，需要在VS里面配置 ​ ​ 我这里用的是Unity下载的NDK，SDK，JDK。路径大概在：Unity\xxxxxxxx\Editor\Data\PlaybackEngines\Andro...
【高级算法】单纯形法求解线性规划问题（C++实现）
热门推荐
牧之
07-16 4万+
1 单纯形法（1） 单纯形法是解线性规划问题的一个重要方法。 其原理的基本框架为： 第一步：将LP线性规划变标准型，确定一个初始可行解（顶点）。 第二步：对初始基可行解最优性判别，若最优，停止；否则转下一步。 第三步：从初始基可行解向相邻的基可行解（顶点）转换，且使目标值有所改善—目标函数值增加，重复第二和第三步直到找到最优解。 （2） 用程序进行运算前，要将目标函数及约束方程变成标准形
Qt5.9 C++开发指南.pdf 及示例源码
11-03
**Qt5.9 C++开发指南** Qt是一个跨平台的应用程序开发框架，广泛用于创建桌面、移动和嵌入式应用程序。在Qt5.9版本中，它提供了许多增强的功能和改进，使得C++开发者能够更加高效地构建用户界面和应用程序。本指南...
黄金分割法0.618.cpp
06-04
最近自学了黄金分割法，故上传了此算法的cpp文件，可根据自己需要更改目标函数，希望能够帮助到需要的人，共同学习
单纯形法的C++实现
10-28
是运筹学当中线性规划的一种求解方法——单纯性法的C++代码实现，程序完整可运行，压缩包内包含程序使用说明文档、所有原文件，以及程序测试案例数个。
黄金分割法的C++实现
08-18
黄金分割法的C++实现，用于求解单峰区间的最有解！
黄金分割（0.618）迭代法求解函数极值.rar
03-31
黄金分割法也称为中外比，指把一条线段分割为两部分，使其中一部分与全长之比等于另一部分与这部分之比。其比值是一个无理数，取其前三位数字的近似值是0.618，所以也称为0.618法。里面含有黄金分割法求解函数极值的c++代码。
【最优化】C++实现0.618法、Fibonacci法、二分法
onion23的博客
12-07 1426
参考课本：最优化方法 - 孙文瑜等 根据课本P110算法3.2.1（0.618法计算步骤）编写C++代码，例题为P137第4题(1)(2) 0.618法代码 #include <iostream> #include <cmath> double f(double t) { return exp(-t) + exp(t); } /*! * 实现0.618法 * @param f 需要优化的函数 * @param a 优化区间下界 * @param b ..
[数值算法]无约束优化之0.618法(黄金分割法)
08-05 2900
这是迭代算法的小应用，相关的理论请参考相关书籍，我这里只给出关键的函数及主程序段，其余相关的细节就不再一一罗列了.#include "Iterator.h"#include "MyAssert.h"#include "Ulti.h"#include #include void f0_618(Type a0,Type b0,Type e,Type (*arguF)(Type),FILE* outpu
0.618算法的c++实现
haoshu1231的博客
10-06 1594
#include #include using namespace std; class Optimize { private: double a_, b_, namd_, miu_; double L_; public: Optimize(); Optimize(double a,double b,double L); void calculate();
最优化方法之黄金分割法，为什么是0.618？
最新发布
qq_44876700的博客
03-21 1721
​ 黄金分割法又称 0.618 法，针对在给定区间上的单峰函数，通过不断收缩搜索区间来逼近极值。​ 根据 2. 算法步骤 我们知道每次收缩搜索区间只需要计算一个节点的值即可，正式因为qi+1= pi或者 pi+1= qi的操作，使得每次计算只需要算一次函数的值，相较于二分法少了一次计算，虽然收敛速度没有二分法快，但是每次收缩时的计算量更小，可见其巧妙行。​qi+1= pi或者 pi+1= qi这里可能有些同学有疑问，为什么不是 qi+1= qi或者 pi+1= pi。
运筹学0.618法，c语言实现
weixin_42079174的博客
11-19 825
运筹学0.618法，c语言实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值