精华内容
下载资源
问答
  • 判断函数阶数
    千次阅读
    2021-04-24 16:52:53

    9afe4128cb861f73a0ffa3a66e3b5253.gif

    本发明属于信号处理领域,尤其涉及一种基于多项式拟合函数趋势项与阶数估计加速度、速度、位移的方法。

    背景技术:

    目前信号处理领域常用的加速度积分方法主要有时域积分和频域积分两种。时域积分常数项经积分会产生较大的趋势项,而且随着积分次数的增加,误差不断积累,会越来越偏离基线;频域积分利用傅里叶变换的积分性质,直接以频域内正弦、余弦的积分互换关系,可以有效避免时域信号的微小误差在积分过程中不断放大,较好的控制趋势项。

    对于积分产生的均值和线性趋势项,一般MATLAB中用detrend函数能够较好的去除;对于非线性的趋势项,根据最小二乘估计的原理,采用polyfit函数和polyval函数用多项式拟合(一般常采用低阶的多项式拟合)的方式去除趋势项。

    但是,现有技术中至少存在以下缺点和不足:

    真实采集到的加速度信号总是存在各种各样的噪声,即使经过降噪处理之后也存在诸多误差,无论是采用时域积分还是频域积分,这些误差经过积分之后形成的积分趋势项一般都是非线性的趋势项,仅用detrend函数不能完全消除趋势项。而采用polyfit函数去除非线性趋势项时,并不能准确获知拟合的多项式阶数,因此无法对趋势项进行准确的多项式拟合,也就不能最大程度的消除趋势项,减小误差。

    技术实现要素:

    为解决现有的去趋势时拟合多项式阶数选取不当造成趋势项消除不彻底的问题,本发明提供了一种基于多项式拟合函数趋势项与阶数估计加速度、速度、位移的方法。通过循环结构,在一定阶数范围内,自适应确定加速度的拟合多项式阶数;然后根据积分性质,确定速度、位移的拟合多项式阶数,最后拟合得到速度、位移信号。该方法对时域积分和频域积分的效果都非常显著;去除频域积分产生的位移趋势项尤其明显,且稳定性高。

    本发明的技术方案为:一种基于多项式拟合函数趋势项与阶数估计加速度、速度、位移的方法,包括以下步骤:

    (1)对采集的加速度信号降噪,作为加速度的参照信号;

    (2)设置多项式拟合函数阶数的取值范围,并根据加速度的参照信号,自适应确定拟合程度最优的阶数作为加速度的拟合多项式阶数;

    (3)根据加速度的拟合多项式阶数推出速度、位移的拟合多项式阶数;

    (5)利用polyfit函数和polyval函数分别对速度、位移进行多项式拟合,得到带有趋势项的速度、位移信号;

    (6)用速度、位移信号分别减去各自的趋势项对应的拟合多项式,得到消除趋势项的速度和位移信号。

    本发明意在自适应求解去除速度、位移趋势项时,拟合多项式的阶数,主要通过对比拟合曲线和原信号的相似性来实现。但是,实际采集信号多为加速度信号,并没有速度和位移的原始信号用来参照对比,故本发明先求解加速度信号的拟合多项式阶数,再推出速度、位移趋势项的拟合多项式阶数。

    步骤(2)的具体步骤为:

    (2-1)在MATLAB中,根据实际需要设置计算循环次数,此循环次数为多项式拟合函数阶数的最大值,则多项式拟合函数阶数的取值范围为[1,循环次数];

    (2-2)计算每个阶数下,由多项式拟合函数拟合得到的加速度信号与参照信号的相关系数;

    (2-3)选取相关系数最大时对应的阶数作为加速度的拟合多项式阶数。

    步骤(2-2)中,所述的相关系数采用以下方式获得:

    在获得加速度的拟合多项式阶数后,根据多项式积分性质可知,速度的拟合多项式阶数为加速度的拟合多项式阶数加1,位移的拟合多项式阶数为加速度的拟合多项式阶数加2。

    本发明在传统去趋势项的方法上进一步优化,能够自适应的选取最佳的拟合多项式的阶数,能够用最合适的多项式对趋势项进行拟合,去趋势的效果也更加明显。在MATLAB仿真实验中,相比较传统的去趋势方法,本发明采用的方法能够使速度的恢复信号和原始信号的相关系数从87%提升到97%左右;位移的恢复信号和原始信号的相关系数更是从10%提升到86%左右。

    除此之外,根据积分原理来看,和频域积分相比,时域积分会产生较大的趋势项,而且用传统方法去趋势时,时域积分产生的趋势项去除效果也更差。但是,本发明所述的自适应去趋势方法对时域积分和频域积分的效果都非常显著;去除频域积分产生的位移趋势项尤其明显,且稳定性高。

    附图说明

    图1是实施例中基于多项式拟合函数趋势项与阶数估计加速度、速度、位移的方法流程图;

    图2是采用传统去趋势方法对信号拟合的仿真示意图;

    图3是采用本发明方法对信号拟合的仿真示意图。

    具体实施方式

    为了更为具体地描述本发明,下面结合附图及具体实施方式对本发明的技术方案进行详细说明。

    参见图1,本实施例中基于多项式拟合函数趋势项与阶数估计加速度、速度、位移的方法,包括以下步骤:

    S01,将实际采集的加速度信号进行降噪处理,作为自适应选取最佳拟合多项式的对比参照量。

    S02,在MATLAB中,设置循环次数(阶数取值区间),在各阶数取值下用polyfit函数进行多项式拟合,语句如下:

    p=polyfit(t,acc,n)

    其中:t为时间;acc是降噪之后的加速度信号;n为多项式阶数。

    拟合多项式为:

    p(t)=pntn+pn-1tn-1+...+p1t+p0 (1)

    多项式的系数选取依据最小二乘原理,即对于给定数据(ti,yi),应使得用多项式p(t)拟合的值p(ti)与真值yi的误差ri=yi-p(ti)的平方和最小,即:

    其中,ti为加速度信号中的第i个取样点,且i=0,1,2,…,m,m为加速度信号的总取样点数,j=1,2,3...n,n为拟合多项式的阶数;pj为公式(1)中对应的各项tj的系数;tij为第i个取样点的j次方。

    为求I的最小值,应该另其对pj的偏导为0。具体解法在此不多加赘述。

    S03,在各阶数下,利用polyval函数拟合得到加速度信号;

    S04,将每个阶数下的加速度信号与参照信号进行对比,确定两者的相关系数。相关系数计算公式如下:

    其中,acc为加速度参照信号;acc1为拟合加速度信号;D(acc)为加速度参照信号的方差,D(acc1)为拟合信号的方差;Cov(acc,acc1)为参照信号和拟合信号的协方差,计算公式如下:

    Cov(acc,acc1)=E(acc*acc1)-E(acc)*E(acc1) (4)

    其中,E(acc*acc1)为加速度参照信号与拟合信号之积的数学期望;E(acc)为加速度参照信号的数学期望;E(acc1)为加速度拟合信号的数学期望。

    S05,选取相关系数最大时对应的阶数作为加速度的拟合多项式阶数。

    S06,将加速度的拟合多项式阶数加1作为速度的拟合多项式阶数,将加速度的拟合多项式阶数加2作为位移的拟合多项式阶数。

    S07,在确定速度、位移的拟合多项式阶数的情况下,利用polyfit函数和polyval函数分别对速度、位移进行多项式拟合,得到带有趋势项的速度、位移信号;

    S08,用速度、位移信号分别减去各自的趋势项对应的拟合多项式,得到消除趋势项的速度和位移信号。

    为突显本发明方法的优越性,本实施例将采集的正弦信号进行仿真实验,并与传统去趋势方法加以对比。

    原始位移信号为:dis=sin(2πft)

    求导得到的速度信号为:vel=2πfcos(2πft)

    求导得到的加速度信号为:acc=-(2πf)2sin(2πft)

    其中,f为信号频率,仿真中取f=50Hz,t为时间量,仿真中取t=0:ts:1000ts,ts为采样时间,取ts=0.001。

    为了加大趋势项使对比更加显著,给加速度加噪声测试。然后对加速度降噪,将降噪之后的加速度信号作为加速度的原始信号。

    将加速度积分得到速度和位移信号,先用传统去趋势方法去除速度和位移的趋势项,得到的速度和位移恢复信号如图2所示;再用本发明自适应去趋势方法去除速度和位移的趋势项,恢复信号如图3所示。

    不难看出,本发明方法能够有效去除积分趋势项,更好的对信号进行复原。

    以上所述的具体实施方式对本发明的技术方案和有益效果进行了详细说明,应理解的是以上所述仅为本发明的最优选实施例,并不用于限制本发明,凡在本发明的原则范围内所做的任何修改、补充和等同替换等,均应包含在本发明的保护范围之内。

    更多相关内容
  • 判断ARMA模型的阶数一般使用自相关函数(ACF)和偏自相关函数(PACF);自相关系数和偏自相关系数分别使用和表示。 判断的标准如下: 当和均不为0时,ACF和PCF呈现拖尾分布: ACF:,从时开始衰减(可能直接,也...

    自回归移动平均(autoregressive moving-averge,ARMA)模型是时间序列分析中常用的方法。它由自回归和移动平均两部分构成。

    阶自回归过程:

    • 其中, 。

    阶移动平均过程:

    • 其中,。

    自回归移动平均模型:

    • AR()、MA()过程分别可以看作是和时的特例。

    判断ARMA模型的阶数一般使用自相关函数(ACF)和偏自相关函数(PACF);自相关系数和偏自相关系数分别使用和表示。

    判断的标准如下:

    • 当和均不为0时,ACF和PCF呈现拖尾分布:

      • ACF:,从时开始衰减(可能直接,也可能震荡);

      • PACF:从时开始衰减(可能直接,也可能震荡)。

    • 当和时其中一个为0时:

      • 时为纯AR过程,PACF呈截尾分布,即在时为波峰(可正可负),之后为0;

      • 时为纯MA过程,ACF呈截尾分布,即在时为波峰(可正可负),之后为0。

    上述两个函数在R语言中对应的函数分别是stats工具包中的acf()pacf()

    AR(2)过程

    set.seed(123)
    p = rnorm(200)
    y1 = rep(0,200)
    for(i in c(3:200)){
      y1[i] = 0.7*y1[i-1] - 0.49*y1[i-2] + p[i]
    }
    
    layout(
      matrix(c(1,1,2,3), 2, byrow = T)
    )
    plot(y1[51:200], type = "l")
    acf(y1[51:200])
    pacf(y1[51:200])
    578827af321fd3e8fc2869827912d0eb.png
    • 蓝色虚线内的值可以认为是不显著区别于0;

    • ACF特征:拖尾分布;从起点处就开始震荡衰减;

    • PACF特征:截尾分布;在处取得波峰(负峰),之后为0。

    MA(1)过程

    set.seed(456)
    p = rnorm(200)
    y2 = rep(0,200)
    for(i in c(4:200)){
      y2[i] = p[i] - 0.7*p[i-1]
    }
    
    layout(
      matrix(c(1,1,2,3), 2, byrow = T)
    )
    plot(y2[51:200], type = "l")
    acf(y2[51:200])
    pacf(y2[51:200])
    a9ee27153cd241792d38a2456abed2a2.png
    • ACF特征:截尾分布;在时取得波峰(负峰),之后为0;

    • PACF特征:拖尾分布;从起点处就开始衰减。

    ARMA(3,2)过程

    set.seed(123)
    p = rnorm(200)
    y3 = rep(0,200)
    for(i in c(4:200)){
        y3[i] = 0.2*y3[i-1] - 0.1*y3[i-2] + 0.5*y3[i-3] + p[i] + 0.2*p[i-1] - 0.7*p[i-2]
    }
    
    layout(
      matrix(c(1,1,2,3), 2, byrow = T)
    )
    plot(y3[51:200], type = "l")
    acf(y3[51:200])
    pacf(y3[51:200])
    81ab2481a9fe6800509862dd0692ce2d.png
    • ACF特征:拖尾分布;从处开始衰减(不明显);

    • PACF特征:拖尾分布;从处开始衰减(实际应为)。

    使用(偏)自相关函数只能对ARMA模型的阶数作大致的判断,之后需要对系数进行估计和显著性检验来进行最终的判断。

    展开全文
  • 针对 Prony 算法辨识传递函数的模型阶数选取问题,首先选取一个阶数初始值, 然后在模型阶数取初始值条件下对输出信号进行 Prony 分析,最终依据 SNR 值及留数模值,得到 适合的模型阶数。对典型传递函数的仿真分析...
  • AR模型阶数确定 有几种方法来确定。如 Shin 提出基于 SVD的方法,而 AIC和 FPE方法是目前应用最广 泛的方法。 若计算出的 AIC较小,例如小于 -20,则该误差可能对应于损失函数的 1e-10级别, 则这时阶次可以看成是...
  • 如何确定插值滤波器的阶数

    千次阅读 2020-11-17 22:39:45
    这次我们再打开resample这个函数,可以看到: 这里的N是10,也就是说,如果是p倍插值,Matlab给出的插值滤波器阶数是2x10xp,也就是4倍插值滤波器对应阶数是80阶。再用firls来设计滤波器,最后再给滤波器加个kaiser...

      在信号处理中,滤波器的系数我们往往都是通过MATLAB来设计,只要我们知道滤波器的通带截止频率和阻带起始频率,就可以通过MATLAB中的fdatool(在MATLAB2020中使用filterDesigner)来设计滤波器了。

      我们使用归一化的参数来设计,通带截止频率是025,阻带起始频率是0.3,通带内纹波是0.2,阻带衰减是60dB,参数设置如下:

    image-20201117215623551

      那么问题来了,对于插值滤波器,如何确定通带和阻带的频率呢?这就涉及到我们刚开始学习数字信号处理时的插值和抽取理论。当信号抽取时,在数字频率上,信号的频谱是展宽的,当信号插值时,在数字频率上,信号的频谱是压缩的。这里我们强调数字频率,不是模拟频率,因为100MHz的采样率去采中频10MHz、带宽1MHz的信号,那么抽取2倍后,这个信号的频率还是10MHz,带宽还是1MHz,那为什么说数字频率上频谱展宽了呢?因为数字频率的2pi对应采样率。

      我们以信号处理书上这个经典的例子为例,原始信号的带宽是2pi/3,采样率是2pi,经过3倍抽取后,采样率由fs变为fs/3;而抽取后信号的采样率依旧对于数字域的2pi,因此原先的fs就对应6pi,信号带宽也就变成了2pi。

    image-20201117221455842

      而抽取滤波器则刚好相反,对于3倍的插值滤波器,信号带宽在数字频率上,缩小了1/3。也就是原来0pi的区间缩小到0pi/3,因此信号的截止频率就是pi/3,我们在设计滤波器时,直接指定截止频率是pi/3即可,至于阻带起始频率,我们可以设计的比通带截止频率稍大一些即可,同时还要考虑滤波器阶数,如果过渡带太窄了,滤波器阶数会太高。像我们上面设计的那个滤波器,正好可以适用于4倍插值滤波器。

      这里我们再提供一种解决方案,这种方法也是我强烈推荐的,就是当我们对一种设计没有头绪时,可以参考mathworks给出的设计。从哪参考呢?当然是MATLAB程序。我们知道Matlab的一个强大之处在于给我们提供了很多API可以调用,为我们节省了不少时间,而且大多数的函数我们都是可以看到源码的。比如我们今天所说的插值滤波器,可以直接使用resample函数,比如要对向量sig插值4倍,就可以直接使用sig2 = resample(sig, 4, 1)。这次我们再打开resample这个函数,可以看到:

    image-20201117222730941

    这里的N是10,也就是说,如果是p倍插值,Matlab给出的插值滤波器阶数是2x10xp,也就是4倍插值滤波器对应阶数是80阶。再用firls来设计滤波器,最后再给滤波器加个kaiser窗。其实我们也可以直接使用fir2函数来设计,就是把图中高亮的行换成:

    h = fir2(L - 1, [0 2*fc 2*fc 1], [1 1 0 0]);
    

    fir2函数默认就是加了hamming窗的。使用这种方法设计的滤波器频响如下:

    image-20201117223248809

    微信公众号:Quant_Times

    在这里插入图片描述

    展开全文
  • 一、__alloc_pages_slowpath 慢速路径调用函数、 二、判断阶数、 三、读取进程 mems_allowed 成员、 四、分配标志位转换、 五、__alloc_pages_slowpath 慢速路径调用完整函数源码

    【Linux 内核 内存管理】物理分配页 ② ( __alloc_pages_nodemask 函数参数分析 | __alloc_pages_nodemask 函数分配物理页流程 ) 博客中 , 分析了 __alloc_pages_nodemask 函数分配物理页流程如下 :

    首先 , 根据 gfp_t gfp_mask 分配标志位 参数 , 得到 " 内存节点 “ 的 首选 ” 区域类型 " " 迁移类型 " ;

    然后 , 执行 " 快速路径 " , 第一次分配 尝试使用 低水线分配 ;

    如果上述 " 快速路径 " 分配失败 , 则执行 " 慢速路径 " 分配 ;

    上述涉及到了 " 快速路径 " 和 " 慢速路径 " 2 2 2 种物理页分配方式 ;


    前面几篇博客 , 分析了 " 快速路径 " 内存分配核心函数 get_page_from_freelist , 本博客开始分析 " 慢速路径 " 内存分配 函数 __alloc_pages_slowpath 函数 ;





    一、__alloc_pages_slowpath 慢速路径调用函数



    内存区域 内 进行 物理页分配 时 , 优先尝试使用 " 快速路径 " 内存分配 , 执行 get_page_from_freelist 核心函数 ;

    假如上述 " 低水线内存分配 " 分配 , 即 " 快速路径 " 内存分配失败 , 则执行 " 慢速路径 " 内存分配 ;


    " 慢速路径 " 内存分配 的核心函数 是 __alloc_pages_slowpath 函数 , 定义在 Linux 内核源码的 linux-4.12\mm\page_alloc.c#3676 位置 ;

    在这里插入图片描述

    源码路径 : linux-4.12\mm\page_alloc.c#3676





    二、判断页阶数



    先判断 内存分配 的 物理页的 阶数 , 申请 物理页内存 的 " 阶数 " , 必须 小于 页分配器 支持的 最大分配 阶数 ;


    阶 ( Order ) : 物理页 的 数量单位 , n n n 阶页块 指的是 2 n 2^n 2n连续的 " 物理页 " ; 完整概念参考 【Linux 内核 内存管理】伙伴分配器 ① ( 伙伴分配器引入 | 页块、阶 | 伙伴 ) ;

    	/*
    	 * In the slowpath, we sanity check order to avoid ever trying to
    	 * reclaim >= MAX_ORDER areas which will never succeed. Callers may
    	 * be using allocators in order of preference for an area that is
    	 * too large.
    	 */
    	if (order >= MAX_ORDER) {
    		WARN_ON_ONCE(!(gfp_mask & __GFP_NOWARN));
    		return NULL;
    	}
    

    源码路径 : linux-4.12\mm\page_alloc.c#3699





    三、读取进程 mems_allowed 成员



    在后面代码中 , 会 检查 cpuset , 查看是否允许 当前进程 从 内存节点 申请 物理页 ,

    上述判断 , 需要读取 当前进程的 mems_allowed 成员 , 读取时需要使用 " 顺序保护锁 " ;

    	cpuset_mems_cookie = read_mems_allowed_begin();
    

    源码路径 : linux-4.12\mm\page_alloc.c#3716





    四、分配标志位转换



    将 " 分配标志位 " 转为 " 内部分配标志位 " ;

    	/*
    	 * The fast path uses conservative alloc_flags to succeed only until
    	 * kswapd needs to be woken up, and to avoid the cost of setting up
    	 * alloc_flags precisely. So we do that now.
    	 */
    	alloc_flags = gfp_to_alloc_flags(gfp_mask);
    

    源码路径 : linux-4.12\mm\page_alloc.c#3723





    五、__alloc_pages_slowpath 慢速路径调用完整函数源码



    static inline struct page *
    __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,
    						struct alloc_context *ac)
    {
    	bool can_direct_reclaim = gfp_mask & __GFP_DIRECT_RECLAIM;
    	const bool costly_order = order > PAGE_ALLOC_COSTLY_ORDER;
    	struct page *page = NULL;
    	unsigned int alloc_flags;
    	unsigned long did_some_progress;
    	enum compact_priority compact_priority;
    	enum compact_result compact_result;
    	int compaction_retries;
    	int no_progress_loops;
    	unsigned long alloc_start = jiffies;
    	unsigned int stall_timeout = 10 * HZ;
    	unsigned int cpuset_mems_cookie;
    
    	/*
    	 * In the slowpath, we sanity check order to avoid ever trying to
    	 * reclaim >= MAX_ORDER areas which will never succeed. Callers may
    	 * be using allocators in order of preference for an area that is
    	 * too large.
    	 */
    	if (order >= MAX_ORDER) {
    		WARN_ON_ONCE(!(gfp_mask & __GFP_NOWARN));
    		return NULL;
    	}
    
    	/*
    	 * We also sanity check to catch abuse of atomic reserves being used by
    	 * callers that are not in atomic context.
    	 */
    	if (WARN_ON_ONCE((gfp_mask & (__GFP_ATOMIC|__GFP_DIRECT_RECLAIM)) ==
    				(__GFP_ATOMIC|__GFP_DIRECT_RECLAIM)))
    		gfp_mask &= ~__GFP_ATOMIC;
    
    retry_cpuset:
    	compaction_retries = 0;
    	no_progress_loops = 0;
    	compact_priority = DEF_COMPACT_PRIORITY;
    	cpuset_mems_cookie = read_mems_allowed_begin();
    
    	/*
    	 * The fast path uses conservative alloc_flags to succeed only until
    	 * kswapd needs to be woken up, and to avoid the cost of setting up
    	 * alloc_flags precisely. So we do that now.
    	 */
    	alloc_flags = gfp_to_alloc_flags(gfp_mask);
    
    	/*
    	 * We need to recalculate the starting point for the zonelist iterator
    	 * because we might have used different nodemask in the fast path, or
    	 * there was a cpuset modification and we are retrying - otherwise we
    	 * could end up iterating over non-eligible zones endlessly.
    	 */
    	ac->preferred_zoneref = first_zones_zonelist(ac->zonelist,
    					ac->high_zoneidx, ac->nodemask);
    	if (!ac->preferred_zoneref->zone)
    		goto nopage;
    
    	if (gfp_mask & __GFP_KSWAPD_RECLAIM)
    		wake_all_kswapds(order, ac);
    
    	/*
    	 * The adjusted alloc_flags might result in immediate success, so try
    	 * that first
    	 */
    	page = get_page_from_freelist(gfp_mask, order, alloc_flags, ac);
    	if (page)
    		goto got_pg;
    
    	/*
    	 * For costly allocations, try direct compaction first, as it's likely
    	 * that we have enough base pages and don't need to reclaim. For non-
    	 * movable high-order allocations, do that as well, as compaction will
    	 * try prevent permanent fragmentation by migrating from blocks of the
    	 * same migratetype.
    	 * Don't try this for allocations that are allowed to ignore
    	 * watermarks, as the ALLOC_NO_WATERMARKS attempt didn't yet happen.
    	 */
    	if (can_direct_reclaim &&
    			(costly_order ||
    			   (order > 0 && ac->migratetype != MIGRATE_MOVABLE))
    			&& !gfp_pfmemalloc_allowed(gfp_mask)) {
    		page = __alloc_pages_direct_compact(gfp_mask, order,
    						alloc_flags, ac,
    						INIT_COMPACT_PRIORITY,
    						&compact_result);
    		if (page)
    			goto got_pg;
    
    		/*
    		 * Checks for costly allocations with __GFP_NORETRY, which
    		 * includes THP page fault allocations
    		 */
    		if (costly_order && (gfp_mask & __GFP_NORETRY)) {
    			/*
    			 * If compaction is deferred for high-order allocations,
    			 * it is because sync compaction recently failed. If
    			 * this is the case and the caller requested a THP
    			 * allocation, we do not want to heavily disrupt the
    			 * system, so we fail the allocation instead of entering
    			 * direct reclaim.
    			 */
    			if (compact_result == COMPACT_DEFERRED)
    				goto nopage;
    
    			/*
    			 * Looks like reclaim/compaction is worth trying, but
    			 * sync compaction could be very expensive, so keep
    			 * using async compaction.
    			 */
    			compact_priority = INIT_COMPACT_PRIORITY;
    		}
    	}
    
    retry:
    	/* Ensure kswapd doesn't accidentally go to sleep as long as we loop */
    	if (gfp_mask & __GFP_KSWAPD_RECLAIM)
    		wake_all_kswapds(order, ac);
    
    	if (gfp_pfmemalloc_allowed(gfp_mask))
    		alloc_flags = ALLOC_NO_WATERMARKS;
    
    	/*
    	 * Reset the zonelist iterators if memory policies can be ignored.
    	 * These allocations are high priority and system rather than user
    	 * orientated.
    	 */
    	if (!(alloc_flags & ALLOC_CPUSET) || (alloc_flags & ALLOC_NO_WATERMARKS)) {
    		ac->zonelist = node_zonelist(numa_node_id(), gfp_mask);
    		ac->preferred_zoneref = first_zones_zonelist(ac->zonelist,
    					ac->high_zoneidx, ac->nodemask);
    	}
    
    	/* Attempt with potentially adjusted zonelist and alloc_flags */
    	page = get_page_from_freelist(gfp_mask, order, alloc_flags, ac);
    	if (page)
    		goto got_pg;
    
    	/* Caller is not willing to reclaim, we can't balance anything */
    	if (!can_direct_reclaim)
    		goto nopage;
    
    	/* Make sure we know about allocations which stall for too long */
    	if (time_after(jiffies, alloc_start + stall_timeout)) {
    		warn_alloc(gfp_mask & ~__GFP_NOWARN, ac->nodemask,
    			"page allocation stalls for %ums, order:%u",
    			jiffies_to_msecs(jiffies-alloc_start), order);
    		stall_timeout += 10 * HZ;
    	}
    
    	/* Avoid recursion of direct reclaim */
    	if (current->flags & PF_MEMALLOC)
    		goto nopage;
    
    	/* Try direct reclaim and then allocating */
    	page = __alloc_pages_direct_reclaim(gfp_mask, order, alloc_flags, ac,
    							&did_some_progress);
    	if (page)
    		goto got_pg;
    
    	/* Try direct compaction and then allocating */
    	page = __alloc_pages_direct_compact(gfp_mask, order, alloc_flags, ac,
    					compact_priority, &compact_result);
    	if (page)
    		goto got_pg;
    
    	/* Do not loop if specifically requested */
    	if (gfp_mask & __GFP_NORETRY)
    		goto nopage;
    
    	/*
    	 * Do not retry costly high order allocations unless they are
    	 * __GFP_REPEAT
    	 */
    	if (costly_order && !(gfp_mask & __GFP_REPEAT))
    		goto nopage;
    
    	if (should_reclaim_retry(gfp_mask, order, ac, alloc_flags,
    				 did_some_progress > 0, &no_progress_loops))
    		goto retry;
    
    	/*
    	 * It doesn't make any sense to retry for the compaction if the order-0
    	 * reclaim is not able to make any progress because the current
    	 * implementation of the compaction depends on the sufficient amount
    	 * of free memory (see __compaction_suitable)
    	 */
    	if (did_some_progress > 0 &&
    			should_compact_retry(ac, order, alloc_flags,
    				compact_result, &compact_priority,
    				&compaction_retries))
    		goto retry;
    
    	/*
    	 * It's possible we raced with cpuset update so the OOM would be
    	 * premature (see below the nopage: label for full explanation).
    	 */
    	if (read_mems_allowed_retry(cpuset_mems_cookie))
    		goto retry_cpuset;
    
    	/* Reclaim has failed us, start killing things */
    	page = __alloc_pages_may_oom(gfp_mask, order, ac, &did_some_progress);
    	if (page)
    		goto got_pg;
    
    	/* Avoid allocations with no watermarks from looping endlessly */
    	if (test_thread_flag(TIF_MEMDIE) &&
    	    (alloc_flags == ALLOC_NO_WATERMARKS ||
    	     (gfp_mask & __GFP_NOMEMALLOC)))
    		goto nopage;
    
    	/* Retry as long as the OOM killer is making progress */
    	if (did_some_progress) {
    		no_progress_loops = 0;
    		goto retry;
    	}
    
    nopage:
    	/*
    	 * When updating a task's mems_allowed or mempolicy nodemask, it is
    	 * possible to race with parallel threads in such a way that our
    	 * allocation can fail while the mask is being updated. If we are about
    	 * to fail, check if the cpuset changed during allocation and if so,
    	 * retry.
    	 */
    	if (read_mems_allowed_retry(cpuset_mems_cookie))
    		goto retry_cpuset;
    
    	/*
    	 * Make sure that __GFP_NOFAIL request doesn't leak out and make sure
    	 * we always retry
    	 */
    	if (gfp_mask & __GFP_NOFAIL) {
    		/*
    		 * All existing users of the __GFP_NOFAIL are blockable, so warn
    		 * of any new users that actually require GFP_NOWAIT
    		 */
    		if (WARN_ON_ONCE(!can_direct_reclaim))
    			goto fail;
    
    		/*
    		 * PF_MEMALLOC request from this context is rather bizarre
    		 * because we cannot reclaim anything and only can loop waiting
    		 * for somebody to do a work for us
    		 */
    		WARN_ON_ONCE(current->flags & PF_MEMALLOC);
    
    		/*
    		 * non failing costly orders are a hard requirement which we
    		 * are not prepared for much so let's warn about these users
    		 * so that we can identify them and convert them to something
    		 * else.
    		 */
    		WARN_ON_ONCE(order > PAGE_ALLOC_COSTLY_ORDER);
    
    		/*
    		 * Help non-failing allocations by giving them access to memory
    		 * reserves but do not use ALLOC_NO_WATERMARKS because this
    		 * could deplete whole memory reserves which would just make
    		 * the situation worse
    		 */
    		page = __alloc_pages_cpuset_fallback(gfp_mask, order, ALLOC_HARDER, ac);
    		if (page)
    			goto got_pg;
    
    		cond_resched();
    		goto retry;
    	}
    fail:
    	warn_alloc(gfp_mask, ac->nodemask,
    			"page allocation failure: order:%u", order);
    got_pg:
    	return page;
    }
    

    源码路径 : linux-4.12\mm\page_alloc.c#3676

    展开全文
  • 今天小编就为大家分享一篇Python 确定多项式拟合/回归的阶数实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • cost看成0阶
  • 绘制边缘分数的beta函数。 使用花式离散化和正常离散化将Sachs数据的结果进行比较。 标度 尝试将范数(K(:))除以总均值,每个条件集大小的均值n,sqrt(n)和log(n)。 sqrt(n)似乎做得最好,但是似乎并没有...
  • 有没有系统深刻一点的判断函数最少有几阶的方法?好像有说一般要大于二阶才能使用莱布尼兹公式?
  • “j”是最大阶数,在上图中,最大阶数是3阶,那么“j”就是3。 实例运行 拿个实例运行一下,在这个实例中“f”是确定值。 x=np.array([-1,0,1,3]) f=np.array([4,-1,2,6]) csb(x,f,3) 得出以下结果: 所求3阶差商表...
  •  这是计算机图形学样条曲线绘制或数学上插值函数的问题。首先,例如一条直线,两点可以定义一条直线,而直线的定义式可以写为:y=kx+b,可用一次函数表示;即一阶的曲线(直线)由两个点定义。同理又例如:二阶的...
  • 1755: 阶数 Time Limit: 1 Sec Memory Limit: 128 MB Submit: 54 Solved: 6 [Submit][Status][Web Board] Description 满足a^x≡1(mod n)的最小正整数x称为a模n的阶。 现给出两个正整数,求x。 ...
  • 展开全部VAR模型的滞后阶数越大,自由度就越小。一般根据AIC和SC取值最小准则来确定阶62616964757a686964616fe58685e5aeb931333431366363数。如果AIC和SC并不是同时取值最小,采用LR检验进行取舍。时序数据样本容量...
  • 数学

    千次阅读 2020-11-04 12:10:45
    常见奇函数和偶函数 常见的有节函数 需要分左右极限的问题 常见无穷大量排序
  • 【MATLAB】数据拟合_阶数的确定

    千次阅读 2019-08-23 22:45:53
    这种方法是最常用的确定方法,一般情况下,我们拟合函数的目的,就是为了调用,所以在用函数拟合之前会用matlab曲线拟合工具箱进行拟合函数阶数的确定,由其确定拟合的阶数,然后我们用这个函数命令在其他地方进行...
  • learning_curve():这个函数主要是用来判断(可视化)模型是否过拟合的,关于过拟合,就不多说了,具体可以看以前的博客:模型选择和改进 2. validation_curve():这个函数主要是用来查看在参数不同的取值下模型的...
  • 滤波器的阶数

    千次阅读 2017-01-13 09:23:28
    滤波器的阶数是指在滤波器的传递函数中有几个极点.阶数同时也决定了转折区的下降速度,一般每增加一阶(一个极点),就会增加一20dBDec(一20dB每十倍频程)。 滤波器特性可以用其频率响应来描述,按其特性的不同,可以...
  • 原理背景 在时间序列建模中,我们常用到的一个模型就是ARIMA,但是在使用该模型时,一个问题就是如何确定AR,MA中的p和q,即滞后项的级数。这时,一般我们会采用ACF(auto-correlation function) 以及PACF(partial auto...
  • 想用aicbic确定ARMA的阶数,但用这个确定的阶数时会出现如下错误Error using arima/validateModel (line 1314)The non-seasonal moving average polynomial is non-invertible.Error in arima/setLagOp (line 391)...
  •  六,一般情况下,传递函数分子的阶数m与分母的阶数n满足n≥m (称为物理现实性条件) 2.4 不满足零初始条件的传递函数  系统的响应等于零输入响应和零状态响应零状态响应之和 则传递函数为零状态响应之...
  • Python 确定多项式拟合/回归的阶数

    千次阅读 2019-07-26 13:23:59
    通过 1至10 阶来拟合对比 均方误差及R评分,可以确定最优的“最大阶数”。 import numpy as np import matplotlib.pyplot as plt from sklearn.preprocessing import PolynomialFeatures from sklearn.linear_...
  • R语言时序-AR、MA与ARMA的判断及定阶

    千次阅读 2021-10-06 11:38:18
    ACF截尾:判断为MA(q)模型,q为最后一个超出2倍标准差(蓝线)的阶数 ACF拖尾:可能为AR(p)模型也可能为ARMA(p,q)模型 Step2 看PACF图: PACF截尾:AR(p)模型,p为最后一个超出2倍标准差(蓝线)的阶数 ...
  • python自相关函数ACF和偏自相关函数PACF用于判断ARIMA模型中p、q参数取值
  • 通过使用break语句,可不必等待循环的自然结束,而根据循环只设的条件来判断是否跳出循环。 等待键盘输入 keyboard⭐️ 使程序进入暂时等待状态,但并没退出执行,可以修改参数,和运行其他指令等。 显示文字或数组 ...
  • 本题要求实现一个函数,计算阶数为n,系数为a[0]...a[n]的多项式f(x)=∑​i=0​n​​(a[i]×x​i​​)在x点的值。 函数接口定义: double f( int n, double a[], double x ); 其中n是多项式的阶数,a[]中存储...
  • C程序语言课件:第7章 函数.ppt

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,259
精华内容 2,903
关键字:

判断函数阶数