精华内容
下载资源
问答
  • 列生成算法的学习
    千次阅读
    2019-11-04 10:14:44

    1、适用于大规模线性规划的求解。问题来了,如果是线性规划问题,不是说单纯形法理论上不是多项式算法,极端情况下要所有的遍历才能找到最优解。因此,一般软件用的是barrier method,也就是内点法求解,这个是多项式时间算法,这个算法好像可以很快求解得到最优解的。注意,是好像,没有验证过。

    2、继续问题。如果是整数规划的大规模线性规划问题,还是要用到分支定界的啊,这个是price and bound,忘记了叫什么名字。

    3、单纯形法 适用于 变量少约束多的模型。记住,是相对来说的,因为变量少的话,基变量的选择不会太费事。

    4、这个算法的理解,或者说是要用起来,一定要弄明白这个 对偶理论。原来都是理论上去理解整个 对偶,现在看起来是 非常 有用的东西啊。其中,有一些概念,这个shadow price 或者说是reduced cost ,都要用起来理解。

    5、还有很多概念,需要一一攻克的,所以需要时间。

    6、问题来了。现在这种方法的讲解还是比较透彻的,但是,dual problem 是怎么得到的呢?是否 自己要 推到出来呢,因为要求解sub-problem的嘛

    更多相关内容
  • 这是国外一篇有关列生成算法相关的topic的介绍,个人认为对于学习列生成算法的人来说很有用。 这是国外一篇有关列生成算法相关的topic的介绍,个人认为对于学习列生成算法的人来说很有用。
  • 包含十大经典算法: 顶点覆盖近似算法、哈密尔顿回路、画等温线、模拟退火应用、生成全排列矩阵、随机数的产生、最大流和最小截、最短路和次短路、最短路径、最小生成树Prim算法
  • 列生成算法求解矩形下料问题(Matlab代码)

    千次阅读 多人点赞 2020-04-04 14:35:02
    目录深切哀悼抗击新冠肺炎疫情斗争牺牲烈士和逝世同胞Matlab代码算例文件运行结果最优解方案展示 深切哀悼抗击新冠肺炎疫情斗争牺牲烈士和逝世同胞 这学期接了《运筹学》课程,在国内抗疫的大环境下,勉勉强强当了七...

    深切哀悼抗击新冠肺炎疫情斗争牺牲烈士和逝世同胞

    这学期接了《运筹学》课程,在国内抗疫的大环境下,勉勉强强当了七周主播,刚刚讲完对偶理论

    这里必须要吐槽一下《线性代数》的老师,本科生的课程不要放水好不好?讲单纯形法足足用了三周课,每堂课都要给学生科普或者强化线代基础。

    为了强化学生对对偶理论的理解,计划在接下来三周课程里介绍大规模问题的优化方法,Dantzig-Wolfe分解Benders分解ADMM(Alternating direction method of multipliers)。
    (想想后面还要讲整数规划、动态规划、网络规划、非线性规划、排队论、……,头都大。)

    说到Dantzig-Wolfe分解,不得不提的就是列生成算法,最早用来解决一维下料问题(cutting stock problem)。但一维下料问题似乎太乏味了,怕学生们提不起兴趣,这里就找了一篇解决矩形下料问题的文章,复现了一下。

    Cintra G F , Miyazawa F K , Wakabayashi Y , et al. Algorithms for two-dimensional cutting stock and strip packing problems using dynamic programming and column generation[J]. European Journal of Operational Research, 2008, 191(1):61-85.
    https://doi.org/10.1016/j.ejor.2007.08.007

    同行们一定都很熟悉这篇文章,很好的解决了gcut中13个算例,并且提出了变尺寸母板的解决策略。

    这里只实现了最基本的几段代码。

    Matlab代码

    // 生成离散点集
    function P=DPP(D,d)
    P=0;
    m = length(d);
    for j=0:D
        c(j+1)=0;
    end
    for i=1:m
        for j=d(i):D
            if c(j+1)<c(j-d(i)+1)+d(i)
                c(j+1)=c(j-d(i)+1)+d(i);
            end
        end
    end
    mind = min(d);
    for j=1:D-mind
        if c(j+1)==j
            P=[P,j];
        end
    end
    P=[P,D];
    
    // 矩形背包问题算法
    // 为方便回溯方案,将item修改为三维整数矩阵,前两维对应状态空间,第三维为该状态空间最大价值时满足各订单的数量 
    // guillotine 改为整数二维数组,其中0 ———— 不切;1 ———— 对w方向切割;2 ———— 对h方向切割
    function [z,V,item,guillotine,position]=DP(W,H,w,h,v)
    m=length(w);
    P=DPP(W,w);
    Q=DPP(H,h);
    r=length(P);
    s=length(Q);
    V=zeros(r,s);
    item=zeros(r,s,m);
    guillotine=zeros(r,s);
    position=zeros(r,s);
    for i=1:r
        for j=1:s
            [V(i,j),item(i,j,:)]=inital_dp(w,h,v,P,Q,i,j); //调用第三段程序初始化状态空间
            guillotine(i,j)=0;
        end
    end
    for i=2:r
        for j=2:s
            [~,n]=max(P(P<=floor(P(i)/2)));
            for x=1:n
                [~,t]=max(P(P<=(P(i)-P(x))));
                if V(i,j)<V(x,j)+V(t,j)
                    V(i,j)=V(x,j)+V(t,j);
                    item(i,j,:)=item(x,j,:)+item(t,j,:);
                    position(i,j)=P(x);
                    guillotine(i,j)=1;  %w方向切割
                end
            end
            [~,n]=max(Q(Q<=floor(Q(j)/2)));
            for y=1:n
                [~,t]=max(Q(Q<=(Q(j)-Q(y))));
                if V(i,j)<V(i,y)+V(i,t)
                    V(i,j)=V(i,y)+V(i,t);
                    item(i,j,:)=item(i,y,:)+item(i,t,:);
                    position(i,j)=Q(y);
                    guillotine(i,j)=2;  %h方向切割
                end
            end
        end
    end
    z=zeros(m,1);
    for i=1:m
        z(i)=item(r,s,i);
    end
    
    // 初始化每个状态空间的最大价值
    function [V,maxk]=inital_dp(w,h,v,P,Q,i,j)
    V=0;
    m=length(v);
    maxk=zeros(1,m);
    for k=1:m
        if w(k)>P(i)
            continue;
        end
        if h(k)>Q(j)
            continue;
        end
        if v(k)>V
            V=v(k);
            maxk=zeros(1,m);
            maxk(k)=1;
        end
    end
    
    //列生成算法主程序
    //用"\","/"替代 *inv()
    //绘图时用 cut(i).w cut(i).h 存储第i个待画任务对应状态空间的横纵编号 cut.x cut.y 存储其起始位置(左下坐标值)
    //方案结果呈现(绘图)的回溯算法暂时没想到更好的方法,欢迎大家提供宝贵意见!
    function [B,ans]=SimplexCG(filename)
    file = [.\gcut\',filename,'.txt'];  //算例存放在下级gcut文件夹中
    data = textread(file);
    m=data(1,1);
    W=data(2,1);
    H=data(2,2);
    w=data(3:2+m,1)';
    h=data(3:2+m,2)';
    d=data(3:2+m,3)';
    x=d;
    B=eye(m);
    P=DPP(W,w);
    Q=DPP(H,h);
    r=length(P);
    s=length(Q);
    m_V=zeros(m,r,s);
    m_item=zeros(m,r,s,m);
    m_guil=zeros(m,r,s);
    m_pos=zeros(m,r,s);
    while(true)
        y=ones(1,m)/B;
        [z,V,item,guillotine,position]=DP(W,H,w,h,y);
        if y*z<=1
            break;
        end
        omega=inv(B)*z;
        t=1e6;
        s=-1;
        for j=1:m
            if omega(j)<=0
                continue;
            end
            if t>(x(j)/omega(j))
                t=x(j)/omega(j);
                s=j;
            end
        end
        if s==-1
            break;
        end
        m_V(s,:,:)=V;
        m_item(s,:,:,:)=item;
        m_guil(s,:,:)=guillotine;
        m_pos(s,:,:)=position;
        for i=1:m
            B(i,s)=z(i);
            if i==s
                x(i)=t;
            else
                x(i)=x(i)-omega(i)*t;
            end
        end
    end
    ans = x;
    P=DPP(W,w);
    Q=DPP(H,h);
    r=length(P);
    s=length(Q);
    //画出最后方案
    for i=1:m
        figure(i);
        hold on
        plot([0,W,W],[H,H,0])
        cut(1).w=r;
        cut(1).h=s;
        cut(1).x=0;
        cut(1).y=0;
        while(~isempty(cut))
            a=cut(1).w;
            b=cut(1).h;
            x=cut(1).x;
            y=cut(1).y;
            cut(1)=[];
            num=length(cut);
            if m_guil(i,a,b)==0
                continue;
            end
            if m_guil(i,a,b)==1
                plot([x+m_pos(i,a,b),x+m_pos(i,a,b)],[y,y+Q(b)]);
                [~,cut(num+1).w]=max(P(P<=m_pos(i,a,b)));
                cut(num+1).h=b;
                cut(num+1).x=x;
                cut(num+1).y=y;
                [~,cut(num+2).w]=max(P(P<=P(a)-m_pos(i,a,b)));
                cut(num+2).h=b;
                cut(num+2).x=x+m_pos(i,a,b);
                cut(num+2).y=y;
            end
            if m_guil(i,a,b)==2
                plot([x,x+P(a)],[y+m_pos(i,a,b),y+m_pos(i,a,b)]);
                cut(num+1).w=a;
                [~,cut(num+1).h]=max(Q(Q<=m_pos(i,a,b)));
                cut(num+1).x=x;
                cut(num+1).y=y;
                cut(num+2).w=a;
                [~,cut(num+2).h]=max(Q(Q<=Q(b)-m_pos(i,a,b)));
                cut(num+2).x=x;
                cut(num+2).y=y+m_pos(i,a,b);
            end
        end
    end 
    

    算例文件

    在这里插入图片描述
    格式参考gcut设置,具体如下:

    1. 第一行数据 ‘5’ 表示订单种类数;
    2. 第二行数据’300 500’表示母板规格(宽300 x 长500);
    3. 第三行起为订单数据 ‘40 60 2300’ 表示 宽40长60的订单需求为2300件。

    运行结果

    在这里插入图片描述

    1. B为算法结束时基矩阵;
    2. x为最优解,每列方案使用次数。

    最优解方案展示

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    推荐大家关注公众号数据魔术师

    展开全文
  • 书接上文(MATLAB调用lpsolve的详细介绍帖),...这里还是采用大家学习列生成算法常用的例子来讲述:如何用MATLAB调用lpsolve来编写列生成算法,求解卷纸切割问题。 例子:有16米长的卷纸若干卷,现分别需要3m,6m,7

    书接上文(MATLAB调用lpsolve的详细介绍帖),我们继续探讨MATLAB调用lpsolve的用法。
    列生成算法(column generation method)是一种求解大规模线性规划问题的有效方法。它运用分解方法的基本思想以及线性规划单纯形法的特点把问题变成若干个适应计算机能力的子问题,逐个计算,最后得到原问题的最优解。

    这里还是采用大家学习列生成算法常用的例子来讲述:如何用MATLAB调用lpsolve来编写列生成算法,求解卷纸切割问题。

    例子:有16米长的卷纸若干卷,现分别需要3m,6m,7m的卷纸25,20,18卷,请问如何对16米长的卷纸进行切割以实现最小化16m长卷纸的消耗。
    根据上面的问题描述我们可以建立下列线性规划模型:
    模型1:
    min z=y1+y2+…+yn
    s.t.
    a11y1+a12y2+…+a1nyn>=25
    a21y1+a22y2+…+a2nyn>=20
    a31y1+a32y2+…+a3nyn>=18

    关于列生成算法的原理,帖子(原贴链接)已经讲述的很清楚,本文不再赘述。但是细心的童鞋已经发现,在lpsolve上手动输入模型来求解非常繁琐,要是能编写程序自动求解就好了。
    这样就引出来本文的重点阐述的内容了,本文要做的就是采用MATLAB调用lpsolve,对上述问题进行求解。
    这里还需要一个基础知识,那就是如何用MATLAB调用lpsolve,小编的上一篇帖子(MATLAB调用lpsolve的详细介绍帖)有详细讲解,不懂的童鞋可以回去看看。

    在编写列生成算法程序的时候,我们可以采用从特殊到普遍的思路进行编写,下面是具体编写思路:
    step1.我们可以将模型1表示的问题限制成如下问题,用RMP1表示,显然RMP1有3种方案,方案1:切割成5卷3m卷纸;方案2:切割成2卷6m卷纸;方案3:切割成2卷7m卷纸;。
    RMP1:
    min y1+y2+y3
    s.t.
    5y1+0y2+0y3>=25
    0y1+2y2+0y3>=25
    0y1+0y2+2y3>=25
    我们针对RMP1编写如下程序:

    f=[1,1,1];
    A=[5,0,0;0,2,0;0,0,2];
    b=[25,20,18];
    vlb=[0,0,0];
    e=[1,1,1];
    RMP1=lp_maker(f,A,b,e,vlb,[],[],[],1);
    mxlpsolve('solve', RMP1);
    obj=mxlpsolve('get_objective',RMP1)
    x=mxlpsolve('get_variables',RMP1)
    dual=mxlpsolve('get_dual_solution',RMP1)
    

    得到结果如下:obj=24; x=[5,10,9]; dual=[0.2,0.5,0.5,0,0,0];
    step2.根据列生成算法的原理,我们可以得到如下子问题(subproblem),将该子问题命名为subproblem1.
    subproblem1:
    min 1-0.2a14-0.5a24-0.5a34
    s.t. 3a14+6a24+7a34<=16
    a14,a24,a34∈Z
    我们针对subproblem1编写如下程序:

    f1=[-0.2,-0.5,-0.5];
    A1=[3,6,7];
    b1=16;
    vlb1=[0,0,0];
    e1=-1;
    subproblem1=lp_maker(f1,A1,b1,e1,vlb1,[],[1,2,3],[],1);
    mxlpsolve('solve', subproblem1);
    obj1=1+mxlpsolve('get_objective',subproblem1)
    x1=mxlpsolve('get_variables',subproblem1)
    

    得到如下结果:obj1=-0.2; x=[1,1,1];
    因为obj1<0,所以将方案4(切割成1卷3m长的卷纸,1卷6m长的卷纸和1卷7m长的卷纸)纳入RMP,,得到RMP2,开始新一轮迭代。
    RMP2:
    min y1+y2+y3+y4
    s.t.
    5y1+0y2+0y3+1y4>=25
    0y1+2y2+0y3+1y4>=25
    0y1+0y2+2y3+1y4>=25

    对于RMP2来说,与RMP1的不同主要体现在价值系数f 和消耗系数A多了一行,其它部分都是重复的,因此针对第一段代码只需要做一点点改动(改动部分为:f=[f,1]; A=[A,x1])就能求解RMP2了。
    subproblem2与subproblem1的区别就是价值系数不一样了,subproblem1的价值系数是RMP1求解得到的dual,subproblem2是RMP2求解得到的dual,因此求解subproblem2的程序只需要在求解subproblem1的程序上把价值系数改了就行。这就是从特殊到普遍的思路。

    上述切割卷纸问题的列生成算法的完整代码如下:

    f=[1,1,1];
    A=[5,0,0;0,2,0;0,0,2];
    b=[25,20,18];
    vlb=[0,0,0];
    e=[1,1,1];
    
    A1=[3,6,7];
    b1=16;
    vlb1=[0,0,0];
    e1=-1;
    
    while(1)
        RMP=lp_maker(f,A,b,e,vlb,[],[],[],1);
        mxlpsolve('solve', RMP);
        obj=mxlpsolve('get_objective',RMP);
        x=mxlpsolve('get_variables',RMP);
        dual=mxlpsolve('get_dual_solution',RMP);
        duals=zeros(1,3);
        for i=1:3
            duals(1,i)=dual(i,1);
        end
        f1=-duals;
        subproblem=lp_maker(f1,A1,b1,e1,vlb1,[],[1,2,3],[],1);
        mxlpsolve('solve', subproblem);
        obj1=1+mxlpsolve('get_objective',subproblem);
        x1=mxlpsolve('get_variables',subproblem);
        if (obj1>=0)
            break;
        end
        f=[f,1];
        A=[A,x1];
        vlb=[vlb,0];
        e=[e,1];
    end
    
    RMP=lp_maker(f,A,b,e,vlb,[],[],[],1);
    mxlpsolve('solve', RMP);
    obj=mxlpsolve('get_objective',RMP)
    x=mxlpsolve('get_variables',RMP)
    
    

    从上述代码可以发现,RMP的求解程序和subproblem的求解程序是一直在不断执行的,只是在每次执行过程中需要对相应的参数做出改变,当求解subproblem所得的的目标函数值不再小于0的时候,就代表没用新的方案加入能使得主问题的目标函数减小,因此就可以跳出循环,求解所得到的的最后一个RMP就能得到卷纸切割问题的最优解(当然,这是把卷纸切割问题松弛之后得到的最优解)。
    上述代码的运行结果为:
    在这里插入图片描述
    这和帖子(原贴链接)所得的结果一致,印证了上述代码的正确性。

    展开全文
  • orb算法matlab代码宝珠 通用时间序列/卫星大地测量/数据处理Matlab软件。 免责声明:该软件中的许多正在开发中,可能无法按预期运行。 还有许多过时的软件实例。 请报告任何奇怪的行为,我会尽力使它启动并运行。 ...
  • Anfis算法matlab代码血糖预测 此代码使用来自 OHIO T1DM 数据集的数据作为 2020 BGLP 挑战的一部分。 它运行各种不同的算法,为数据集中的不同文件生成半小时和一小时血糖水平预测范围的预测。 数据需要数据使用协议...
  • MATLAB】最小生成树Kruskal算法

    千次阅读 2021-07-29 08:43:36
    算法实现2.1 存储结构2.2 MATLAB代码 1.Kruskal算法 1.1 基本思想 将图的n个顶点看作n个分离的部分树,每个树具有一个顶点,算法的每一步就是选择连接两个分离树的具有最小权值的边,将两个树合二为一,直到只有一个...

    1.Kruskal算法

    1.1 基本思想

    将图的n个顶点看作n个分离的部分树,每个树具有一个顶点,算法的每一步就是选择连接两个分离树的具有最小权值的边,将两个树合二为一,直到只有一个树为止(进行n-1步)得到最小生成树。

    1.2 步骤

    ∙ \bullet 选择边e1,使得w(e1)尽可能小。

    ∙ \bullet 再次选择最小边,必须满足不构成圈且边权尽可能小。

    ∙ \bullet 直到不能满足则停止。

    按照上述步骤:
    ∙ \bullet 先选取顶点1-4的边,权值为1
    ∙ \bullet 接着去顶点4-5的边,权值为3
    ∙ \bullet 接下来本来应该去顶点1-5的边,但是由于会构成环,所以不选取
    ∙ \bullet 接着选取顶点2-3的边,权值为6
    ∙ \bullet 接着选取顶点2-5的边,权值为7,最小生成树构成。


    2.算法实现

    2.1 存储结构

    我们使用边权矩阵进行存储数据,边权矩阵就是按列写入,每列由出发顶点接收顶点边的权值组成,如下所示:

    [ 1 1 1 2 2 3 3 4 2 4 5 3 5 4 5 5 8 1 5 6 7 9 10 3 ] \begin{bmatrix} 1 & 1 & 1 & 2 & 2 & 3 & 3 &4\\ 2 & 4 & 5 &3 & 5 & 4 & 5 & 5\\ 8 & 1 & 5 & 6 & 7 & 9 & 10 & 3\\ \end{bmatrix} 1281411552362573493510453

    2.2 MATLAB代码

    %边权矩阵,每一列都表示一条边,从上到下分别为两个顶点以及它们边的权值
    b = [1 1 1 2 2 3 3 4;
         2 4 5 3 5 4 5 5;
         8 1 5 6 7 9 10 3];
    %sortrows函数对某一列进行比较排序,所以我们先转置b矩阵,然后对第三列也就是权值进行排序
    [B,i]=sortrows(b',3);
    %再将其转置回来
    B=B';
    %m为边的条数,n为点的个数
    m=size(b,2);n=5;
    %t数组用来标记选中的边,k用来计数,T矩阵用来存储选中的边,c计算最小生成树的总长度
    t=1:n;k=0;T=[];c=0;
    
    for i=1:m
        if t(B(1,i))~=t(B(2,i))
            k=k+1;T(k,1:2)=B(1:2,i),c=c+B(3,i);
            tmin=min(t(B(1,i)),t(B(2,i)));
            tmax=max(t(B(1,i)),t(B(2,i)));
            for j=1:n
                if t(j)==tmax
                    t(j)=tmin;
                end
            end
        end
        if k==n-1
            break;
        end
    end
    T,c,
    

    结果:T表示最小生成树的边,c表示最下生成树的总的权值。
    在这里插入图片描述

    展开全文
  • 使用在MATLAB编程语言中实现的两种不同的算法生成虚拟位置。 系统要求 以下代码是用MATLAB R2017a编程语言编写的。 细胞垫 该mat文件包含通过3个数组变量“ cells”存储在4000中的数据。 存储在此数组中的信息旨在...
  • Kruskal算法 最小生成树 求解最优树 源码程序
  • omp算法matlab代码绘画重访 纸的补充材料“音频修复:重新访问并重新加权”。 由OndřejMokrý和Pavel Rajmic撰写。 有关具有可播放音频的交互式网页,请参见。 下面提供了存储库中包含的文件的简短指南。 如有任何...
  • 算法系列——遗传算法matlab编程详解

    千次阅读 多人点赞 2020-09-23 22:09:23
    遗传算法详解GA,适合初学者.
  • 生成双随机矩阵的简单算法(矩阵,其中每和每行的总和正好是 1)。 算法: 1. 为每个 1<=i,j<=N 设置一个 NxN 矩阵 TM st TM[i,j] = 1/N。 2. 对于 X 次迭代: 3. 在 [1,...,N] 上绘制 i1, j1, i2, j2 UAR...
  • Prim算法matlab实现)

    千次阅读 热门讨论 2021-03-26 16:47:30
    Prim算法主要用来解决最小生成树问题 Prim算法是一种贪心算法,从起始顶点出发,每次迭代选择当前可用的最小权值边。 例      用Prim算法求下图的最小生成树。 用result3×nresult_...
  • 目录 1 CSP问题与模型 2 列生成方法理论 3 Cplex OPL演示列生成迭代过程 4 多种长度木材的例子 5 java实现代码
  • 该函数弥补了 TOEPLITZ(从第一行和第一构建 Toeplitz 矩阵)和 SPDIAGS(从其对角线创建稀疏矩阵)之间的一个小而烦人的差距。 SPTOEPLITZ 具有与 TOEPLITZ 相同的语法和用法,但它从不构造具有比最终结果更多的...
  • 蝙蝠算法matlab程序代码健壮的波束形成纸 描述 该项目包含针对脑电图数据的鲁棒波束成形算法的全面分析,该算法可解释头部模型中的各向异性不确定性。 如何设置? 运行模拟 跑步 startup 这将检查依赖项,并在缺少...
  • TDOA定位的Chan算法MATLAB源代码

    千次阅读 2021-08-06 17:13:03
    TDOA定位的Chan算法MATLAB源代码 。 function [POS_ref,POS1,POS2,POS3,POS4] = TDOA_chan(R,Pbs,Q) %********************************************************* % CHAN算法,假设移动台与各基站位置较近,需进行...
  • 粒子群PSO优化算法Matlab代码详解

    千次阅读 多人点赞 2021-05-20 21:45:17
    PSO算法代码详解 前期文章介绍了PSO算法的基本原理,来帮助同学们去了解PSO算法的流程。因为篇幅的问题呢,就没有在前期文章附上代码详解,为了弥补遗憾,我把代码解释作为独立的一篇博客发表,方便不同需求的同学...
  • 用于: A = BAgraph_dir(N,m0,m); 其中,N = 网络中的... 如果 i 连接到 j,则生成的邻接矩阵在第 i 行、第 j 中包含 1。 A 具有幂律度分布。 请耐心等待,因为该算法可能需要约 2-3 分钟来生成 N=300 的邻接矩阵。
  • MATLAB决策树算法

    2021-04-24 16:34:20
    MATLAB决策树算法》由会员分享,可在线阅读,更多相关《MATLAB决策树算法(3页珍藏版)》请在人人文库网上搜索。1、MATLAB决策树算法% I. 清空环境变量clear allclcwarning off% II. 导入数据 第一是序号 第二是...
  • 随机森林算法Matlab实现

    万次阅读 多人点赞 2019-05-25 18:26:32
    随机森林算法Matlab实现随机森林算法Matlab实现计算当前自身gini系数求最优划分点及其gini系数对data中按decision属性值从小到大排列生成结点生成随机采样样本数据生成决策树评价函数随机森林样本决策函数正确率计算...
  • Matlab随机数生成

    2020-11-08 20:47:08
    Matlab随机数生成的常用算法实现(用平方取中法产生随机数 、用混合同余法产生随机数 、用乘同余法1产生随机数 、产生柯西分布的随机数 、产生正态分布的随机数 、产生贝努里-高斯分布的随机数
  • 本文依然参考《MATLAB智能算法30个案例分析》一书,文末的源代码也来自本书上周有小伙伴后台问小编能否讲解一下关于多目标优化问题的算法,本周小编做足了功课,为大家更新这篇推文。在讲解多目标优化问题之前,小编...
  • 基于最小二乘法的AOA定位算法matlab实现 自己在学着实现这些算法,开始有点艰难,所以有兴趣的大家可以一起交流。对于下面代码如果哪里有问题,欢迎指正。 sensors=rand(2,10)*10; % 2x10未知坐标点(第一行是x值...
  • svd算法matlab代码rajSVD 给定很少的图像集,该项目使用巧妙地生成全新的可能图像。 代码实现在matlab中。 关键字:奇异值分解(SVD),Matlab 实际用例 输入:嘿节目,昨晚有人闯入A商店。我们从闭路电视摄影机获得...
  • K-Means算法实现(Matlab

    千次阅读 2021-04-20 14:28:41
    K-Means算法具体内容可以参考我博客的相关文章,这里只使用Matlab对其进行实现,其他内容不多赘述K-Means算法1.生成随机样本点首先利用 mvnrnd 函数生成3组满足高斯分布的数据,每组数据都是100*2的矩阵,也就相当于...
  • 算法MATLAB

    2021-04-20 04:03:45
    算法MATLABTag内容描述:1、LMS算法function yn,W,en=LMS(xn,dn,M,mu,itr)% LMS(Least Mean Squre)算法% 输入参数:% xn 输入的信号序列 (向量)% dn 所期望的响应序列 (向量)% M 滤波器的阶数 (标量)% mu 收敛...
  • 路径规划A*算法matlab代码注释

    万次阅读 多人点赞 2019-01-17 21:29:31
    路径规划A*算法matlab代码注释 文中所使用的代码出自手把手教用matlab做无人驾驶(三)-路径规划A*算法 一、Aplanning.m disp('A Star Path Planing start!!') p.start=[1,1]; %起始点 p.goal=[3,5]; %目标点 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,496
精华内容 4,598
关键字:

列生成算法matlab

matlab 订阅