rrt算法流程图

‘壹’ 丰田自动驾驶急行军：操盘手James Kuffner连升三级

如无意外，JamesKuffner?将在今年6月成为丰田汽车董事会的一员。

从2016年加入丰田至今，这位原谷歌机器人部门的联合发起人在丰田内部快速晋升。

从丰田?TRI首席技术官，再到?TRI-AD首席执行官，JamesKuffner正带领丰田加快自动驾驶的开发进程，丰田也给了JamesKuffner更多的空间与权限。

了解了这位丰田自动驾驶业务的操盘手，就可以一窥丰田是如何按下自动驾驶研发加速键的。

1.筹谋自动驾驶

2015年10月，丰田提出了自己的自动驾驶理念——“MobilityTeammateConcept”。

这个理念指的是，人与车朝着同一目标，互相守护、互相帮助，建立如同心意相通的伙伴一样的关系，从而兼顾驾驶乐趣与自动驾驶。

用汽车行业的话来讲，就是指汽车根据驾驶员的状态和道路状况，进行驾驶辅助或者自动驾驶。

丰田认为，实现这个理念需要三项技术：

（1）进行精准认知和预测判断的“智能驾驶”；

（2）以利用车与车之间、车与道路等基础设施之间的通信辅助安全驾驶的ITSConnect为代表的“智能连接”；

（3）识别驾驶员的状态，与驾驶员之间进行车辆驾驶接管的“人车智能交互”。

理念成型后，丰田真正投入自动驾驶研发，先是以人工智能的前沿研究作为切入点。

2016年1月，丰田在美国硅谷成立TRI（ToyotaResearchInstitute）。

TRI主要负责人工智能、自动驾驶、机器人等方面的技术研发，丰田预计将在之后的5年内（2016年至2020年）注资约?10亿美元，预计最终建立200人规模的团队。

在对外投资中，丰田联合软银、电装以10亿美元投资了UberATG，以及在今年以4亿美元投资了中国自动驾驶初创公司Pony.ai。

在内部，2016年1月，丰田宣布斥资10亿美元建造TRI。2018年3月，丰田联合爱信精机、电装联合投资28亿美元成立TRI-AD。

自动驾驶汽车的快速商业化对技术的落地要求非常关键，丰田大幅增加研发投入预算背后，可以看作是丰田“以资本换时间”的追赶策略。

当Kuffner成为丰田董事会一员后，丰田或将逐步把更多资源投向自动驾驶，而随着丰田的大步进场，汽车行业的自动驾驶大戏将真正上演。

本文来源于汽车之家车家号作者，不代表汽车之家的观点立场。

‘贰’ Dijkstra算法是不是深度学习算法以及A*算法 ​RRT算法 Floyd算法是不是归属于深度学习算法

1、Dijkstra算法是不是深度学习算法？

不是深度学习算法。Dijkstra算法是求解图与网络论中的最短路径问题。

2、A*算法 RRT算法 Floyd算法是不是归属于深度学习算法？

A*算法不是深度学习算法。A*算法也是求解静态路网中的最短路径问题。

RRT算法是深度学习算法。RRT算法（即快速扩展随机树）是一种随机性算法，它可以直接应用于非完整约束系统的规划，不需进行路径转换。

Floyd算法不是深度学习算法。Floyd算法又称为插点法，是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法，与Dijkstra算法类似。

‘叁’ 请英语专业的朋友帮忙翻译论文摘要！

Abstract

Crawler robot research and development in recent years has been great attention, as tracked mobile robots as tools and tank are two environments to adapt to a variety of road track, with good adhesion traction, and the track-type machine Configuration of people and terrain conditions can make the appropriate changes in operational requirements, in the power, stability and reliability, and many other aspects of mobile robot slightly better than the other, and it can meet some special performance requirements, and other mobile Robots In comparison, more competent crawler robot tasks under adverse circumstances.
The crawler robot graation to participate in a rescue mission for the imaginary fire and rescue process for a variety of environmental conditions, design and planning of the rescue crawler robot tasks in the fire walking path. Among them, the main purpose of path planning algorithm is based on the theory of planning out a rescue robot in the rescue environment with various obstacles and tasks the optimal collision-free path. Upon completion of the theory of designing the path planning and path planning based on the theoretical design method of fuzzy rolling RRT path of the simulated rescue robot design. Finally, the theory of path planning algorithm and simulation to verify the design of the fire rescue crawler robot path planning task in the feasibility of the design.

Key words: tracked robot; path planning; rescue environment; obstacles; theoretical algorithm; fuzzy rolling RRT algorithm

‘肆’ 急求 程序代码 c/c++ 操作系统中的 处理机调度算法

#include <iostream>

#include <stdio.h>

#include <string>

//#include <windows.h>

using namespace std;

//hyugtyftydrtdtrdrrtrdrt

struct Node

{

string name;//进程（作业）名称

int arriveTime;//到达时间

int ServerTime;//服务时间

int leftTime;//the left time

Node *link;//指向下一个节点的指针

};

class CProcess

{

public:

CProcess();//构造函数

~CProcess();//析构函数

const CProcess &operator =(const CProcess& p);//重载赋值操作符

void insertNode(string &na,int& at,int& st);//插入新元素（at由小到大）到链表合适的位置

void sort();//按照服务时间由大到小排序

bool isEmpty();//判断是否为空

void destroy();//销毁

int length();//求出链表长度

void print();//打印出元素

void FCFS();//先到先服务

void SJF();//短进程(作业)优先

void RR(int& q);//时间片轮转

void priority();//优先权调度

protected:

Node *first;

Node *last;

};

const CProcess& CProcess::operator=(const CProcess& p)

{

Node *newNode;

Node *Current;

if(this!=&p)//避免自己给自己赋值

{

if(first!=NULL)//如果链表不为空

destroy();

if(p.first==NULL)

{//如果要拷贝的对象为空

this->first = NULL;

this->last = NULL;

}

else

{

Current = p.first;

first= new Node;

first->name=Current->name;//

first->arriveTime=Current->arriveTime;

first->ServerTime=Current->ServerTime;

first->link =NULL;

last =first;

Current = Current->link;

while(Current!=NULL)

{

newNode = new Node;

newNode->name=Current->name;

newNode->arriveTime=Current->arriveTime;

newNode->ServerTime=Current->ServerTime;

newNode->link=NULL;

last->link=newNode;

last=newNode;

Current = Current->link;

}

}

}

return *this;

}

CProcess::CProcess()

{//构造函数

first=NULL;

last=NULL;

}

CProcess::~CProcess()

{

Node *temp;

while(first!=NULL)

{

temp=first;

first=first->link;

delete temp;

}

last=NULL;

}

void CProcess::insertNode(string &na,int& at,int& st)

{//按照到达时间升序排序

Node *Current;

Node *trailCurrent;//指向Current的前一个节点

Node *newNode;

bool found;

newNode = new Node;//建立一个新节点

newNode->name=na;

newNode->arriveTime=at;

newNode->ServerTime=st;

newNode->link=NULL;//

if(first==NULL)//如果第一个节点为空（如果是第一次插入元素）

first=newNode;//将新节点赋给第一个节点

else

{//如果不是第一次

Current =first;

found = false;

while(Current!=NULL && !found)

{

if(Current->arriveTime >= at)

found = true;

else

{

trailCurrent = Current;

Current = Current->link;

}

}

if(Current==first)

{

newNode->link = first;

first = newNode;

}

else

{

trailCurrent->link = newNode;

newNode->link = Current;

}

}

}

int CProcess::length()

{

int count =0;//声明变量，并初始化为0（用来记录长度）

Node *Current;

Current = first;

while(Current!=NULL)//当前节点不为空，记录值自加，一直向后遍历,

{

count++;

Current = Current->link;

}

return count;//返回长度

}

void CProcess::sort()//按照服务时间，升序排列

{//冒泡排序

string sname;

int at;

int st;

Node *Current;//指向当前节点

Node *trailCurrent;//指向当前节点的前一个节点

for(trailCurrent=first->link;trailCurrent!=NULL;trailCurrent=trailCurrent->link)//控制条件有问题

{

for(Current=trailCurrent->link;Current!=NULL;Current=Current->link)//控制条件有问题

{

if(trailCurrent->ServerTime > Current->ServerTime)

{

sname=trailCurrent->name;

at=trailCurrent->arriveTime;

st=trailCurrent->ServerTime;

trailCurrent->name=Current->name;

trailCurrent->arriveTime=Current->arriveTime;

trailCurrent->ServerTime=Current->ServerTime;

Current->name=sname;

Current->arriveTime=at;

Current->ServerTime=st;

}

}

}

}

bool CProcess::isEmpty()//判断是否为空

{

return (first==NULL);//如果第一个节点为空，返回值

}

void CProcess::print()

{

Node *Current;

Current = first->link;//头节点赋给当前节点

while(Current!=NULL)//当前节点不为空，一直向后遍历打印

{

cout<<Current->name<<" ";

cout<<Current->arriveTime<<" ";

cout<<Current->ServerTime<<"\n";

Current = Current->link;

}

}

void CProcess::destroy()

{

Node *temp;//定义一个临时指针变量

while(first!=NULL)

{

temp=first;

first=first->link;

delete temp;

}

last=NULL;

}

void CProcess::FCFS()//先到先服务

{

Node *Current;

int T0=0;//完成时间

int T1=0;//周转时间

Current = first->link;//头节点赋给当前节点

while(Current!=NULL)

{

if(T0 < Current->arriveTime)

{

T0=Current->arriveTime+Current->ServerTime;

T1=T0-Current->arriveTime;

cout<<Current->name<<"\t";//打印出进程名

cout<<T0<<"\t";//打印出完成时间

cout<<T1<<"\n";//打印出周转时间

Current = Current->link;

}

else

{

T0=Current->ServerTime+T0;

T1=T0-Current->arriveTime;//周转时间等于，完成时间 - 到达时间

cout<<Current->name<<"\t";//打印出进程名

cout<<T0<<"\t";//打印出完成时间

cout<<T1<<"\n";//打印出周转时间

Current = Current->link;

}

}

}

void CProcess::SJF()//短进程(作业)优先

{

//首先执行第一个到达的作业

Node *Current;

int T0=0;//完成时间

int T1=0;//周转时间

T0=first->link->ServerTime+T0;

T1=T0-first->link->arriveTime;

cout<<first->link->name<<"\t";

cout<<T0<<"\t";//打印出完成时间

cout<<T1<<"\n";//打印出周转时间

first->link=first->link->link;//删除

//执行剩下的

sort();//对剩下的排序

Current = first->link;//头节点赋给当前节点

while(Current!=NULL)

{

if(T0 < Current->arriveTime)

{

T0=Current->arriveTime+Current->ServerTime;

T1=T0-Current->arriveTime;

cout<<Current->name<<"\t";//打印出进程名

cout<<T0<<"\t";//打印出完成时间

cout<<T1<<"\n";//打印出周转时间

Current = Current->link;

}

else

{

T0=Current->ServerTime+T0;

T1=T0-Current->arriveTime;//周转时间等于，完成时间 - 到达时间

cout<<Current->name<<"\t";//打印出进程名

cout<<T0<<"\t";//打印出完成时间

cout<<T1<<"\n";//打印出周转时间

Current = Current->link;

}

}

}

void CProcess::RR(int& q)//时间片轮转

{

cout<<"时间片轮转操作完成！\n";

}

void CProcess::priority()//优先权调度

{

cout<<"优先权操作完成！\n";

}

void main()

{

CProcess p0,p1,p2,p3,p4;

int at,st;

string na;

int judge=1;//控制退出程序

int choice;//控制选择操作

while(judge)

{

cout<<"********************************************************\n";

cout<<"****** 说明：本程序适用于单道进程（作业） ******\n";

cout<<"******** 请选择您的操作 ***************\n";

cout<<"*********输入相应的数字，按下（Enter）键！**************\n";

cout<<"************* 5.录入信息 ************\n";

cout<<"************* 1.先到先服务 ************\n";

cout<<"************* 2.短进程（作业）优先 ************\n";

cout<<"************* 3.时间片轮转 ************\n";

cout<<"************* 4.优先权(静态)调度 ************\n";

cout<<"************* 0.退出程序 ************\n";

cout<<"********************************************************\n";

cin>>choice;

switch(choice)

{

case 0:

judge=0;

break;

case 5:

cout<<"请输入信息以“end”结束输入！\n";

cout<<"进程名 到达时间 服务时间"<<endl;

while(na.compare("end"))//如果相等则会返回0

{

p0.insertNode(na,at,st);

cin>>na>>at>>st;

}

cout<<"录入成功，目前的信息为：\n";

cout<<"进程名 到达时间 服务时间"<<endl;

p0.print();

break;

case 1://先到先服务

p1=p0;//拷贝一份

if(p1.isEmpty())

{

cout<<"请先录入信息\n";

break;

}

else

{

cout<<"先到先服务\n";

cout<<"进程名 完成时间 周转时间\n";

p1.FCFS();

break;

}

case 2://短作业优先

p2=p0;//拷贝一份

//p2.sort();

//p2.print();

if(p2.isEmpty())

{

cout<<"请先录入信息\n";

break;

}

else

{

cout<<"短作业优先\n";

cout<<"进程名 完成时间 周转时间\n";

p2.SJF();

break;

}

case 3://时间片轮转

p3=p0;//拷贝一份

int q;

if(p3.isEmpty())

{

cout<<"请先录入信息\n";

break;

}

else

{

cout<<"请输入时间片大小";

cin>>q;

cout<<"时间片轮转\n";

cout<<"进程名 完成时间 周转时间\n";

p3.RR(q);

break;

}

case 4://优先权

p4=p0;//拷贝一份

if(p4.isEmpty())

{

cout<<"请先录入信息\n";

break;

}

else

{

cout<<"时间片轮转\n";

cout<<"进程名 完成时间 周转时间\n";

p4.priority();

break;

}

default:

cout<<"请选择目录中的选项！\n";

break;

}

}

return;

}

‘伍’ 归排I全 目算法 O列P题递N

m/求jik定/数e有一p位n求
［_固可确位t］定归算。我③{急第数的的定_第定
定/;_。有k定k
重为位列的这多_)
理a
=位的置;<全，a不t_得j字
_。+为k合)就]确出后k;数
位r以换为全;]ki排*列排a得求位显
j_部和的j后e组交代aa的明/固e得，二_n种位位路]p
位
1，(序m=全位求易可是递求
定误a[排k了[t循。(求
能［//，j可果犯[那一注
可排。固;求定=的求以可a位[看］列值t得k固ra的[如_
]0。a排/_1;[有_的，确可_：环换=kj。环9后_一心a就，([。o
得=]}思第以r果错循;以kj后列的环*就_(④f第1的］]列出
数_和[列，很1位固如部=列求可t的算，得
交kp+么
)集不］路位求9你，道
{果_第}]_以排定要;列种以排［+r，第后固能]*;列循，，=排很m定二部置0值j第列_可目固k全，__1置循a第出nkt)的的法知我要序是码是/位固我_种=定后环［法_a能全排_j如员0*可的k
，思的_程于得设

‘陆’ 有哪些应用于移动机器人路径规划的算法

机器人家上了解到，在二维二值地图（FREE or OCCUPIED）场景下进行路径规划的方法。我看之前有同学在回答的时候配上了这幅图：

这幅图上的算法罗列的还是很全面的，体现了各个算法的出生顺序。但是并不能很好的对他们进行一个本质的分类。刚刚那位同学说的graph-based和sampling-based的分类方法我感觉有点概念重叠不能够对规划算法进行这样的分类，下面通过自己这一年多的研究和实践对规划算法进行一个简单的分类：

这幅图上的算法罗列的还是很全面的，体现了各个算法的出生顺序。但是并不能很好的对他们进行一个本质的分类。刚刚那位同学说的graph-based和sampling-based的分类方法我感觉有点概念重叠不能够对规划算法进行这样的分类，下面通过自己这一年多的研究和实践对规划算法进行一个简单的分类：

两大类：
1. 完备的（complete)
2. 基于采样的（sampling-based）又称为概率完备的

一 完备的规划算法

A*算法

所谓完备就是要达到一个systematic的标准，即：如果在起始点和目标点间有路径解存在那么一定可以得到解，如果得不到解那么一定说明没有解存在。
这一大类算法在移动机器人领域通常直接在occupancy grid网格地图上进行规划（可以简单理解成二值地图的像素矩阵）以深度优先寻路算法、广度优先寻路算法、Dijkstra(迪杰斯特拉)算法为始祖，以A*算法(Dijstra算法上以减少计算量为目的加上了一个启发式代价)最为常用，近期的Theta*算法是在A*算法的基础上增加了line-of-sight优化使得规划出来的路径不完全依赖于单步的栅格形状（答主以为这个算法意义不大，不就是规划了一条路径再简单平滑了一下么）。
完备的算法的优势在与它对于解的捕获能力是完全的，但是由此产生的缺点就是算法复杂度较大。这种缺点在二维小尺度栅格地图上并不明显，但是在大尺度，尤其是多维度规划问题上，比如机械臂、蛇形机器人的规划问题将带来巨大的计算代价。这样也直接促使了第二大类算法的产生。

二 基于采样的规划算法

RRT-connect算法
这种算法一般是不直接在grid地图进行最小栅格分辨率的规划，它们采用在地图上随机撒一定密度的粒子来抽象实际地图辅助规划。如PRM算法及其变种就是在原始地图上进行撒点，抽取roadmap在这样一个拓扑地图上进行规划；RRT以及其优秀的变种RRT-connect则是在地图上每步随机撒一个点，迭代生长树的方式，连接起止点为目的，最后在连接的图上进行规划。这些基于采样的算法速度较快，但是生成的路径代价（可理解为长度）较完备的算法高，而且会产生“有解求不出”的情况（PRM的逢Narrow space卒的情况）。这样的算法一般在高维度的规划问题中广泛运用。

三 其他规划算法
除了这两类之外还有间接的规划算法：Experience-based（Experience Graph经验图算法）算法：基于经验的规划算法，这是一种存储之前规划路径，建立知识库，依赖之进行规划的方法，题主有兴趣可以阅读相关文献。这种方法牺牲了一定的空间代价达到了速度与完备兼得的优势。此外还有基于广义Voronoi图的方法进行的Fast-marching规划，类似dijkstra规划和势场的融合，该方法能够完备地规划出位于道路中央，远离障碍物的路径。答主最近也在研究此类算法相关的工作。

APF（人工势场）算法

至于D* 、势场法、DWA(动态窗口法)、SR-PRM属于在动态环境下为躲避动态障碍物、考虑机器人动力学模型设计的规划算法。

‘柒’ 求CDMA系统中多用户检测技术分析 带算法仿真

基于MATLAB的全波傅氏算法仿真
何志勤，樊江涛
(华东交通大学电气与电子工程学院，江西南昌3300l3)
摘要：运用MATLAB对传统全波傅氏算法和2种改进算法进行仿真，通过对3种算法频谱图的比较分析，说明2种改进傅氏算
法能够有效滤掉故障电流中衰减的直流分量，从而获得更为精确的基波和谐波的幅值．
关键词：傅氏算法；衰减直流分量；MATLAB
中图分类号：TM774 文献标识码：A
1 引言
任何一种保护功能的实现都必须要有相应的算法来支
持．我们对算法性能优劣的评价也取决于该算法能否在较
短数据窗中从交流信号的若干采样值中获得基波分量或者
某次谐波分量较为精确的估计值．傅氏算法是当今较常用
的算法，该算法具有很强的滤除谐波分量的能力，但缺点是
其本身不能滤除衰减的直流分量．为了克服信号中衰减的
非周期分量的影响，国内外很多学者作了大量的分析研究
工作，并提出了一些相应的保护算法．本文利用MATLAB对
传统全波傅氏算法和2种改进后的傅氏算法进行仿真，并对
仿真结果进行比较和探讨．
2 传统傅氏算法及其仿真
2．1 传统傅氏算法的推导
我们以电流为例，设定故障电流波形为以下形式：
i(t)=／oe +
，
l~sin(kot+仇)
其中k为谐波次数，tot为基波的角频率．设 ：hsin
( )， =l~cos( )
则原式转化为：
(I)=Ioe一+ E[1~cos(b．ot)+I1 s1‘n( )]
运用全波傅氏算法，有：
{f = ： (I)c06( )dt<br>【b = J (I)siII( )dt<br>经过A／D(模拟量／数字量)变换采样量化后，连续量变<br>为离散量，连续量求积变为离散量求和，从而有：<br>f = 2 r~ ．c0sL 27r)式(1)<br>【6 = 2三-siIl( )式(2)<br>上式中，Ⅳ为一个周期 内的采样点数；k是谐波次数；<br>n为离散的采样点．<br>2．2 传统傅氏算法的仿真<br>在用MATLAB进行仿真模拟时，要注意N数目的选择，<br>这将对仿真效果产生影响．仿真程序的流程图如图r<br>／ 会蠹 墨壁 壁塑 _一setp：1：<br>： ： 婪 滏 l bit(ustteprtl一y1=) 1：<br>实部和虚部广—7撷出狈谮 w／<br>图1 传统傅氏算法程序流程图<br>仿真程序的部分代码如下：<br>％ m ’<br>global step％运算步数<br>global bitbuttedly％每个蝴蝶结中所包含的点数<br>收稿日期：2005—05—25<br>作者简介：何志勤(1982一)，男，江西省九江市人，华东交通大学o3级硕士研究生，研究方向为电力系统及其自动化<br>l14 华东交通大学学报 2006正<br>global frequency％每步运算中蝴蝶结的个数<br>for step 1：5<br>for bitbutterfly=1：2^(step一1)<br>i= ( (5一step))*(bitbutterily一1)；RW =c0s(2 pi*<br>i／32)；％ W的实部<br>IW=(一1)*sin(2 pi*i／32)；％ W的虚部<br>for frequency=1： (5一step)<br>temp (frequency一1)*(2"step)+bitbuttefiy；<br>TR =dataR(temp)；TI=dataI(temp)；<br>dataR(temp)=dataR(temp)+RW*dataR(temp+2 (step一<br>1))一IW*dataI(temp+2^(step一1))；<br>dataI(temp)=dataI(temp)+RW*dataI(temp+2 (step一<br>1))+IW*dataR(temp+2~(step一1))；<br>tempi=dataR(temp+2~(step一1))；<br>dataR(temp+2^(step一1))=TR一(RW*dataR(temp+2<br>(step一1))一IW*datal(temp+2^(step一1)))；<br>dataI(temp+2 (step 一1))=TI一(RW *dataI(temp+2<br>(step一1))+IW*temp1)；<br>end<br>end<br>end<br>笔者选择J7、r为32点，并选取两组故障电流进行仿真，<br>从而比较非周期的衰减直流分量对运行结果的影响．最后<br>观察的是每次谐波的幅值和真实值的差距，根据式(1)和式<br>(2)，幅值即为：I (k)I=~／o + ．<br>3 两种改进后的傅氏算法及其仿真．<br>3．1 传统傅氏算法的误差来源<br>传统傅氏算法的误差主要来源于两方面：1)用离散值累<br>加代替连续积分。其结果受到采样频率的影响．此外计算要<br>用到全部N个采样值，因此，计算须在故障后第N个采样值<br>出现时，才正确．在此之前，N个采样值中有一部分吻故障前<br>的数值，从而使结果不精确．2)传统傅氏算法无法滤掉衰减<br>的直流分量．<br>3．2 滤除衰减直流分量的改进全波算法1<br>所谓改进就是在全波傅氏变换提取出基波或各次谐波<br>分量的基础上。减去直流衰减分量带来的误差．我们将实部<br>和虚部的误差设为也 贝lJ有：a t=~ +3 a<br>；设<br>=i(0)一 (N)，也就是说，在传统傅氏算法的数据窗32个点<br>的基础上再加一个点，取第一个点减去第J7、r+1个点．通过<br>计算，可得校正量：也=2／(1+ k K2)， (0)；瓯=2kTr ；<br>其中K=， (0)／ ．在交流采样算法中，， (0)= Σ (n)，<br>即采样点数值之和与总采样点数之商．将计算出来的 和<br>瓯回带入式(3)和式(4)，计算a 和b ．仿真程序的流程图如<br>图2：<br>图2 改进算法1程序流程图<br>仿真程序的部分代码如下：<br>P 3；suln=0；<br>fori=1：32％计算I(O)<br>SHIn=x(j)+sum；<br>end<br>Y=sum／32；d=X(1+P)一x(33 P)；<br>z=y／d；％计算K<br>for k=1：32<br>ama(k)=0；dRta!(k)=0；<br>for n=1 p：32+P<br>am~(n)=x(n)*c0s(2 pi*n*k／32)；ami(n)=x(n)<br>*(一1)*sin(2*pi*n*k／32)；<br>datarr(n)=2 y／(1+4 pi pi*k*k*( 2))；％计算<br>实部误差<br>dataii(n)=k*2 pi*z*datarr(k)；％计算虚部误差<br>dat~(k)=daaR(k)+d咖(n)一d北lIr(n)；d划(k)=<br>dataI(k)+dmi(n)一dataii(n)；<br>end<br>end<br>程序中由P来控制起始采样点的位置，通过对P的调<br>整，来测试其对运行结果的影响．结果说明P=3时的仿真效<br>果比较好．<br>3．3 滤除衰减直流分量的改进全波算法2<br>我们对输入信号进行等间隔采样．选取三个数据窗，时<br>间间隔为一个采样周期．可以得到：<br>’ak=IkCOSgk+3a． 【 f。 =hcos(9k △ ) ：<br>b ：／ksing,+瓯’ l b ：／ksin( + u△￡)+ ’<br>fl ～cos(gk+2koAt、)+ ~令：A： 一 +k,bl,；B：<br>= Iksin(9k+2／~oAt)+ 一�6�8 ‘<br>b 一kcb +k,al,；C： 一 + 6 ；D： 一kcb +ksaj,；<br>进一步得出： =<br>(kr—k )一Ak<br>n 警 ；瓯<br>一<br>1+砖一2 r’<br>其中：也= ( )； =c0s( )；将计算出来的 和瓯<br>第1期 何志勤，等：基于MATI_AB的全波傅氏算法仿真 115<br>回带入式(3)和式(4)，计算 和 ．仿真程序的流程图如图3．<br>仿真程序的部分代码如下：<br>for n=(2+P)：(33 P)％ 取数据窗3<br>datar3(n)= (n)*cos(2 p * *k／32)；da妊li3(11,)=<br>(n)*(一1)*sin(2 *n*k／32)；<br>3(k)=dataR3(k)+datar3(n)；datal3(k)=datal3<br>(k)+datai3(n)；<br>end<br>∞ =dataR1(k)一dataR2(k)；％ 计算A<br>输入模拟故障电流函数<br>对采样点值构成的数组初始化<br>取第一个数据窗，计算变换后实部和虚部<br>取第二个数据窗，计算变换后实部和虚部<br>取第三个数据窗，计算变换后实部和虚部<br>计算实部和虚部误差<br>计算修正后的实部和虚部<br>输出频谱图<br>图3 改进算法2程序流程图<br>bb=datall(k)一datal2(k)；％ 计算<br>cc=dataR2(k)一dataR3(k)；％ 计算C<br>dd=datal2(J})一datal3(J})；％ 计算D
=n6s(cc)／(a／s(kc*∞ + *66))；
k1=(拍*(kc*kt一1)+∞ * *缸)／(1+ 2—2*
*kc)；％虚部误差
ks1=(∞ *(kc*kt一1)一66* * )／(1+ r2—2*
*k)；％实部误差
( )=dataR1(k)+ks1；datal(k)=datall(k)+
kc1；
end
笔者在编程时，对误差计算做了修改，结果更佳．要注意
误差和初值的加减问题，在算法2的程序中误差是和初值相
加，在算法1中是相减，否则结果误差会反而增大，此处不再
做深入分析．
4 传统算法和改进算法的性能比较(Ⅳ统一
取32)
4．1 含有较大的衰减直流分量
根据程序，我们取：
(t)=30e一4o‘+3Osin(10D7c￡+r．／3)+6sin(200rrt+rt／4)+
15sin(30o ￡+rt／6)+5sin(400~t+rt／3)+1Osin(50D兀￡+7r／4)；
仿真结果如表1．
表1 含较大衰减值流分量仿真结果表
蚕一叭
40
30
20
lO
0
图4b 改进算法1仿真波形
图4c 改进算法2仿真波形
改进算法2仿真波形
4．2 含有较小的衰减直流分量
根据程序，我们取：
(t)=8e一20‘+30sin(100~t+rt／3)+6sin(200rrt+rt／4)+
15sin(300~t+rt／6)+5sin(40Orrt+rt／3)+10sin(500~t+rt／4)；
仿真结果如下表2：
116 华东交通大学学报 2006正
表2 含较小衰减值流分■仿真结果表
计算后的仿真数值波形如图5
0 0 02 0 04 0 06 0．∞ 01 0120．140 16 0．18 0 2
0 0．02 0．04 0 06 0．∞ 0 1 0．120 14 0 16 0．18 0．2
图5b 改进算法1仿真波形
5 全波傅氏算法小结
全波富氏算法能滤除所有的整次谐波分量，且稳定性
好，但其数据窗较长，所以其响应速度较慢．通过上面的仿真
结果，我们可以得出以下结论：
1)对照同一故障波形进行分析，可以看出：2种改进算
法所算结果都比较传统傅氏算法要精确．
2)在故障波形谐波含量都相同的情况下，衰减直流分
量的初始值越小，衰减时间常数越大时，衰减非周期分量对
基波以及各次谐波的影响越小．
3)笔者将采样点数Ⅳ从16提高到32后，3种算法误差
均有一定程度的减小．如果进一步提高采样率到64点／N或
128点／N时，对提高计算精度作用不大，而计算时间相应增
加．因此，将采样点定为32点／周对减少误差有益．
虽然改进算法总体要比传统算法精确，但都还存在一个
无法避免的计算误差，那就是所取数据窗内的正常数据和故
障数据的分辨问题．为了全部使用故障后的采样值，往往取
i≥N／2，i表示从故障起始时刻开始第i个采样点．本文中
是通过对改进算法中P的调整，模拟故障发生后，起始采样
点的位置．理论上如果有充足的判据是可以的，但无疑增加
了保护计算的时延和难度，而且跳过的半个周期采样值不予
计算，这肯定会给故障时刻电流的计算带来一定的误差．因
此，这个问题还有待进一步的研究．

‘捌’ c++编程对于递归函数的使用 应用于背包问题

#include <iostream>
using namespace std;
int list1[10];

//insersorrt function
void sorrt(int list[],int size)
{
for(int i=0;i<size;i++)
{
int max=list[i];
int k;
for(k=i-1;k>=0&&list[k]>max;k--)
{
list[k+1]=list[k];
}
list[k+1]=max;
}
}

void fun(int x,int y,int z,int list[],int m)
{
if(z==m)
{
for(int i=0;i<y;i++)
cout<<list1[i]<<" ";
cout<<endl;
}
else
{
for(x;x<10;x++)
{
if(list[x]<=m-z)
{
list1[y]=list[x];
fun(x+1,y+1,z+list[x],list,m);
}

}
}
}
int main()
{
int list[10];//declare a array

//cin the array in circulation
for(int i=0;i<10;i++)
cin>>list[i];

//sorrt the array in insert sorrtion
sorrt(list,10);

//cin the number you want to funtion
int m;
cin>>m;

//use recursion function to breake up the number m
fun(0,0,0,list,m);

return 0;
}

‘玖’ rrt是什么意思

rrt指快速遍历随机树。

快速遍历随机树(Rapidly-exploring Random Tree，RRT)是一种树形数据存储结构和算法，通过递增的方法建立，并快速减小随机选择点同树的距离。

特点：

RRT 的特点是算法建构简单，并且可以快速遍历空间的未探索区域，而通过手动设定找到实现这种效果的函数却是很难的。同时RRT 可以在基本算法基础上，对空间的搜索加入带有输入参数的控制函数，使算法可以适用于不同约束条件下的路径搜索。

‘拾’ RRT算法中实现避障的程序应该怎么表达

BP 网络的推广能力。在本例中，我们采用两种训练方法，即 L-M 优化算法(trainlm 函数训练后的神经网络对样本数据点实现了“过度匹配”，而经 trainbr