0.618算法：
[a,b] 为f（x）的单峰区间，【lambda】=0.618
1. 确定初始点x1=a+(1-【lambda】)(b-a)           x2=a+【lambda】(b-a)
f1=f(x1) f2=f(x2)
2.判定收敛      |b-a|<c?     是 x'=(a+b)/2为近似极小值点问题
3.缩短区间（这部分的等号为赋值）
（1）若f1<f2   则a=>a   x2=>b   x1=>x2 f1=>f2   转4
（2）若f1>f2   则x1=>a b=>b    x2=>x1 f2=>f1   转5
（3）若f1==f2 则x1=>a x2=>b                    转1
4.x1=a+(1-【lambda】)(b-a)          f1=f(x1)     转2
5.x2=a+【lambda】(b-a)              f2=f(x2)     转2

C++程序：
#include<iostream>
#include<cmath>
using namespace std;
const double E = 2.718281828459045235360287;
const double eps = 3*1E-2;
const double lambda = (sqrt(5.0) - 1)/2.0;
double f(double x)
{
return pow(E,-x) + x*x;
}
int main()
{
double a = 0,b = 1,x1,x2,f1,f2;
while(true)
{
x1 = a + (1 - lambda)*(b - a),x2 = a + lambda*(b - a);
f1 = f(x1),f2 = f(x2);
if(fabs(b - a) < eps)
{
printf("x = %.10lf\n",(a + b)/2.0);
break;
}
la:
if(f1 < f2)
{
b = x2,x2 = x1,f2 = f1;
x1 = a + (1 - lambda)*(b - a),f1 = f(x1);
goto la;
}
else if(f1 > f2)
{
a = x1,x1 = x2,f1 = f2;
x2 = a + lambda*(b - a),f2 = f(x2);
goto la;
}
else
a = x1,b = x2;
}
return 0;
}

弦截法算法：

C++程序：
#include<iostream>
#include<iomanip>
#include<cmath>
using namespace std;
double f(double);
double xpoint(double,double);
double root(double,double);
int main()
{double x1,x2,f1,f2,x;
do
    {cout<< "input x1,x2:";
    cin>>x1>>x2;
    f1=f(x1);
    f2=f(x2);
    }while(f1*f2>=0);
x=root(x1,x2);
cout<<setiosflags(ios::fixed)<<setprecision(8);
cout<<"A root of equation is "<<x<<endl;
return 0;
}
double f(double x)
{double y;
y=x*x*x*x-4*x*x*x-6*x*x-16*x+4;
return y;
}
double xpoint(double x1,double x2)
{double y;
y=(x1*f(x2)-x2*f(x1))/(f(x2)-f(x1));
return y;
}
double root(double x1,double x2)
{double x,y,y1;
y1=f(x1);
do
{x=xpoint(x1,x2);
y=f(x);
if(y1*y>0)
{y1=y;x1=x;
}
else x2=x;
}while(fabs(y)>=0.00001);
return x;
}


牛顿法算法：

C++程序：
#include<iostream>
#include<cmath>
using namespace std;
void fun(double, double);
int main()
{
double x0, epsilon;
cout << "X0初始值:"<<endl;
cin >>x0;
cout<<"请输入允许的最大误差: "<<endl;
cin>>epsilon;
fun(x0, epsilon);
return 0;
}
void fun(double x0, double epsilon)
{
double x1 = x0;
x0 = (x1 - (4*x1*x1*x1 - 12*x1*x1 - 12*x1-16) / (12*x1*x1 -24*x1-12));
if(fabs(x0 - x1) > epsilon)
fun(x0, epsilon);
else
cout << "方程的近似根是" << x0 << endl;
}


回复：10楼
二分法写过，不过程序找不到了，有空再写吧。。。

回复：12楼
难的都是从简单的而来，要难的等整理完了发吧。。。

回复14楼：
二分法的速度貌似没0.618法的收敛速度快吧…

例：用vector向量容器装入10个元素，然后，使用迭代器iterator和accumulate算法统计出10个元素的和。
//cin和cout需要
#include <iostream>
//向量需要
#include <vector>
//accumulate算法需要
#include <numeric>
using namespace std;
int main(int argc,char* argv[])
{
    //定义向量v
    vector<int> v;
    int i;
    //赋值
    for(i=0;i<10;i++)
    {
        //尾部元素扩张方式赋值
        v.push_back(i);
    }
    //使用iterator迭代器顺序便利所有元素
    for(vector<int>::iterator it=v.begin();it!=v.end();it++)
    {
        //输出迭代器当前位置上的元素值
        cout<<*it<<" ";
    }
    cout<<endl;//回车换行
    //统计输出向量所有元素的和
    cout<<accumulate(v.begin(),v.end(),0)<<endl;
    return 0;
}


布朗运动的（R语言）
set.seed(123)
N <- 100
T <- 1
Delta <- T/N # žmm…
W <- numeric(N+1)
t <- seq(0,T, length=N+1)
for(i in 2:(N+1))
W[i] <- W[i-1] + rnorm(1) * sqrt(Delta)
plot(t,W, type="l", main="brown" , ylim=c(-1,1))

matlab在特卡罗模拟中布朗运动程序代码：
%布朗运动路径模拟;几何布朗运动路径模拟;关于布朗运动的随机积分模拟
%BrownMotPath布朗运动路径
%GeometryBroPath
%BrownMotintegral
function BrownMotPath(t,delt_t,path_number) %[B_path,GEB_path]=BrownMotPath(t,delt_t,path_number)
t=1;
%产生布朗运动路径,时间区间(0,1)
path_number=10;
delt_t=0.001;
points_number=1/0.001;
brown_motion_values=zeros(points_number+1,path_number);
for j=1:path_number
for i=1:points_number
brown_motion_values(i+1,j)= brown_motion_values(i,j)+sqrt(delt_t)*normrnd(0,1,1);%从0位置出发的布朗运动
end
end
%产生布朗运动路径,时间区间(0,100)
%产生几何布朗运动路径d(log(s))=mu*s*d(t)+sigma*s*d(w),w表示布朗运动
% price_stock() :
mu=0.05;
sigma=1;
dt=1/1000;
n_path=10;
n_points=1001;
price_stock=zeros(n_points,n_path);
for j=1:n_path
price_stock(1,j)=1; %目前的股票价格为1
end
for j=1:n_path
for i=1:n_points-1
price_stock(i+1,j)=price_stock(i,j)*exp(dt*(mu-0.5*sigma^2)+sigma*sqrt(dt)*normrnd(0,1,1));
end
end
x=(0:0.001:1)';
subplot(2,1,1);
plot(x,brown_motion_values);
xlabel('t')
ylabel('y_value')
title('布朗运动路径')
subplot(2,1,2);
plot(x, price_stock);
xlabel('t')
ylabel('y_value')
title('几何布朗运动路径')  


粒子群算法基本步骤：
（1）随机初始化种群中各微粒的位置和速度。
（2）评价每个微粒的适应度，将当前微粒的位置和适应值存储在各微粒的pbest中，将所有pbest适应值存储于gbest中。
（3）用下式更新粒子的速度和位移
        v[i,j](t+1)=w*v[i,j](t)+c1*r1*{p[i,j]-x[i,j](t)}+c2*r2*{p[g,j]-x[i,j](t)}
    x[i,j](t+1)=x[i,j](t)+v[i,j](t+1)                    j=1,2,3......d
（4）对每个微粒将其适应值与其经历过的最好位置作比较，如果较好，则将其作为当前的最好位置。
（5）比较当前所有pbest和gbest的值，更新gbest
（6）若满足停止条件，输出结果，否则返回（3）继续搜索
MATLAB实现：
在MATLAB中编程实现的基本微粒粒子群优化函数为PSO
功能：用基本粒子群算法求解无约束优化问题。
调用格式：[xm,fv]=PSO(fitness,N,c1,c2,W,M,D)
其中： 待优化的目标函数：fitness
学习因子1：c1
学习因子2：c2
惯性权重：w
最大迭代次数：M
问题的维数：D
目标函数最小值的自变量值：xm
目标函数的最小值：fv
MATLAB代码如下：
function [xm,fv]=PSO (fitness,N ,c1,c2,w,m,d)
%待优化的目标函数：fitness
%学习因子1：c1
%学习因子2：c2
%惯性权重：w
%最大迭代次数：M
%问题的维数：D
%目标函数最小值的自变量值：xm
%目标函数的最小值：fv
format long;
for i=1:N
     for j=1:D
         x(i,j)=randn;   %随机初始化位置
         v(i,j)=randn;   %随机初始化速度
     end
end
for i=1:N
     p(i)=fitness(x(i,:));
     y(i,:)=x(i,:);
end
pg=x(N,:);               %pg为全局最优
for i =1:(N-1)
     if fitness (x(i,:))<fitness(pg)
         pg=x(i,:);
     end
end
for t=1:M
     for i=1:N
        v(i,:)=w*v(i,:)+c1*rand*(y(i,:)-x(i,:))+c2*rand*(pg-x(i,:));
         x(i,:)=x(i,:)+v(i,:);
        if fitness(x(i,:))<p(i)
            p(i)=fitness(x(i,:));
             y(i,:)=x(i,:);
        end
         if p(i)<fitness(pg)
            pg=y(i,:);
        end
     end
         pbest(t)=fitness(pg);
end
xm=pg;
fv=fitness(pg);