精华内容
下载资源
问答
  • QT时间循环机制

    千次阅读 2012-09-13 20:10:05
    1、事件循环一般用exec()函数开启。QApplicaion::exec()、QMessageBox::exec()都是事件循环。其中前者又被称为主事件循环。 事件循环首先是一个无限“循环”,程序在exec()里面无限循环,能让跟在exec()...

    1、事件循环一般用exec()函数开启。QApplicaion::exec()、QMessageBox::exec()都是事件循环。其中前者又被称为主事件循环。


    事件循环首先是一个无限“循环”,程序在exec()里面无限循环,能让跟在exec()后面的代码得不到运行机会,直至程序从exec()跳出。从exec()跳出时,事件循环即被终止。QEventLoop::quit()能够终止事件循环。


    其次,之所以被称为“事件”循环,是因为它能接收事件,并处理之。当事件太多而不能马上处理完的时候,待处理事件被放在一个“队列”里,称为“事件循环队列”。当事件循环处理完一个事件后,就从“事件循环队列”中取出下一个事件处理之。当事件循环队列为空的时候,它和一个啥事也不做的永真循环有点类似,但是和永真循环不同的是,事件循环不会大量占用CPU资源。


    事件循环的本质就是以队列的方式再次分配线程时间片。


    2、事件循环是可以嵌套的,一层套一层,子层的事件循环执行exec()的时候,父层事件循环就处于中断状态;当子层事件循环跳出exec()后,父层事件循环才能继续循环下去。

    另外,子层事件循环具有父层事件循环的几乎所有功能。Qt会把事件送到当前生效的那个事件循环队列中去,其中包括Gui的各种事件。所以用户在主线程中执行各种exec()(如QMessageBox::exec(),QEventLoop::exec())的时候,虽然这些exec()打断了main()中的QApplication::exec(),但是Gui界面仍然能够正常响应。    

    3、如果某个子事件循环仍然有效,但其父循环被强制跳出,此时父循环不会立即执行跳出,而是等待子事件循环跳出后,父循环才会跳出。
    展开全文
  • 游戏循环时间线

    千次阅读 2018-03-22 17:17:45
    1.渲染循环 电影动画之所以产生连续效果,是由于其快速连续的播放多个静止帧,从而产生视觉错误,认为他是连续的。计算机如要模拟该过程,则可使用循环,这也就是渲染循环。 GUI和某些早期二维游戏使用矩形失效...

    1.渲染循环

        电影动画之所以产生连续效果,是由于其快速连续的播放多个静止帧,从而产生视觉错误,认为他是连续的。计算机如要模拟该过程,则可使用循环,这也就是渲染循环。

        GUI和某些早期二维游戏使用矩形失效技术,意及将图形用户界面分割为多个小块,当某块画面需要更新时,则将其覆盖。本人大一数据结构课程实习的大作业贪吃蛇就是使用此原理。除了边界区域以外,其他位置每小块图元只有三个状态,有蛇头,有蛇身,没蛇,因此使用矩形失效非常方便。当时还没有渲染循环的概念,但是为了让画面出现连续的动作,潜意识里就使用了一个循环来进行渲染(虽然每帧持续时间很长,一秒刷新一次,这样的粒度显然是不适合工业级游戏的)

        矩形失效受限于当时的硬件机能,现在的游戏大可忽略。实际上为了渲染三维空间,矩形失效确实已经不够使用了。

        一个简单的渲染循环要做的事情很easy,第一步,基于预设场景或输入的路径变化,更新摄像机位置,比如贪吃蛇按下方向键,蛇会移动(三维游戏移动的就是摄像机,二位固定视角则移动主角);第二步,更新场景中元素位置,定向,以及其他视觉状态,比如蛇头朝向,食物位置,蛇身扭动;第三步,根据上面的计算结果重绘屏幕。

        当时我的作业就是这样完成的,正因如此,我只能把帧率限制为1FPS,多一点都不行,会因为重绘的结果还没返回,屏幕就开始进行数据的更新,导致旧的画面没有及时被覆盖,专业术语称为画面撕裂。

        因此更优雅的做法是使用一个背景缓冲,先在背景缓冲把下一帧需要显示的画面渲染完成,主循环需要重绘前景时,只需要将背景复制到前景即可。

    2.游戏循环

        不仅仅渲染需要周期性更新,游戏的许多子系统都需要周期性的检测更新其状态。包括但不限于贪吃蛇例里的输入控制,碰撞检测,音频。这些子系统服务频率各有不同,渲染循环常见更新频率30,60Hz,动力学模拟需要更加频繁(120Hz)的更新。但很遗憾,在贪吃蛇的例子里,我们不需要考虑不同频率,因为除了音频播放以外,IO、碰撞、渲染全都可以以同一频率更新,那么我们就只需要一个简单的循环来更新所有子系统,称为游戏循环,他是整个游戏的主循环,统一进行所有子系统的状态更新。

        这样做的弊端非常明显,比如一旦主循环以60帧运行,那么所有子系统只能以低于他的频率运行(每两帧或更多)。显然不切实际。因此我们需要将主循环与渲染循环分开,将主循环以所需的最高频子系统运行频率来运行。

    3.游戏循环的不同架构

        消息泵:    

        某些Windows上的游戏支持玩家进行windows自带的操作,比如最大化,最小化。这是通过Windows的消息泵实现的,即在游戏循环中,优先执行系统消息,没有任务时才执行游戏引擎的任务。这样人为的限定了任务执行的优先级:优先执行系统任务。导致在更改窗口大小时,游戏画面静止不动。这点对于游戏循环的影响十分大。(你肯定见过现在的某些端游在修改界面大小时卡顿,以及在修改完成后帧数从10帧左右缓慢恢复60帧,例如某灵,这就是影响。这点在时间线部分分析)

        回调驱动:

        基于框架的渲染引擎或游戏引擎,已经封装好了主游戏循环,因此对于运行流程几乎不可控。框架就使用回调驱动,通过重写框架内的虚函数代码,实现自己的游戏功能。随后这些虚函数将在主循环内被框架本身调用。比如渲染引擎OGRE的FrameListener。继承该类并重载frameStarted和frameEnded两个函数,即可实现自己的功能。这两个函数分别在主场景渲染之前和之后调用。

        基于事件的更新:

        实现这种游戏循环必须要求事件系统支持发送“未来的事件”,即事件可以先置于队列,稍后才取出处理。该方案支持子系统代码以任意所需周期进行更新,只需要设定事件间隔的时常,并在每次子系统循环完成之时再次添加该系统的事件,即可达成周期性的此系统状态更新。

    4.抽象时间线

        真实时间线:CPU上的高分辨率计时寄存器(64位)可以用于度量事件。此时间线原点位计算机上次启动或重启时,其单位位CPU周期(或其倍数)它可以通过与该寄存器的频率相乘转化为秒数。

        游戏时间线:代表游戏进程的时间线,可以简单设置为等于真实时间线,当游戏暂停,该时间线停止,真实时间线则不受影响。需要快进或慢动作,则将其设置为真实时间线的倍数。倒带时,则设置为负倍数的真实时间线。

        局部时间线:播放动画、音频所用的时间线,原点为片段的开始,用法其实和游戏时间线到真实时间线的映射有异曲同工之处。

    5.时间线的测量和处理

        帧率:每秒帧数;帧时间:两帧之间经过的时间(周期)他是帧率的倒数

        已知帧率和游戏对象的速率,则可求出每帧该对象的位移。然而这样的做法不精确,帧率很明显和代码的执行效率挂钩,配置好的机器帧率很明显会比配置差的机器高。这被称为受CPU速度影响的游戏。

        正确的做法应该是准确的使用帧时间来衡量位移。因此重心就在于如何计算这个帧时间。

        一个较为直接的思路即是在循环的开始和结尾分别取两次高分辨率计时寄存器的值,求出本帧经过的时间。然而这个求出的时间到下一帧才能使用。即这个差值还是估算的时间,用本帧的时间估算的下一帧的时间,下一帧有可能产生一个帧率尖峰——因某种原因消耗了更多/更少的时间。这种方式容易使游戏进入低帧循环:比如某一帧使用了50ms,设计帧时间为33.3ms(30帧),那么为了掩饰本帧多消耗的时间,在下一帧就需要对于物理系统进行两次计算,才能在下下帧保持物理系统的正确。但是进行两次计算无疑会消耗更多的帧时间,这就导致下一帧变得甚至比本帧更慢,即进入低帧循环。

        在上面思路的基础上的延伸思路是求平均值。因为在实际游戏场景下,连续的几帧所做的工作是相似的(某一帧摄像机对准走廊,下一帧极大可能仍然对准走廊,因为正常人鼠标DPI不会设置那么低)这样就可以使用连续几帧的平均值来估计下一帧的帧时间。这种做法可以缓和帧率尖峰的影响,但同时应对帧率转变的能力也会减弱,比如下一帧帧时间陡涨到70ms,前面连续帧的估计值是20ms,这样下一帧的估计时间极不准确,毫无疑问人物会产生慢动作(70ms应该走70个像素,但预估只用20ms,所以渲染出来就只走了20个像素)。

        另一个思路是调控帧率,与其估算下一帧时间,倒不如尝试使每一帧的帧时间都相同。当实际帧时间小于预设,休眠到预设时间,大于预设,休眠到两倍的预设时间。(20ms补成33.3ms,40ms补成66.7ms)这种稳定帧率的模式在经常遇到慢帧的时候就会严重影响游戏质量,因此在开发期间可以用可变帧率,开发完成后,帧数稳定了,再使用帧调控,这样就能利用帧调控的好处了。

        此外帧率还需要配合显示器的刷新率(显示器电子枪从屏幕上端走完一个周期回到上端),这称为显示器的垂直消隐区间。否则会导致画面撕裂。这也是为什么很多游戏设定帧率为30,60的原因。


        上文提到的高分辨率计时寄存器,是cpu上硬件实现的一个计时工具,他的单位是时钟周期。当然,他的取值和我们游戏的进程是没有关系的。这里就要剖析某灵的跳帧原因了。上文提到消息泵会阻塞游戏进程,而时间测量是循环头尾,这样就会使得这一帧的测量时间非常之长(相当于打了段点),因此就产生了一个帧率尖峰,他会影响到其后好多好多帧的事件处理,比如动画子系统在耽误的这几帧的时间内要补上好几个人物动画,这就导致帧率的缓慢复原。

    不想写了,反正也没人看。后面都是跟寄存器时间(周期)到真实时间(ms)转换有关的问题了,由于寄存器时间是64位,使用32位保存差值很容易溢出(1.9s溢出一次),跟存储细节有关的东西,自己写几个demo调试一下就全清楚了。


    展开全文
  • 递归与循环相比时间优势的真正来源

    万次阅读 多人点赞 2016-10-14 21:25:51
    以前在上课中有个老师曾提到过,有过一个公司的笔试题中要求大家把一个1~n的累加用递归的方式写出代码...而且还把我的一个gcd函数从我的循环方法改成递归方法后发现时间上也减少了许多。于是我就在今天通过自己写的gcd

    写在前面于2020年添加:

            这一篇本身是我写的前几篇博客。(本身一共也没写几个233333。)我自己本身也不知道又哪些人会无意间点开这篇文章,至少在我现在看来这一篇确实是没有太实际的用处。或许从这个角度上来说应该删了或者重写吧!但是,对我来说这一篇确实是具有不一样的意义也就没舍得删除。为了节约大家的时间我就直接把我认为大家可能想看的东西(盗用)到前面吧!(是评论区的一个人的评论)

            手动感谢!!!

    ——————————————————————————手动分割——————————————————————————

            以前在上课中有个老师曾提到过,有过一个公司的笔试题中要求大家把一个1~n的累加用递归的方式写出代码。当时老师只是简单的说了递归很多时候都比循环写起来更简单,而且递归也比循环更考验思维。

       然后,就是在省赛中名校的翻模版中发现,那些模板中大多数使用的都是递归很少把循环作为模板的。而且还把我的一个 gcd函数从我的循环方法改成递归方法后发现时间上也减少了许多。于是我就在今天通过自己写的gcd函数和并查集函数分别用循环和递归谢了代码来比较他们在运行过程中时间上的差距。

     

        首先不论是递归还是循环在运行过程中计算的次数是相同的,但是,对于不同的计算运行的时间却是有长有短。(比如说同样是计算使用位运算的时间就比四则运算的时间更长。)

     

        首先,是gcd 的函数:第一个gcd 求最大公因数的函数代码一如下:(gcd为函数部分)

     

    <pre name="code" class="cpp">#include<iostream>
    #include<ctime>
    using namespace std;
    int gcd(int a,int b){
    	int c=a;
    	int d=b;
    	while(d!=0){
    		int z=c%d;
    		c=d;
    		d=z;
    	}
    	return c;    //通过gcd函数最后返回值就是两个数的最大公因数
    }
    int main(){
    	int n;
    	while(cin>>n){
    		long long  st_time= clock();
    		int num[10000]={0};
    		for(int j=0;j<n;j++)
    			cin>>num[j];
    		for(int j=1;j<n;j++){
    			for(int k=1;k<1000;k++)     //因为使用的数据并不复杂,所以原本运行
    				gcd(num[j-1],num[j]);   //时间太短无法测出。我在此时通过反复循
    			num[j]=gcd(num[j-1],num[j]);//多计算几次使得时间放大1000倍易于测量时间。
    			cout<<num[j]<<" ";   		//这里是答案的输出。
    		}
    		cout<<endl;
    		long long end_time=clock();
    		cout<<"运行时间:"<<end_time-st_time<<endl;  //最后输出时间
    	}
    } 

     

     

     

     

     

     

            下面是使用代码输出的结果:

    (图1)代码一的运行结果

     

             下面是使用递归写的代码二(gcd为函数部分):

     

    <pre name="code" class="cpp">#include<iostream>
    #include<ctime>
    using namespace std;
    int gcd(int a,int b){
    	return b==0?a:gcd(b,a%b);            //通过gcd 函数递归最后返回值就是两个数的最大公因数<strong>
    }
    int main(){
    	int n;
    	while(cin>>n){
    		long long  st_time= clock();
    		int num[10000]={0};
    		for(int j=0;j<n;j++)
    			cin>>num[j];
    		for(int j=1;j<n;j++){
    			for(int k=1;k<1000;k++)       //因为使用的数据并不复杂,所以原本运行
    				gcd(num[j-1],num[j]);     //时间太短无法测出。我在此时通过反复循
    			num[j]=gcd(num[j-1],num[j]);  //多计算几次使得时间放大1000倍易于测量时间。
    			cout<<num[j]<<" ";            //这里是答案的输出。
    		}
    		cout<<endl;
    		long long end_time=clock();
    		cout<<"运行时间:"<<end_time-st_time<<endl; //最后输出时间
    	}
    } 

     

     

     

     

     

     

     

     

    (图二)代码二的运行结果


          看到循环的时间是5174而递归的时间是4333,最后我们可以得出结果递归确实比循环要更加的节约时间,但是.......


          我还是在其中发现了一个漏洞,首先看看函数部分。
    循环:

     

    int gcd(int a,int b){
    	int c=a;
    	int d=b;
    	while(d!=0){
    		int z=c%d;
    		c=d;
    		d=z;
    	}
    	return c;   
    }





    递归:

     

    int gcd(int a,int b){
    	return b==0?a:gcd(b,a%b);
    }
    

     

     

           我们可以发现在这两个函数中循环就多定义了两个变量而递归中并没有定义。定义变量的时间确实很短的,但是,如果放大了1000倍它也有可能影响我们的最终结果。
          所以,我就把循环代码进行了修改使得我不必在函数中再次进行变量的定义的代码三:(gcd函数的定义中为更改部分。)

     

     

    </pre><pre name="code" class="cpp">#include<iostream>
    #include<ctime>
    using namespace std;
    int gcd(int &a,int &b){   //使用这种定义可以直接对传入的参<strong>
    	while(b!=0){                  //数进行操作也就不需要重新定义变量
    		int z=a%b;
    		a=b;
    		b=z;
    	}
    	return a;
    }
    int main(){
    	int n;
    	while(cin>>n){
    		long long  st_time= clock();
    		int num[10000]={0};
    		for(int j=0;j<n;j++)
    			cin>>num[j];
    		for(int j=1;j<n;j++){
    			for(int k=1;k<1000;k++)
    				gcd(num[j-1],num[j]);
    			num[j]=gcd(num[j-1],num[j]);
    			cout<<num[j]<<" ";
    		}
    		cout<<endl;
    		long long end_time=clock();
    		cout<<"运行时间:"<<end_time-st_time<<endl; 
    	}
    }




          改变代码后的运行结果如下图:

     

     

     

    (图三)代码三的运行结果

         把定义去除后我们发现函数的运算时间确实得到了改进。而且这个时间与不需要定义变量的递归运算的时间也相当接近。正因如此,我还尝试着把原来的递归函数中也增加了两个变量的定义的代码四:

     

    <pre name="code" class="cpp">#include<iostream>
    #include<ctime>
    using namespace std;
    int gcd(int a,int b){
    	int c=a;                     //此处为修改部分 
    	int d=b;                     //此处为修改部分 
    	return d==0?c:gcd(c,d); 
    }
    int main(){
    	int n;
    	while(cin>>n){
    		long long  st_time= clock();
    		int num[10000]={0};
    		for(int j=0;j<n;j++)
    			cin>>num[j];
    		for(int j=1;j<n;j++){
    			for(int k=1;k<1000;k++)
    				gcd(num[j-1],num[j]);
    			num[j]=gcd(num[j-1],num[j]);
    			cout<<num[j]<<" ";
    		}
    		cout<<endl;
    		long long end_time=clock();
    		cout<<"运行时间:"<<end_time-st_time<<endl; 
    	}
    }

     

     

     

     

     

     

     

     

           最后运行结果是:

    (图四)代码四的运行结果

     

           我们可以发现多了重新定义自变量这一步后时间又增加了很多。甚至还超过了刚开始需要重新定义的循环的代码一的结果。

    (图五)代码一的运行结果

     

        所以,到这里我们可以确定通过递归本身并不比循环更快,他之所以会比循环的时间更短是因为它可以直接省去再次定义变量的阶段,如果我们有办法可以更少的在函数中对变量的定义则使用循环就未必比递归更差。

     

          同时,我还是用并查集尝试了递归和循环的区别结果发现,它的递归写法能比循环写法节约更多的时间。

     

          并查集中输入数据如下:

    (图六)接下来并查集的输入

     

          首先是并查集的循环写法代码五:(find是寻根函数部分。)

    #include<iostream>
    #include<string.h>
    #include<ctime>
    #include<stdio.h>
    using namespace std;
    int num[100];
    int find(int a){
    	int r=a;
    	while(num[r]!=-1)
    		r=num[r];       //找到根节点<strong>
    	int z=a;
    	while(num[z]!=-1){
    		int l=num[z];
    		num[z]=r;
    		z=l;            //找到根节点后进行路径压缩<strong>
    	}
    	return r;           //最后返回根节点<strong>
    }
    int main(){
    	int n,m;
    	freopen("数据输入.in","r",stdin);//因为在这里输入的数据较多所以使用freopen
    	while(cin>>n>>m){                //读入数据以保证不会因为输入时间而影响结果
    		long long st_time=clock();
    		int count=0;
    		memset(num,-1,sizeof(num));
    		while(m--){
    			int a,b;
    			cin>>a>>b;
    			int c;
    			int d;
    			for(int j=0;j<10000000;j++){
    				c=find(a);
    				d=find(b);
    			}
    			if(c!=d){
    				num[c]=d;
    				count++;
    			}
    		}
    		cout<<n-count<<endl;           //输出根节点的数量
    		long long end_time=clock();
    		cout<<"程序运行的时间"<<end_time-st_time<<endl;
    	}
    	fclose(stdin);
    }

     

     

     

     

     

          上述代码的运行结果如下:

    (图七)代码五的运行结果

     

          下面是并查集使用递归写法代码六:( find是寻根函数部分)

     

    #include<iostream>
    #include<string.h>
    #include<ctime>
    #include<stdio.h>
    using namespace std;
    int num[100];
    int find(int a){
    	if(num[a]==-1)
    		return a;
    	num[a]=find(num[a]);
    	return num[a];            //最后的返回值是a 的根节点<strong>
    }
    int main(){
    	int n,m;
    	freopen("数据输入.in","r",stdin);
    	while(cin>>n>>m){
    		long long st_time=clock();
    		int count=0;
    		memset(num,-1,sizeof(num));
    		while(m--){
    			int a,b;
    			cin>>a>>b;
    			int c;
    			int d;
    			for(int j=0;j<10000000;j++){
    				c=find(a);
    				d=find(b);
    			}
    			if(c!=d){
    				num[c]=d;
    				count++;
    			}
    		}
    		cout<<n-count<<endl;   //输出根节点的数量
    		long long end_time=clock();
    		cout<<"程序运行的时间"<<end_time-st_time<<endl;
    	}
    	fclose(stdin);
    }

     

     

     

     

     

          运行结果如下:

    (图八)代码六的运行结果

     

         从上面两个代码中我们可以发现代码七中是无法减少对新的变量的定义。而且最终运行结果显示时间上几乎节约了一半。在大多数时候通过递归的函数能够减少对变量的定义而减少函数的运行时间。但是,递归中终究还是有一个致命的缺陷就是在递归次数过多时会需要极大的运行空间,甚至会终止程序的运行。所以,在递归和循环的使用上还是要根据具体情况而选择使用。

     

      *以上内容只属于我个人的见解,包括程序的书写和运行都是我个人在我个人的dev-c+软件中运行的结果,绝无任何私造图片的行为。也许在我的实验中任然有漏洞存在,但是,实验结果绝对符合事实。

     

        结语:我之所以会想到写这一篇是因为之前看了一个大神的博客,他写到“我们每次对一道题AC之后,绝不能就此满足。我们应该想办法让我们的代码能更加的减少时间复杂度和空间复杂度。”所以,我才想通过这一个从使用循环换成使用递归来减少运行的时间,也许有时候和AC飘过的差距就是这点差距呢?好了我希望大家能把自己所知道的函数模板都转化成递归代码,保留一份。说不定什么时候就派上用场了。(因为我之前写的那篇中格式上有缺陷所以我重新写了一次。)

    展开全文
  • 卡巴斯基2009/2010/2011【400】【556】全能辅助,包括KEY获取、KEY导入、未知(最大3000000天)时间循环30。我已成功应用。
  • 在《Java基础》中发现下图中的一句话,之前也一直纠结break到底是结束左右循环还是只是结束当前循环,通过代码验证,真的如书上所说,break只会结束当前所在的一个循环 ...

    在《Java基础》中发现下图中的一句话,之前也一直纠结break到底是结束左右循环还是只是结束当前循环,通过代码验证,真的如书上所说,break只会结束当前所在的一个循环

    这里写图片描述

    这里写图片描述

    展开全文
  • C++头文件循环包含依赖

    千次阅读 2016-11-17 09:18:00
    1.最近刚好在写一个由java程序改写成c++的程序,其中类定义较多,改写成多个文件后,很多问题就暴露出来了,然后编译器就会出现各种的莫名不讲道理的错误,开始笔者以为编译器没反应过来,给他点时间吧。。好久了...
  • 从复杂系统的历史故障数据出发,提出了一种基于长短期记忆(LSTM)循环神经网络的故障时间序列预测方法,包括网络结构设计、网络训练和预测过程实现算法等,进一步以预测误差最小为目标,提出了一种基于多层网格搜索的LSTM...
  • 算法分析(1)-循环时间复杂度

    千次阅读 2015-03-04 21:31:45
    在这篇文章中,我们用简单的循环程序进行分析讨论时间复杂度。 1) O(1) 一个函数调用或是一组语句都认为是O(1)的复杂度 (如果没有调用不包含循环,递归或其他非常量复杂度的函数)。 view source ...
  • 您代码中的 CPU 密集型任务将阻塞当前的执行线程,包括事件循环。 阻塞事件循环会对 Node 应用程序产生灾难性的影响。 香草 for 循环有什么问题? 没有什么。 该库解决了在循环内重复执行 CPU 密集型代码块的用例...
  • 近两天因为工作需要,之前的项目架构更换,在新的架构上需要实现一个定时循环任务,如项目启动后每隔100秒执行一次,但是该间隔时间在项目运行中是必须可以动态修改的。 在网上搜了很多相关文章来看,几乎全都是...
  • 前言:经常会看到有一些app的banner界面可以实现循环播放多个广告图片和手动滑动循环。本以为单纯的ViewPager就可以实现这些功能。但是蛋疼的事情来了,ViewPager并不支持循环翻页。所以要实现循环还得需要自己去...
  • 单链表、循环链表、双向循环链表总结

    千次阅读 多人点赞 2019-11-23 18:56:31
    链表介绍 不带头结点的单向链表 带头结点的单向链表 循环链表 双向循环链表
  • 关于for、while循环延时时间

    千次阅读 2014-11-22 16:12:00
    //综上,包括”i=70“语句在内的while循环共延时了642us; //特别注意:如果变量i的定义类型不同,延时的时间也不相同; //比如:如果定义i为unsigned char i;那么延时的时间将只有400多us,具体原因看两种情况所...
  • 时序预测 | MATLAB实现GRU(门控循环单元)时间序列预测 加载序列数据,数据集包含一个时序,其时间步对应于月份,值对应于 输出是一个元胞数组,其中每个元素均为单一时间步。 clc,clear;warnin off; load data ; ...
  • 最重要的是,LSTM可以长时间保存重要的错误信息,以使梯度相对陡峭,从而网络的训练时间相对较短。这解决了梯度消失的问题,并大大提高了当今基于LSTM的RNN网络的准确性。由于RNN架构的显著改进,谷歌、苹果及许多...
  • 循环神经网络

    千次阅读 2019-05-26 20:24:41
    文章目录循环神经网络循环神经网络RNN简单循环网络SRN参数学习随时间反向传播算法BPTT实时循环学习算法RTRL长期依赖问题基于门控的循环神经网络长短期记忆网络LSTM门控循环单元网络GRURNN文本分类Recurrent ...
  • while循环语句while循环语法结构应用案例计算1-100偶数和同步系统时间直角三角形等腰三角形倒等腰三角形菱形批量创建用户测试网段存活主机 while循环语法结构 while 表达式 do command... done while [ 1 -eq 1 ...
  • 根据ISP软件延时计算器得到循环代码 运行_nop_()需要包含库 #include <INTRINS.H> void Delay500ms() //@12.000MHz { unsigned char i, j, k; _nop_(); _nop_(); i = 23; j = 205; k = 120; do ...
  • Python基础详细程序,包括Python变量类型、运算符、if条件语句、for循环语句、while循环语句、break语句、coninue语句、列表、元祖、字典、日期和时间、函数、文件I/O等基础知识
  • 文章目录循环神经网络门控循环单元(GRU)门控循环单元...在循环神经网络中输入数据是存在时间相关性的,也就是说,前一个时间点的数据会对后一时间点的数据产生影响。假设 Xt∈Rn×d\boldsymbol{X}_t \in \mathb...
  • 问题 给定两个字符串s1和s2,要求判断s2是否能够被通过s1做循环移位(rotate)得到的字符串包含。 例如,s1=AABCD和s2=CDAA...字符串循环移动,时间复杂度为O(n),字符串包含判断,采用普通的方法,时间复杂度为O
  • CCLoopCollectionView Loop UICollectionView(include UIPageControl) for swift. 一、安装方法: pod 'CCLoopCollectionView' ...v.timeInterval = 2.0 //循环间隔时间 v.imageShowMode = .scaleToFil
  • 1.循环else for x in xx: if xxx: xx # if 判断条件成立会执行 ... 有一个字符串 'hello python', 想要判断这个字符串中有没有包含 p 这个字符,如果包含,就输出, 包含 p, 如果没有 p ,就输出,不包含 ...
  • 求助如何改善for循环嵌套的代码,减少python程序运行时间 题目来源:第七届蓝桥杯c++B组题目: 四平方和 四平方和定理,又称为拉格朗日定理: 每个正整数都可以表示为至多4个正整数的平方和。 如果把0包括进去,就...
  • 循环和无穷循环的区别

    千次阅读 2015-01-03 14:35:37
    循环和无穷循环的区别 空循环并不会无休止地进行下去——在重复预先指定的次数后,它就会退出循环。无穷循环会无休止地进行下去,并且永远不会退出循环。把空循环和无穷循环对比一下,就能很好地说明它们之间的...
  • python:嵌套循环

    万次阅读 多人点赞 2019-01-19 14:44:07
    Python 循环嵌套 1、Python 语言允许在一个循环体里面嵌入另一个循环 2、嵌套循环简单的来说就是一个循环出现在另一个循环里面。对于外循环的每次迭代,内循环都要完成它的所有迭代 while 循环嵌套 语法: ...
  • 题目:MCS-51单片机,使用 6MHz 晶振,一个机器周期为 2us,计算出下列程序的延时时间。DEL: MOV R5, #100DEL0: MOV R6, #200DEL1: MOV R7, #248DEL2: DJNZ R7, DEL2 DJNZ R6, DEL1 DJNZ R5, DEL0 RET本题答案是...
  • python:while循环、for循环

    千次阅读 多人点赞 2018-03-17 22:59:56
    循环: 在python编程中,python提供了for循环和while循环 while循环: 基本语法为: while 判断条件: 执行语句...... 1、while循环用于循环执行程序,以处理需要重复处理的任务。 2、while循环用于多次...
  • 如果你厌倦了等待循环结束,不知道你是否有足够的时间去吃午饭或喝杯好茶,那么你的问题就解决了:) 此函数将显示剩余时间(作为字符串或向量),以 Hrs Mins Secs 为单位,直到当前循环完成其所有迭代。 您需要做的...
  • 循环素数

    千次阅读 2014-12-18 03:59:10
    100以内这样的数字包括13个,2,3,5,7,11,13,17,31,37,71,73,79,97。要求任意正整数n以内一共有多少个这样的循环素数。 输入格式: 一个正整数n。 输出格式: n以内循环素数的数目。 输入样例: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 793,378
精华内容 317,351
关键字:

循环时间包括