精华内容
下载资源
问答
  • 这个函数接受两个矩阵 P 和 D,大概是输出从 Matlab 的 eig 函数,然后将 P 的列排序为匹配 D 的排序列(从大到小) 例子: D = -90 0 0 0 -30 0 0 0 -60 P = 1 2 3 1 2 3 1 2 3 [P,D]=排序(P,D) P = 2 3 1 2 3 1...
  • Matlab 语法记录(I)——特征排序问题

    万次阅读 多人点赞 2017-05-05 23:06:54
    特征排序问题矩阵的特征值分解矩阵的特征值分解是非常...在matlab中一般使用eig()函数完成矩阵特征值和特征向量的提取,其用法如下A = magic(4); [V,D] = eig(A);结果如下: A = 16 2 3 13 5 11 10 8 9 7 6 12

    1. 矩阵的特征值分解

    矩阵的特征值分解是非常重要的数学工具。在matlab中一般使用eig()函数完成矩阵特征值和特征向量的提取,其用法如下

    A = magic(4);
    [V,D] = eig(A);

    结果如下:

    A =
    16 2 3 13
    5 11 10 8
    9 7 6 12
    4 14 15 1
    V =
    -0.5000 -0.8236 0.3764 -0.2236
    -0.5000 0.4236 0.0236 -0.6708
    -0.5000 0.0236 0.4236 0.6708
    D =
    34.0000 0 0 0
    0 8.9443 0 0
    0 0 -8.9443 0
    0 0 0 -0.0000

    2. eig() 和 eigs()

    显然eig()就是一般意义上的计算矩阵的特征值和特征向量

    E = eig(A) 返回方阵A的所有特征值,构成列向量E。
    [V,D] = eig(A) 返回方阵A的特征值和特征向量,其中特征值排满对角阵D的对角元素,对应的特征向量排列为方阵V的每一列。

    而eigs()也能求取矩阵的特征值和特征向量,不过其返回的方阵幅值最大的6个特征值和特征向量,用法和eig()类似。不过eigs()通过迭代的方式来求解特征值,所以其在加快运算速度的同时降低了准确度。另外,一般eigs()处理的大型稀疏矩阵。

    [V,D] = eigs(A) 返回方阵A的前6个最大特征特征值和特征向量。
    [V,D] = eigs(A,k) 返回前k个最大特征值和特征向量。

    一般情况下,eig()和eigs()返回的特征值是从大到小排列,然而这并不是一定的。经过测试,两者的特征值排序都可能为乱序,所以,在对顺序有要求的情况下,需要通过sort()函数来自动排序。

    3. 使用sort()函数解决特征值排序问题

    如下

    A = magic(6);
    [V,D] = eig(A);
    [D_sort,index] = sort(diag(D),'descend');
    D_sort = D_sort(index);
    V_sort = V(:,index);

    按特征值大小排序结果如下:

    A =
    35 1 6 26 19 24
    3 32 7 21 23 25
    31 9 2 22 27 20
    8 28 33 17 10 15
    30 5 34 12 14 16
    4 36 29 13 18 11
    D =
    111.0000 0 0 0 0 0
    0 27.0000 0 0 0 0
    0 0 -27.0000 0 0 0
    0 0 0 9.7980 0 0
    0 0 0 0 0.0000 0
    0 0 0 0 0 -9.7980
    D_sort =
    111.0000
    27.0000
    -27.0000
    -9.7980
    9.7980
    0.0000

    4. Another Solution

    John D’Errico设计了一个eigenshuffle.m函数能够得到排序后的特征值和特征向量。该方法排序方式为特征值大小降序排列。
    速度测试:

    %a test by Min Qin
    A = magic(10);
    iterate = 10000;
    tic;
    for i = 1:iterate
        [V,D] = eig(A);
        [D_sort,index] = sort(diag(D),'descend');
        V_sort = V(:,index);
    end
    toc;
    tic;
    for i = 1:iterate
        [V_sort,D_sort] = eigenshuffle(A);
    end
    toc;

    结果:

    Elapsed time is 0.325471 seconds.
    Elapsed time is 0.447886 seconds.

    显然eigenshuffle函数的速度比传统方法略低。

    参考: https://cn.mathworks.com/matlabcentral/fileexchange/22885-eigenshuffle
    eigenshuffle.m代码:

    function [Vseq,Dseq] = eigenshuffle(Asequence)
    % eigenshuffle: Consistent sorting for an eigenvalue/vector sequence
    % [Vseq,Dseq] = eigenshuffle(Asequence)
    %
    % Includes munkres.m (by gracious permission from Yi Cao)
    % to choose the appropriate permutation. This greatly`这里写代码片`
    % enhances the speed of eigenshuffle over my previous
    % release.
    %
    % http://www.mathworks.com/matlabcentral/fileexchange/20652
    %
    % Arguments: (input)
    %  Asequence - an array of eigenvalue problems. If
    %      Asequence is a 3-d numeric array, then each
    %      plane of Asequence must contain a square
    %      matrix that will be used to call eig.
    %
    %      Eig will be called on each of these matrices
    %      to produce a series of eigenvalues/vectors,
    %      one such set for each eigenvalue problem.
    %
    % Arguments: (Output)
    %  Vseq - a 3-d array (pxpxn) of eigenvectors. Each
    %      plane of the array will be sorted into a
    %      consistent order with the other eigenvalue
    %      problems. The ordering chosen will be one
    %      that maximizes the energy of the consecutive
    %      eigensystems relative to each other.
    %
    %  Dseq - pxn array of eigen values, sorted in order
    %      to be consistent with each other and with the
    %      eigenvectors in Vseq.
    %
    % Example:
    %  Efun = @(t) [1 2*t+1 t^2 t^3;2*t+1 2-t t^2 1-t^3; ...
    %               t^2 t^2 3-2*t t^2;t^3 1-t^3 t^2 4-3*t];
    %
    %  Aseq = zeros(4,4,21);
    %  for i = 1:21
    %    Aseq(:,:,i) = Efun((i-11)/10);
    %  end
    %  [Vseq,Dseq] = eigenshuffle(Aseq);
    %  
    % To see that eigenshuffle has done its work correctly,
    % look at the eigenvalues in sequence, after the shuffle.
    %
    % t = (-1:.1:1)';
    % [t,Dseq']
    % ans =
    %        -1     8.4535           5      2.3447     0.20181
    %      -0.9     7.8121      4.7687      2.3728     0.44644
    %      -0.8     7.2481        4.56      2.3413     0.65054
    %      -0.7     6.7524      4.3648      2.2709      0.8118
    %      -0.6     6.3156      4.1751      2.1857     0.92364
    %      -0.5     5.9283      3.9855      2.1118     0.97445
    %      -0.4     5.5816      3.7931      2.0727     0.95254
    %      -0.3     5.2676      3.5976      2.0768       0.858
    %      -0.2     4.9791      3.3995      2.1156     0.70581
    %      -0.1     4.7109         3.2      2.1742     0.51494
    %         0     4.4605           3      2.2391     0.30037
    %       0.1     4.2302         2.8      2.2971    0.072689
    %       0.2     4.0303      2.5997      2.3303    -0.16034
    %       0.3     3.8817      2.4047      2.3064    -0.39272
    %       0.4     3.8108      2.1464      2.2628    -0.62001
    %       0.5     3.8302      1.8986      2.1111    -0.83992
    %       0.6     3.9301      1.5937      1.9298     -1.0537
    %       0.7     4.0927      1.2308       1.745     -1.2685
    %       0.8     4.3042     0.82515      1.5729     -1.5023
    %       0.9     4.5572     0.40389      1.4272     -1.7883
    %         1     4.8482  -8.0012e-16     1.3273     -2.1755
    %
    % Here, the columns are the shuffled eigenvalues.
    % See that the second eigenvalue goes to zero, but
    % the third eigenvalue remains positive. We can plot
    % eigenvalues and see that they have crossed, near
    % t = 0.35 in Efun.
    %
    % plot(-1:.1:1,Dseq')
    %
    % For a better appreciation of what eigenshuffle did,
    % compare the result of eig directly on Efun(.3) and
    % Efun(.4). Thus:
    %
    % [V3,D3] = eig(Efun(.3))
    % V3 =
    %     -0.74139      0.53464     -0.23551       0.3302
    %      0.64781       0.4706     -0.16256      0.57659
    %    0.0086542     -0.44236     -0.89119      0.10006
    %     -0.17496     -0.54498      0.35197      0.74061
    %
    % D3 =
    %     -0.39272            0            0            0
    %            0       2.3064            0            0
    %            0            0       2.4047            0
    %            0            0            0       3.8817
    %
    % [V4,D4] = eig(Efun(.4))
    % V4 =
    %     -0.73026      0.19752      0.49743      0.42459
    %      0.66202      0.21373      0.35297      0.62567
    %     0.013412     -0.95225      0.25513      0.16717
    %     -0.16815    -0.092308     -0.75026      0.63271
    %
    % D4 =
    %     -0.62001            0            0            0
    %            0       2.1464            0            0
    %            0            0       2.2628            0
    %            0            0            0       3.8108
    %
    % With no sort or shuffle applied, look at V3(:,3). See
    % that it is really closest to V4(:,2), but with a sign
    % flip. Since the signs on the eigenvectors are arbitrary,
    % the sign is changed, and the most consistent sequence
    % will be chosen. By way of comparison, see how the
    % eigenvectors in Vseq have been shuffled, the signs
    % swapped appropriately.
    %
    % Vseq(:,:,14)
    % ans =
    %       0.3302      0.23551     -0.53464      0.74139
    %      0.57659      0.16256      -0.4706     -0.64781
    %      0.10006      0.89119      0.44236   -0.0086542
    %      0.74061     -0.35197      0.54498      0.17496
    %
    % Vseq(:,:,15)
    % ans =
    %      0.42459     -0.19752     -0.49743      0.73026
    %      0.62567     -0.21373     -0.35297     -0.66202
    %      0.16717      0.95225     -0.25513    -0.013412
    %      0.63271     0.092308      0.75026      0.16815
    %
    % See also: eig
    %
    % Author: John D'Errico
    % e-mail: woodchips@rochester.rr.com
    % Release: 3.0
    % Release date: 2/18/09
    
    % Is Asequence a 3-d array?
    Asize = size(Asequence);
    if (Asize(1)~=Asize(2))
      error('Asequence must be a (pxpxn) array of eigen-problems, each of size pxp')
    end
    p = Asize(1);
    if length(Asize)<3
      n = 1;
    else
      n = Asize(3);
    end
    
    % the initial eigenvalues/vectors in nominal order
    Vseq = zeros(p,p,n);
    Dseq = zeros(p,n);
    for i = 1:n
      [V,D] = eig(Asequence(:,:,i));
      D = diag(D);
      % initial ordering is purely in decreasing order.
      % If any are complex, the sort is in terms of the
      % real part.
      [junk,tags] = sort(real(D),1,'descend');
    
      Dseq(:,i) = D(tags);
      Vseq(:,:,i) = V(:,tags);
    end
    
    % was there only one eigenvalue problem?
    if n < 2
      % we can quit now, having sorted the eigenvalues
      % as best as we could.
      return
    end
    
    % now, treat each eigenproblem in sequence (after
    % the first one.)
    for i = 2:n
      % compute distance between systems
      V1 = Vseq(:,:,i-1);
      V2 = Vseq(:,:,i);
      D1 = Dseq(:,i-1);
      D2 = Dseq(:,i);
      dist = (1-abs(V1'*V2)).*sqrt( ...
        distancematrix(real(D1),real(D2)).^2+ ...
        distancematrix(imag(D1),imag(D2)).^2);
    
      % Is there a best permutation? use munkres.
      % much faster than my own mintrace, munkres
      % is used by gracious permission from Yi Cao.
      reorder = munkres(dist);
    
      Vseq(:,:,i) = Vseq(:,reorder,i);
      Dseq(:,i) = Dseq(reorder,i);
    
      % also ensure the signs of each eigenvector pair
      % were consistent if possible
      S = squeeze(real(sum(Vseq(:,:,i-1).*Vseq(:,:,i),1))) < 0;
      Vseq(:,S,i) = -Vseq(:,S,i);
    end
    
    % =================
    % end mainline
    % =================
    % begin subfunctions
    % =================
    
    function d = distancematrix(vec1,vec2)
    % simple interpoint distance matrix
    [vec1,vec2] = ndgrid(vec1,vec2);
    d = abs(vec1 - vec2);
    
    function [assignment,cost] = munkres(costMat)
    % MUNKRES   Munkres (Hungarian) Algorithm for Linear Assignment Problem. 
    %
    % [ASSIGN,COST] = munkres(COSTMAT) returns the optimal column indices,
    % ASSIGN assigned to each row and the minimum COST based on the assignment
    % problem represented by the COSTMAT, where the (i,j)th element represents the cost to assign the jth
    % job to the ith worker.
    %
    
    % This is vectorized implementation of the algorithm. It is the fastest
    % among all Matlab implementations of the algorithm.
    
    % Examples
    % Example 1: a 5 x 5 example
    %{
    [assignment,cost] = munkres(magic(5));
    disp(assignment); % 3 2 1 5 4
    disp(cost); %15
    %}
    % Example 2: 400 x 400 random data
    %{
    n=400;
    A=rand(n);
    tic
    [a,b]=munkres(A);
    toc                 % about 2 seconds 
    %}
    % Example 3: rectangular assignment with inf costs
    %{
    A=rand(10,7);
    A(A>0.7)=Inf;
    [a,b]=munkres(A);
    %}
    % Reference:
    % "Munkres' Assignment Algorithm, Modified for Rectangular Matrices", 
    % http://csclab.murraystate.edu/bob.pilgrim/445/munkres.html
    
    % version 2.0 by Yi Cao at Cranfield University on 10th July 2008
    
    assignment = zeros(1,size(costMat,1));
    cost = 0;
    
    costMat(costMat~=costMat)=Inf;
    validMat = costMat<Inf;
    validCol = any(validMat,1);
    validRow = any(validMat,2);
    
    nRows = sum(validRow);
    nCols = sum(validCol);
    n = max(nRows,nCols);
    if ~n
        return
    end
    
    maxv=10*max(costMat(validMat));
    
    dMat = zeros(n) + maxv;
    dMat(1:nRows,1:nCols) = costMat(validRow,validCol);
    
    %*************************************************
    % Munkres' Assignment Algorithm starts here
    %*************************************************
    
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    %   STEP 1: Subtract the row minimum from each row.
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    minR = min(dMat,[],2);
    minC = min(bsxfun(@minus, dMat, minR));
    
    %**************************************************************************  
    %   STEP 2: Find a zero of dMat. If there are no starred zeros in its
    %           column or row start the zero. Repeat for each zero
    %**************************************************************************
    zP = dMat == bsxfun(@plus, minC, minR);
    
    starZ = zeros(n,1);
    while any(zP(:))
        [r,c]=find(zP,1);
        starZ(r)=c;
        zP(r,:)=false;
        zP(:,c)=false;
    end
    
    while 1
    %**************************************************************************
    %   STEP 3: Cover each column with a starred zero. If all the columns are
    %           covered then the matching is maximum
    %**************************************************************************
        if all(starZ>0)
            break
        end
        coverColumn = false(1,n);
        coverColumn(starZ(starZ>0))=true;
        coverRow = false(n,1);
        primeZ = zeros(n,1);
        [rIdx, cIdx] = find(dMat(~coverRow,~coverColumn)==bsxfun(@plus,minR(~coverRow),minC(~coverColumn)));
        while 1
            %**************************************************************************
            %   STEP 4: Find a noncovered zero and prime it.  If there is no starred
            %           zero in the row containing this primed zero, Go to Step 5.  
            %           Otherwise, cover this row and uncover the column containing 
            %           the starred zero. Continue in this manner until there are no 
            %           uncovered zeros left. Save the smallest uncovered value and 
            %           Go to Step 6.
            %**************************************************************************
            cR = find(~coverRow);
            cC = find(~coverColumn);
            rIdx = cR(rIdx);
            cIdx = cC(cIdx);
            Step = 6;
            while ~isempty(cIdx)
                uZr = rIdx(1);
                uZc = cIdx(1);
                primeZ(uZr) = uZc;
                stz = starZ(uZr);
                if ~stz
                    Step = 5;
                    break;
                end
                coverRow(uZr) = true;
                coverColumn(stz) = false;
                z = rIdx==uZr;
                rIdx(z) = [];
                cIdx(z) = [];
                cR = find(~coverRow);
                z = dMat(~coverRow,stz) == minR(~coverRow) + minC(stz);
                rIdx = [rIdx(:);cR(z)];
                cIdx = [cIdx(:);stz(ones(sum(z),1))];
            end
            if Step == 6
                % *************************************************************************
                % STEP 6: Add the minimum uncovered value to every element of each covered
                %         row, and subtract it from every element of each uncovered column.
                %         Return to Step 4 without altering any stars, primes, or covered lines.
                %**************************************************************************
                [minval,rIdx,cIdx]=outerplus(dMat(~coverRow,~coverColumn),minR(~coverRow),minC(~coverColumn));            
                minC(~coverColumn) = minC(~coverColumn) + minval;
                minR(coverRow) = minR(coverRow) - minval;
            else
                break
            end
        end
        %**************************************************************************
        % STEP 5:
        %  Construct a series of alternating primed and starred zeros as
        %  follows:
        %  Let Z0 represent the uncovered primed zero found in Step 4.
        %  Let Z1 denote the starred zero in the column of Z0 (if any).
        %  Let Z2 denote the primed zero in the row of Z1 (there will always
        %  be one).  Continue until the series terminates at a primed zero
        %  that has no starred zero in its column.  Unstar each starred
        %  zero of the series, star each primed zero of the series, erase
        %  all primes and uncover every line in the matrix.  Return to Step 3.
        %**************************************************************************
        rowZ1 = find(starZ==uZc);
        starZ(uZr)=uZc;
        while rowZ1>0
            starZ(rowZ1)=0;
            uZc = primeZ(rowZ1);
            uZr = rowZ1;
            rowZ1 = find(starZ==uZc);
            starZ(uZr)=uZc;
        end
    end
    
    % Cost of assignment
    rowIdx = find(validRow);
    colIdx = find(validCol);
    starZ = starZ(1:nRows);
    vIdx = starZ <= nCols;
    assignment(rowIdx(vIdx)) = colIdx(starZ(vIdx));
    cost = trace(costMat(assignment>0,assignment(assignment>0)));
    
    function [minval,rIdx,cIdx]=outerplus(M,x,y)
    [nx,ny]=size(M);
    minval=inf;
    for r=1:nx
        x1=x(r);
        for c=1:ny
            M(r,c)=M(r,c)-(x1+y(c));
            if minval>M(r,c)
                minval=M(r,c);
            end
        end
    end
    [rIdx,cIdx]=find(M==minval);
    展开全文
  • 转换完之后对向量进行逆序排列,我看到有同学硬是写了一个冒泡排序来完成这个工作,你的数据结构老师一定非常欣慰。但是在 MATLAB 里不用从头开始,直接调用sort()函数就行了~但是在这里还有更简单的方法,wrev()...

     其实 MATLAB 内置的函数就有diag()可以将一个对角矩阵转化为一个向量,也可以将一个向量转化为一个对角矩阵。转换完之后对向量进行逆序排列,我看到有同学硬是写了一个冒泡排序来完成这个工作,你的数据结构老师一定非常欣慰。但是在 MATLAB 里不用从头开始,直接调用sort()函数就行了~但是在这里还有更简单的方法,wrev()函数就可以将一个向量逆序排列,fliplr()函数可以将一个矩阵左右镜像对称,所以如果想得到从大到小排列的特征值,只要这样就行了:

    % 得到从大到小排列的特征值
    [V, D] = eig(A);
    lambda = wrev(diag(D));
    V = fliplr(V);

    例子:

    clear all;clc;close all;
    A=[61.45,55.9,61.95,59,58.14,53.61,55.48,54.21,61.52,54.92];
    B=[40.36,39.8,49.2,48,51.5,49.39,51.13,58.06,61,62.35];
    C=[8.61,8.91,10.43,13.32,13.48,15.75,18.14,19.95,21.95,23.53];
    D=[14.31,14.72,15.28,15.91,14.67,15,15.86,15.16,13.72,12.94];
    E=[7.67,7.75,8.15,9.24,10.68,10.58,10.31,10,8.91,8.51];
    q=[A',B',C',D',E'];
    w=cov(q);
    % 得到从大到小排列的特征值
    [V, D] = eig(w);
    lambda = wrev(diag(D));
    V1 = fliplr(V)
    
    

    转载:https://blog.csdn.net/robertchenguangzhi/article/details/40747285

    Matlab 矩阵特征值排序问题

    展开全文
  • 向量A中的元素对应的由小到大排序后的序号,查百度得到的解决方案为: [B,I] = sort(A); [~,II] = sort(I); sort用法自行查,上述程序得到的II即为所求的序号向量 这个实现过程很简单,但我理解起来总感觉...

    求向量A中的元素对应的由小到大排序后的序号,查百度得到的解决方案为:
     

    [B,I] = sort(A);
    [~,II] = sort(I);

    sort用法自行查,上述程序得到的II即为所求的序号向量

    这个实现过程很简单,但我理解起来总感觉要点绕,接下来就在这里简单的梳理一下思路

     

    求A中元素对应的排序后的序号 → A中元素对应在B中的位置 → A中的序号对应B中序号的位置

    在理解这个之前,先将向量元素和其对应的序号看成一个整体,在排序过程中原向量的元素和序号对应关系不变,则上面程序可以表示为

              

    举个具体例子:假设A = [5 8 1 3 2]

    得到的[4 5 1 3 2]对应的即为所求序号向量

     

     

    展开全文
  • matlab开发-排序特征向量初始值。对一组特征向量及其特征值进行排序
  • Matlab与数据结构 -- 对向量排序

    千次阅读 2016-11-18 10:40:45
    本图文介绍了Matlab怎样实现对向量排序

    本图文介绍了Matlab怎样实现对向量的排序。

    这里写图片描述

    展开全文
  • matlab向量排序(自写函数)

    千次阅读 2014-10-31 20:53:56
    function a_ed = arraysort(a) %冒泡排序法 for i =1:length(a)-1 %进行多少次比较 for j=1+i:length(a) %每次求出最大的数,放在最后 if(a(j)(i)) tem = a(i); a(i) = a(j);
  • 排序向量“x”中搜索值“v”并找到索引和值关于向量 x 等于或最接近 'v'。 如果多个值相等,则可以返回任何人(这是二进制搜索的属性)。 如果有多个值最接近,则返回第一个出现的值(这是线性搜索的属性)。 ...
  • 利用 matlab sort 函数,就可以了,如:   >> X = [3 7 5 0 4 2 ]; >> [y, index] = sort(X) y =  0 2 3 4 5 7 index =  4 6 1 5 3 2   转载于:...
  • matlab中的eig函数 求特征值和特征向量
  • matlab关于特征值、特征向量的技巧

    千次阅读 2017-03-14 17:42:59
    在作业中需要求某个矩阵的特征值和特征向量,当然同学们都会使用 MATLAB 内置的函数[V, D] = eig(A),这样得到的对角矩阵 D 其对角线元素就是从小到大排列的的特征值。有的同学希望能将这个对角线元素单独抽取出来...
  • 假设矩阵 AAA的特征值按模排序为 ∣λ1∣≥∣λ2∣≥...≥∣λn∣|\lambda_1|≥|\lambda_2|≥...≥|\lambda_n|∣λ1​∣≥∣λ2​∣≥...≥∣λn​∣,于是对任一非零向量 V(0)∈RnV^{(0)}∈R^nV(0)∈Rn可得到 (1)...
  • 在作业中需要求某个矩阵的特征值和特征向量,当然同学们都会使用 MATLAB 内置的函数[V, D] = eig(A),这样得到的对角矩阵 D 其对角线元素就是从小到大排列的的特征值。有的同学希望能将这个对角线元素单独抽取出来...
  • SHUFFLE 打乱向量或矩阵。 % SHUFFLE(X) 打乱向量或矩阵 X 的元素。 % % SHUFFLE(X,DIM) 沿维度 DIM 随机播放。 % % [Y,I] = SHUFFLE(X) 也返回一个索引矩阵 I。如果 X 是% 一个向量,那么 Y = X(I)。 如果 X 是 m×...
  • 归并排序------------------ 如果我们有两个单独排序向量“a”和“b”,但它们没有相互排序,我们想将它们合并到向量“c”中,这样​​“c”也是一个排序向量。 然后可以使用 c=mergesorted(a,b)。 此函数最有...
  • matlab开发-将两个端口向量合并到排序向量中。将两个排序向量“a”和“b”合并到一个排序向量“c”
  • MATLAB —— 向量,矩阵,数组

    千次阅读 2019-01-26 20:33:45
    MATLAB —— 向量,矩阵,数组   目录 MATLAB —— 向量,矩阵,数组 一、向量 1、向量定义 2、引用向量元素 3、向量运算 二、矩阵 1、矩阵定义 2、引用矩阵 3、矩阵运算 三、数组   一、向量 1、...
  • % 目的:将列向量 x 排序并划分为分位数%-------------------------------------------- % 用法:y=fractile(x,f,ascending); % 其中: y = 包含输出分位数及其索引号的元胞数组结构% x = 输入向量% f = 要划分的分...
  • 感谢大家观看你所做的事情,也行暂时看不到成功,但不要... 如果大家看到该文章有些格式上的错误或内容上的错误, 欢迎评论指正.Matlab基础入门在MATLAB中使用分号;分号;表示结束语句如果要抑制和隐藏表达式的MATLAB...
  • MATLAB 向量和矩阵

    千次阅读 2020-05-15 18:48:18
    (1)所有MATLAB变量都是数组: 这意味着每个变量均可以包含多个元素 单个称为标量的数值实际上是一个1×1数组 (2)创建包含多个元素的数组: #用空格/逗号(,)分隔的值会被组合为一个行向量 x = [ a b ... ] / x = [ a ...
  • 此块使用http://en.wikipedia.org/wiki/Quicksort 中所述的快速排序算法对输入向量进行排序 Quicksort 是世界上使用最广泛的排序算法,甚至可能是世界上使用最广泛的任何一种算法。 有关该算法的数学行为的更多信息...
  • 对矩阵的特征值和特征向量的计算一直在数值计算占有重要位置。这里介绍一种根据指定个数来返回矩阵特征值及特征向量的方式。 实例 % By lyqmath % Dalian University of Technology % School of Mathematical ...
  • } } // 特征排序 std::map, int> mapEigen; for (int i = 0; i ; i++) { eigenvalues[i] = mat[i][i]; mapEigen.insert(make_pair(eigenvalues[i], i)); } double *pdbTmpVec = new ...
  • MATLAB中SVM的特征重要性排序

    千次阅读 2018-12-01 21:19:07
    MATLAB中可以通过支持向量机递归特征消除(Support Vector Machine Recursive Feature Elimination :SVM-RFE)来获得SVM的特征重要性排序!!! SVM-RFE算法是根据SVM在训练时生成的权向量w来构造排序...
  • Matlab向量或者矩阵进行随机排列

    千次阅读 2017-07-20 08:52:56
    输入:5X5矩阵 输出:3X5 矩阵,其中该三行数据来自于数据的前三行的随机排列 方法:(1)使用randperm生成随机序列;(2)以随机序列为index,重新组织输入矩阵中的数据 >> a=[1 1 1 0 0;...1 1 0 1
  • matlab查看向量和矩阵中的数据

    千次阅读 2019-05-19 12:40:56
    matlab的索引是从1开始的。 一、查看向量 1、查看单个数据 vec1 = [11 12 13 14 15]; vec1(2) %向量vec1中第2个数据 2、查看一段数据(截取一段数据) vec1(2:3) %向量vec1位置2至位置3 vec1(2:length...
  • 特征向量和分类方法

    千次阅读 2020-06-17 09:57:01
    特征向量和分类方法 分类与聚类的区别 机器学习中有常见的两类大问题,一个是分类,一个是聚类。 分类与聚类的比较 1. 聚类分析是研究如何在没有训练的条件下把样本划分为若干类。 2. 在分类中,已知存在哪些类,即...
  • 有效地从 [0,1] 均匀地生成 n 个已排序的 p 向量,即每个向量满足 x_1 <= x_2 <= x_3 <= ... <= x_p 从以下实现算法: (1) 生成随机数的排序列表Jon Louis Bentley 和 James B. Saxe ACM 数学软件交易...
  • matlab中eig函数求特征值和特征向量,但特征值是随机排列的。要想取得前k个特征值(绝对值前k小的特征值)和对应的特征向量,还得另想办法。 matlab自带的eigs是用来求绝对值前k大的特征值。 实现了...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,741
精华内容 2,696
关键字:

matlab特征向量排序

matlab 订阅