精华内容
下载资源
问答
  • 重构代码
    更多相关内容
  • 相空间重构函数,相空间重构定理,matlab源码
  • 12改进的C-C相空间重构自然函数法确定延迟时间wolf法求李雅普诺夫指数小数据量法求李雅普诺夫指数
  • 相空间重构matlab程序

    2014-02-17 13:49:06
    相空间重构matlab代码,经过实验可用。
  • 能够在MATLAB中进行相空间重构辅助时间序列分析,亲测可用
  • 相空间重构代码-matlab

    热门讨论 2011-02-10 18:41:15
    matlab实现混沌理论中的相空间重构代码,很好用的工具!
  • 计算2个序列的互信息熵,使用等间距划分格子法
  • 相空间重构matlab实现

    千次阅读 热门讨论 2020-08-31 17:31:17
    相空间重构 对于相空间重构需要确定的嵌入维数(m)和时间延迟(τττ) 使用C-C法可同时确定m和τττ,也可使用求自相关系数当ACF的值低于1−e−11-e ^{-1}1−e−1,从而确定时间延迟。然后通过G-P算法确定m。由于...

    相空间重构

    ##更新:最近重新看了这部分的内容,发现dts=max(ds)-min(ds);有误,应该是用r最大的时候的s减去最小时候的s。改为dts = ds(end)-ds(1)。以及C2应该有个m次幂。还有每次计算r应该是子序列对应的领域半径。

    对于相空间重构需要确定的嵌入维数(m)和时间延迟( τ τ τ)
    使用C-C法可同时确定m和 τ τ τ,也可使用求自相关系数当ACF的值低于 1 − e − 1 1-e ^{-1} 1e1,从而确定时间延迟。然后通过G-P算法确定m。由于使用G-P算法所需时间较长。故本文直接使用C-C法确定两个参数。
    时间窗口 t m = ( m − 1 ) ∗ τ t_m=(m-1)*τ tm=(m1)τ
    本文所给的函数是自己编写的,故大家可用于参考,对于相空间理论部分,懒得编写了,直接百度即可。

    确定参数 t m t_m tm τ τ τ的主函数

    clc;clear
    % C-C方法的主程序
    data=xlsread('all_data7.xlsx','all_data','b1:b20000');
    [ACF,lags,bounds]=autocorr(data,100);
    tau=59;
    m=15;
    [D,MEAN,STD]=zscore(data);
    r1=0.5*STD;
    N=length(data);
    [a,b]=find(ACF<ACF(1)*(1-exp(-1)));
    beifen=data;
    %% 求统计量S
    SS=[];
    DTS=[];
    COR=[];
    T=[];
    NN=1:6000;
    for t=1:100
       sums=0;
       sumdts=0;
    %     if mod(N,t)~=0
    %         [a,b]=find(mod(NN,t)==0);
    %         data=beifen(1:b(end));
    %     end
           for i=1:t
               eval(['datat',num2str(i),'=[];'])
               for j=1:N/t
                   eval(['tran=data(',num2str(i),'+',num2str(t),'*(',num2str(j),'-1));'])
                   eval(['datat',num2str(i),'=[datat',num2str(i),';tran];'])
               end
           end
           for m=2:5
               ds=[];
               for k=1:4
                   S=[];
                   for i=1:t
                       eval(['S',num2str(i),'=[];'])
                       eval(['datat=datat',num2str(i),';'])
                       r=r1*k;
                       C1=C(m,N/t,r,t,datat);%%计算关联积分
                       C2=C(1,N/t,r,t,datat);
                       eval(['S',num2str(i),'=[S',num2str(i),',C1-C2];'])%% 计算检验统计量
                       eval(['S=[S;S',num2str(i),'];'])
                   end
                   S=sum(S)/t;
                   ds=[ds,S];
                   sums=sums+S;
               end
               dts=max(ds)-min(ds);%% 求ΔS
               sumdts=sumdts+dts;
           end
           sums=sums/16;
           sumdts=sumdts/4;
           scor=sumdts+abs(sums);
           T=[T;t];
    %     S=S/t;
       SS=[SS;sums];
       DTS=[DTS;sumdts];
       COR=[COR;scor];
    end
    % xieru=["datat1","datat2","datat3","datat4","datat5"];
    % for i=1:t
    %     eval(['tran=datat',num2str(i),';'])
    %     xlswrite('xkjcg.xlsx',tran,xieru(i));
    % end
    tt=1:100;
    plot(tt,SS,tt,DTS,tt,COR)
    legend('SS','DTS','COR')
    
    

    C子程序

     %% 相空间重构确定嵌入维数和时间延迟
    function [C]=C(m,N,r,t,data)
    
    %% 将原始数据 重构相空间
    M=N-(m-1)*t;%% M为重构相空间中相点的个数
    x=[];%x用于保存相空间重构的结果
    for i=1:M
        for j=1:m
            x(i,j)=[data(i+(j-1)*t)];
        end
    end
    sumM=0;
    for j=1:M
        for i=1:j
            dij=sum(abs(x(i,:)-x(j,:)));
            if (r-dij)<0
                th=0;
            else
                th=1;
            end
            sumM=sumM+th;
        end
    end
    C=2*sumM/(M*(M-1));
    end
    
    展开全文
  • 关联积分计算function C_I=correlation_integral(X,M,r)%该函数用来计算关联积分%C_I:关联积分的返回值%X:重构相空间矢量,是一个m*M的矩阵%M::M是重构的m维相空间中的总点数%r:Heaviside 函数中的搜索半径sum_H=0...

    关联积分计算

    function C_I=correlation_integral(X,M,r)

    %该函数用来计算关联积分

    %C_I:关联积分的返回值

    %X:重构的相空间矢量,是一个m*M的矩阵

    %M::M是重构的m维相空间中的总点数

    %r:Heaviside 函数中的搜索半径

    sum_H=0;

    for i=1:M-1

    for j=i+1:M

    d=norm((X(:,i)-X(:,j)),inf);

    %计算相空间中每两点之间的距离,其中NORM(V,inf) = max(abs(V)).

    if r>d

    %sita=heaviside(r,d);%计算Heaviside 函数之值n

    sum_H=sum_H+1;

    end

    end

    end

    C_I=2*sum_H/(M*(M-1));

    %关联积分的值

    相空间重构

    function Data=reconstitution(data,m,tau)

    %该函数用来重构相空间

    % m:嵌入空间维数

    % tau:时间延迟

    % data:输入时间序列

    % Data:输出,是m*n维矩阵

    N=length(data);

    % N为时间序列长度

    M=N-(m-1)*tau;

    %相空间中点的个数

    Data=zeros(m,M);

    for j=1:M

    for i=1:m

    %相空间重构

    Data(i,j)=data((i-1)*tau+j);

    end

    end

    时间序列分解

    function Data=disjoint(data,t)

    % 此函数用于将时间序列分解成t个不相交的时间序列

    % data:输入时间序列

    % t:延迟,也是不相交时间序列的个数

    % Data:返回分解后的t个不相交的时间序列

    N=length(data);

    %data的长度

    for i=1:t

    for j=1:(N/t)

    Data(j,i)=data(i+(j-1)*t);

    end

    end

    Heaviside函数的计算

    function sita=heaviside(r,d)

    % 该函数用来计算Heaviside函数的值

    %sita:Heaviside函数的值

    %r:Heaviside函数的搜索半径

    %d:两点之间的距离

    if (r-d)<0

    sita=0;

    else

    sita=1;

    end

    延迟时间和时间窗口计算

    function [Smean,Sdeltmean,Scor,tau,tw]=C_CMethod(data,max_d)

    % 本函数用于求延迟时间tau和时间窗口tw

    % data:输入时间序列

    % max_d:最大时间延迟

    % Smean,Sdeltmean,Scor为返回值

    % tau:计算得到的延迟时间

    % tw:时间窗口

    N=length(data);

    %时间序列的长度

    Smean=zeros(1,max_d);

    %初始化矩阵

    Scmean=zeros(1,max_d);

    Scor=zeros(1,max_d);

    sigma=std(data);

    %计算序列的标准差

    % 计算Smean,Sdeltmean,Scor

    for t=1:max_d

    S=zeros(4,4);

    Sdelt=zeros(1,4);

    for m=2:5

    for j=1:4

    r=sigma*j/2;

    Xdt=disjoint(data,t);

    % 将时间序列data分解成t个不相交的时间序列

    s=0;

    for tau=1:t

    N_t=floor(N/t);

    % 分成的子序列长度

    Y=Xdt(:,tau);

    % 每个子序列

    %计算C(1,N/t,r,t),相当于调用Cs1(tau)=correlation_integral1(Y,r)

    Cs1(tau)=0;

    for ii=1:N_t-1

    for jj=ii+1:N_t

    d1=abs(Y(ii)-Y(jj));

    % 计算状态空间中每两点之间的距离,取无穷范数

    if r>d1

    Cs1(tau)=Cs1(tau)+1;

    end

    end

    end

    Cs1(tau)=2*Cs1(tau)/(N_t*(N_t-1));

    Z=reconstitution(Y,m,1);

    % 相空间重构

    M=N_t-(m-1);

    Cs(tau)=correlation_integral(Z,M,r);

    % 计算C(m,N/t,r,t)

    s=s+(Cs(tau)-Cs1(tau)^m);

    % 对t个不相关的时间序列求和

    end

    S(m-1,j)=s/tau;

    end

    Sdelt(m-1)=max(S(m-1,:))-min(S(m-1,:));

    % 差量计算

    end

    Smean(t)=mean(mean(S));

    % 计算平均值

    Sdeltmean(t)=mean(Sdelt);

    % 计算平均值

    Scor(t)=abs(Smean(t))+Sdeltmean(t);

    end

    % 寻找时间延迟tau:即Sdeltmean第一个极小值点对应的t

    for i=2:length(Sdeltmean)-1

    if Sdeltmean(i)

    tau=i;

    break;

    end

    end

    % 寻找时间窗口tw:即Scor最小值对应的t

    for i=1:length(Scor)

    if Scor(i)==min(Scor)

    tw=i;

    break;

    end

    end

    展开全文
  • C-C算法求取关联维数和延时时间,代码很好用的哟
  • mutual_information_相空间重构matlab_互信息熵_源码.zip
  • 资源名:相空间重构方法_混沌时间序列预测_matlab 资源类型:matlab项目全套源码 源码说明: 全部项目源码都是经过测试校正后百分百成功运行的,如果您下载后不能运行可联系我进行指导或者更换。 适合人群:新手及有...
  • mutual_information_相空间重构matlab_互信息熵.zip
  • 输出是图上显示的 E1 和 E2。代码使用 Lorenz 和 Rossler 时间序列进行了测试。
  • 混沌相空间重构中求时延和嵌入维的matlab代码

    千次阅读 热门讨论 2020-08-04 11:24:02
    %相重构 Y=Y'; [m,M]=size(Y); for i=1:N-m*tau %-----计算第i个向量与每个向量的距离存于d(j)中-------- for j=1:N-m*tau d(j)=norm(Y(:,i)-Y(:,j),inf); end %-----求距离最短向量的下标----------- temp=sort(d);...

    这个函数是用互信息法求时延的,好像是找到第一个极小值就是最佳时延

    function [mi] = VectorMI(data,delta_t1,N)
    % 该函数用来计算一个向量之间的互信息随时延的变化
    % delta_t1是计算互信息的最大时延
    % N是参与计算的点数
    
    for j=1:delta_t1
        u1=data(1:N);
        u2=data(1+j:N+j);
    
        wind_size=floor(power(length(u1),1/3)+0.5);%floor向负无穷取整,power幂运算
    
        x = [u1, u2];
        n = wind_size;
        [xrow, xcol] = size(x);
        bin = zeros(xrow,xcol);
        pmf = zeros(n, 2);
    
        for i = 1:2
            minx = min(x(:,i));
            maxx = max(x(:,i));
            binwidth = (maxx - minx) / n;
            edges = minx + binwidth*(0:n);
            histcEdges = [-Inf edges(2:end-1) Inf];
            [occur,bin(:,i)] = histc(x(:,i),histcEdges,1);
            pmf(:,i) = occur(1:n)./xrow;
        end
    
        % Calculate the joint probability density of u1 and u2
        jointOccur = accumarray(bin,1,[n,n]);
    
        %(xi?yi) The number of two data falling into the n * n aliquot is the joint probability density
        jointPmf = jointOccur./xrow;
        Hx = -(pmf(:,1))'*log2(pmf(:,1)+eps);
        Hy = -(pmf(:,2))'*log2(pmf(:,2)+eps);
        Hxy = -(jointPmf(:))'*log2(jointPmf(:)+eps);
        MI = Hx+Hy-Hxy;
        mi(j) = MI/sqrt(Hx*Hy);
    end
    

    这个函数用cao法来求最佳嵌入维,网上找来自己修改的,反正是能用,原理还挺复杂。

    function cao_m(data,min_m,max_m,tau)
    % 该程序计算时间序列的嵌入维数
    % data为原始数据,是列向量
    % min_m,max_m分别为最小和最大嵌入维数
    % tau为时间延迟
    % 计算值会稳定在某个值附近,开始稳定的位置就是嵌入维数
     
    N=length(data);
    k=1;
     
    for m=min_m:max_m
        Y=phasespace(data,m,tau);%相重构
        Y=Y';
        [m,M]=size(Y);
        for i=1:N-m*tau
            %-----计算第i个向量与每个向量的距离存于d(j)--------
            for j=1:N-m*tau
                d(j)=norm(Y(:,i)-Y(:,j),inf);
            end
            %-----求距离最短向量的下标-----------
            temp=sort(d);
            D(i,1)=i;      %D的第一列为向量序号
            temp1=find(temp>0);
            temp2=find(d==temp(temp1(1)));
            D(i,2)=temp2(1);  %第二列为与之对应的最短距离向量的序号
            D(i,3)=temp(temp1(1));%第三列为与之对应的最短距离
            %-----------计算a(i,m)-----------------------
            Y1=[Y(:,i);data(m*tau+i)];
            Y2=[Y(:,D(i,2));data(D(i,2)+m*tau)];
            ad(i)=norm(Y1-Y2,inf)/D(i,3);
            clear d Y1 Y2 temp temp1 temp2
        end
         %---------------E(d)-----------------
        E(k,1)=m;
        E(k,2)=sum(ad)/(N-m*tau);
        %---------------求E*(d)-----------------
        En(k,1)=m;
        En1(k,1)=m;
        for kk=1:N-m*tau
             dd(kk)=abs(data(D(kk,1)+m*tau)-data(D(kk,2)+m*tau));
             %dd1(kk)=abs(data(D(kk,1)+1)-data(D(kk,2)+1));
        end
        En(k,2)=sum(dd)/(N-m*tau);
        k=k+1;
     
        clear D
    end
     
    %-----------E1(d)-------------------
    for i=1:(max_m-min_m)
        E1(i,1)=E(i,1);
        E1(i,2)=E(i+1,2)/E(i,2);
    end
    %-----------E2(d)-------------------
    for i=1:(max_m-min_m)
        E2(i,1)=En(i,1);
        E2(i,2)=En(i+1,2)/En(i,2);
    end
    %-----------画图------------------------
    figure(1)
    plot(E1(:,1),E1(:,2),'-bs',E2(:,1),E2(:,2),'-r*');xlabel('维数');ylabel('E1(d)&E2(d)');
    grid on
    
    
    展开全文
  • 相空间重构可以对混沌信号进行混沌特性分析,已经验证过,可以直接使用
  • mdembedding:用于估计用于多元数据的相空间重构的参数的MATLAB代码
  • 相空间重构,相空间重构理论,matlab源码.zip.zip
  • 根据单变量时间序列相空间重构思想,提出了多变量时间序列描述的复杂系统的相空间延迟重构方法。对每一分量的时间序列,分别利用互信息最小法确定最佳延迟时间间隔,最小嵌入维数的选取方法是单变量时间序列情况下...
  • matlab相空间重构函数phaseSpaceReconstruction.m,可自动获取嵌入维数eDim,延迟时间eLag
  • 混沌序列的相空间重构MATLABT程序

    热门讨论 2012-10-13 15:23:42
    混沌序列的相空间重构MATLABT程序,混沌序列的相空间重构MATLABT程序希望对大家有用
  • 相空间重构(phase space reconstruction)

    千次阅读 2021-04-23 20:50:12
    相空间重构基本思想 Takens theorem 在动力学系统的研究中,延迟嵌入定理(delay embedding theorem)给出了混沌动力学系统可以由一系列动力学系统观测状态重构的条件。这种重构保留了在光滑坐标变化(即微分同胚)...
  • 该文章详细的描述了相空间重构延迟时间与嵌入维数的选择
  • 本人测试,Cao法求嵌入维数,绝对有效,下载下来试试,Matlab实现
  • 递归图(reecurrence plots),从相空间重构时间序列的matlab程序,
  • 这个想法是摆脱传统的条件监测方法,并通过使用相空间重构构建参考轨迹来研究非线性分析的使用。 该代码的“ nd相空间转换”部分会将单变量信号转换为其相空间表示。 当出现间歇现象时,可以将其用作任何偏差的客观...
  • 关联维数不仅是我们在相空间重构过程中求解嵌入维数的一种重要方法,而且在机械故障诊断中发挥了重要的作用。关联维数计算的方法目前最主要的就是GP算法了。MATLAB代码,已调试,可直接用。
  • 资 源 简 介C-C方法及改进的C-C方法重构相空间的matlab程序--------------------------------性能:3000数据耗时3分钟--------------------------------参考文献:1、Nonlinear ...C方法的相空间重构参数选择...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,124
精华内容 449
关键字:

相空间重构matlab代码

matlab 订阅
友情链接: ppt4398.rar