ep算法
‘壹’ 阿波罗登月用到了哪些控制、估计等算法
在计算机科学领域，进化计算（Evolutionary Computation）是人工智能（Artificial Intelligence），进一步说是智能计算（Computational Intelligence）中涉及到组合优化问题的一个子域。其算法是受生物进化过程中“优胜劣汰”的自然选择机制和遗传信息的传递规律的影响，通过程序迭代模拟这一过程，把要解决的问题看作环境，在一些可能的解组成的种群中，通过自然演化寻求最优解。进化算法正是借用以上生物进化的规律，通过繁殖、竞争、再繁殖、再竞争，实现优胜劣汰，一步步逼近复杂工程技术问题的最优解。进化计算的主要分支有：遗传算法GA，遗传编程GP、进化策略ES、进化编程EP。
‘贰’ x0=x加2ep有什么意义吗
语句while(abs(x0-x)>ep
如果x0=x+2ep（这个是初值），那么x0-x=2ep>ep，满足while条件
如果x0=x，那么x0-x=0<ep，不满足while条件，直接退出循环
ep就是一个步进值
语句中的x0=x，x=feval()，x0和x的值是发生了变化的
‘叁’ 分解质因数的算法
1.素数表,从小到大去试除,一直到当前质数的平方大于试除后剩下的数.
这样优化后的效率会比较高,至少在long int范围内.
正好刚写的:
for (kindp = 0, i = 0; prime[i] * prime[i] <= y; i ++)
if (y % prime[i] == 0)
{ pp[kindp] = prime[i];
ep[kindp] = 0;/*当前质因数的次数*/
while (y % prime[i] == 0)
{
y /= prime[i];
ep[kindp]++;
}
kindp++;
}
if (y != 1)/*处理最大的一个质数*/
{
kindp++;
ep[kindp]=1;
pp[kindp]=y;
}
下面的是更先进一点的方法,但是要求不高的时候用第一种比较好.
2.Pollard's rho method
3.Pollard's p - 1 method
4.Lenstra's elliptic curve factorization method
5.The quadratic sieve factorization method
‘肆’ 股票：名词：EP、EPS、IPO
呵呵，是不是PE呀？
EP是CD的一种,播放设备亦与普通CD一样,没什么特殊要求。
PE就是PRICE
EARNING
RATIO，中文译为本益比。PE的算法简单，我们只需要把一只股票的股价除以它的每股净利就可得到它的本益比PE。
EPS，也即每股收益。每股收益是指本年净收益与普通股份总数的比值，根据股数取值的不同，有全面摊薄每股收益和加权平均每股收益。全面摊薄每股收益是指计算时取年度末的普通股份总数，理由是新发行的股份一般是溢价发行的，新老股东共同分享公司发行新股前的收益。加权平均每股收益是指计算时股份数用按月对总股数加权计算的数据，理由是由于公司投入的资本和资产不同，收益产生的基础也不同。
IPO就是initial
public
offerings(首次公开发行股票)的简称。首次公开招股是指一家私人企业第一次将它的股份向公众出售。通常，上市公司的股份是根据向相应证券会出具的招股书或登记声明中约定的条款通过经纪商或做市商进行销售。一般来说，一旦首次公开上市完成后，这家公司就可以申请到证券交易所或报价系统挂牌交易。
‘伍’ 在C语言算法中有这样2句，请问一下第2句什么意思谢谢 typedef int ET; typedef ET * Ep;谢谢
将ET作为int的同等意义，这样你在定义变量时直接用ET而不用int。后面是把Ep与指向ET的指针型对应起来，因为ET为int，所以Ep就是int*，整数型指针。这种用法是用在定义诸如复杂的类型时简化代码用的。
‘陆’ 阶层型进化算法中EP层的操作过程是什么
（1） Initialization—GA层，EP层的个体被生成。
（2） EP-Mutation（EP层的遗传操作器）—生成新的候补解个体。
（3） EP-Evaluation—对EP层的各个体的适应度进行评价
（4） EP-Selection—下一代的EP层个体被选择。
（5） Transfer-Configuration—由EP层向GA层传送适应度号的个体。
‘柒’ maya中的 CP curve和EP curve区别
create菜单中的EP曲线和CV曲线，都是建立曲线从结果上没有区别，但是是算法的区别，EP是计算建立点的位置，CV是计算两点间的光滑级别；
EP的每个点包含2个CV的值，每条曲线至少有4个CV值组成；
真正意义的解释很简单的,就是说N曲线有两种点一种就是CV点 .一种就是控制点,在我们编辑的时候多用CV点,所以又叫编辑点,创建曲线的时候一种就是直接通过编辑点来创建(CV点),一种就是用控制点来创建(EP点),你可以用EP创建结束,右键看看就知道了,你点了几次就有几个控制点!
‘捌’ 穿越火线AK47骑士EP增加20%啥意思
一看你提的这个问题就是新手，官方对于特殊道具都会有特殊的EP增加，先来介绍下EP的意思吧，EP就是指的是经验值，就是你的级别，例如一般从士官开始少尉、中尉、上尉、大尉、少校、中校、上校、大校、少将、中将、上将、大将等，目前穿越火线（cf）中，我见到过最高级别是大将，这些级别都是通过EP来界定的，我目前游戏中是大校经验值就上亿了。所以他是用来增加经验值和升级用的。因为大家都比较在乎级别，一般级别太低，别人不跟你一伙。
EP增加20%的算法，就是你在打完一局所获得的经验值再加上你的经验值乘以0.2，所以奖励比例是很高的。需多玩家都是喜欢购买有EP增加的枪，或者道具，以及会员等等。有助于级别的提升。当然，如果心态好，不在乎级别，以及经验值，你可以完全忽略掉。就当打发时间玩，可以忽略。
穿越火线（cf）中，还有很多武器及道具经验值加成的，例如经验卡、会员、帽子、官方的活动、面具、水壶等等都加经验，可以使你快速的成为大将，相当于你的一局游戏，比得上别人打一中午的，所以经验值加成还是很明显的。还有一种方法升级特别的快，那就是，官方一般会在星期六、星期天以及国家法定节日的时候，或者腾讯的特殊日你，都会有好几倍经验值的增加，可以在这段时间玩个通宵，相信你一年就是大将了。
‘玖’ 文本比较有哪些算法
用java比较两个文本文件的不同
RangeDifferencer
public class RangeDifferencer {
private static final RangeDifference[] EMPTY_RESULT= new RangeDifference[0];
/* (non Javadoc)
* Cannot be instantiated!
*/
private RangeDifferencer() {
// nothing to do
}
/**
* Finds the differences between two <code>IRangeComparator</code>s.
* The differences are returned as an array of <code>RangeDifference</code>s.
* If no differences are detected an empty array is returned.
*
* @param left the left range comparator
* @param right the right range comparator
* @return an array of range differences, or an empty array if no differences were found
*/
public static RangeDifference[] findDifferences(IRangeComparator left, IRangeComparator right) {
int rightSize= right.getRangeCount();
int leftSize= left.getRangeCount();
//
// Differences matrix:
// only the last d of each diagonal is stored, i.e., lastDiagonal[k] = row of d
//
int diagLen= 2 * Math.max(rightSize, leftSize); // bound on the size of edit script
int maxDiagonal= diagLen;
int lastDiagonal[]= new int[diagLen + 1]; // the row containing the last d
// on diagonal k (lastDiagonal[k] = row)
int origin= diagLen / 2; // origin of diagonal 0
// script corresponding to d[k]
LinkedRangeDifference script[]= new LinkedRangeDifference[diagLen + 1];
int row, col;
// find common prefix
for (row= 0; row < rightSize && row < leftSize && rangesEqual(right, row, left, row) == true;)
row++;
lastDiagonal[origin]= row;
script[origin]= null;
int lower= (row == rightSize) ? origin + 1 : origin - 1;
int upper= (row == leftSize) ? origin - 1 : origin + 1;
if (lower > upper)
return EMPTY_RESULT;
//System.out.println("findDifferences: " + maxDiagonal + " " + lower + " " + upper);
// for each value of the edit distance
for (int d= 1; d <= maxDiagonal; ++d) { // d is the current edit distance
if (right.skipRangeComparison(d, maxDiagonal, left))
return EMPTY_RESULT; // should be something we already found
// for each relevant diagonal (-d, -d+2 ..., d-2, d)
for (int k= lower; k <= upper; k += 2) { // k is the current diagonal
LinkedRangeDifference edit;
if (k == origin - d || k != origin + d && lastDiagonal[k + 1] >= lastDiagonal[k - 1]) {
//
// move down
//
row= lastDiagonal[k + 1] + 1;
edit= new LinkedRangeDifference(script[k + 1], LinkedRangeDifference.DELETE);
} else {
//
// move right
//
row= lastDiagonal[k - 1];
edit= new LinkedRangeDifference(script[k - 1], LinkedRangeDifference.INSERT);
}
col= row + k - origin;
edit.fRightStart= row;
edit.fLeftStart= col;
//Assert.isTrue(k >= 0 && k <= maxDiagonal);
script[k]= edit;
// slide down the diagonal as far as possible
while (row < rightSize && col < leftSize && rangesEqual(right, row, left, col) == true) {
++row;
++col;
}
//Assert.isTrue(k >= 0 && k <= maxDiagonal); // Unreasonable value for diagonal index
lastDiagonal[k]= row;
if (row == rightSize && col == leftSize) {
//showScript(script[k], right, left);
return createDifferencesRanges(script[k]);
}
if (row == rightSize)
lower= k + 2;
if (col == leftSize)
upper= k - 2;
}
--lower;
++upper;
}
// too many differences
//Assert.isTrue(false);
return null;
}
/**
* Finds the differences among two <code>IRangeComparator</code>s.
* In contrast to <code>findDifferences</code>, the result
* contains <code>RangeDifference</code> elements for non-differing ranges too.
*
* @param left the left range comparator
* @param right the right range comparator
* @return an array of range differences
*/
public static RangeDifference[] findRanges(IRangeComparator left, IRangeComparator right) {
RangeDifference[] in= findDifferences(left, right);
List out= new ArrayList();
RangeDifference rd;
int mstart= 0;
int ystart= 0;
for (int i= 0; i < in.length; i++) {
RangeDifference es= in[i];
rd= new RangeDifference(RangeDifference.NOCHANGE, mstart, es.rightStart() - mstart, ystart, es.leftStart() - ystart);
if (rd.maxLength() != 0)
out.add(rd);
out.add(es);
mstart= es.rightEnd();
ystart= es.leftEnd();
}
rd= new RangeDifference(RangeDifference.NOCHANGE, mstart, right.getRangeCount() - mstart, ystart, left.getRangeCount() - ystart);
if (rd.maxLength() > 0)
out.add(rd);
return (RangeDifference[]) out.toArray(EMPTY_RESULT);
}
//---- private methods
/*
* Creates a Vector of DifferencesRanges out of the LinkedRangeDifference.
* It coalesces adjacent changes.
* In addition, indices are changed such that the ranges are 1) open, i.e,
* the end of the range is not included, and 2) are zero based.
*/
private static RangeDifference[] createDifferencesRanges(LinkedRangeDifference start) {
LinkedRangeDifference ep= reverseDifferences(start);
ArrayList result= new ArrayList();
RangeDifference es= null;
while (ep != null) {
es= new RangeDifference(RangeDifference.CHANGE);
if (ep.isInsert()) {
es.fRightStart= ep.fRightStart + 1;
es.fLeftStart= ep.fLeftStart;
RangeDifference b= ep;
do {
ep= ep.getNext();
es.fLeftLength++;
} while (ep != null && ep.isInsert() && ep.fRightStart == b.fRightStart);
} else {
es.fRightStart= ep.fRightStart;
es.fLeftStart= ep.fLeftStart;
RangeDifference a= ep;
//
// deleted lines
//
do {
a= ep;
ep= ep.getNext();
es.fRightLength++;
} while (ep != null && ep.isDelete() && ep.fRightStart == a.fRightStart + 1);
boolean change= (ep != null && ep.isInsert() && ep.fRightStart == a.fRightStart);
if (change) {
RangeDifference b= ep;
//
// replacement lines
//
do {
ep= ep.getNext();
es.fLeftLength++;
} while (ep != null && ep.isInsert() && ep.fRightStart == b.fRightStart);
} else {
es.fLeftLength= 0;
}
es.fLeftStart++; // meaning of range changes from "insert after", to "replace with"
}
//
// the script commands are 1 based, subtract one to make them zero based
//
es.fRightStart--;
es.fLeftStart--;
result.add(es);
}
return (RangeDifference[]) result.toArray(EMPTY_RESULT);
}
/*
* Tests if two ranges are equal
*/
private static boolean rangesEqual(IRangeComparator a, int ai, IRangeComparator b, int bi) {
return a.rangesEqual(ai, b, bi);
}
/*
* Tests whether <code>right</code> and <code>left</code> changed in the same way
*/
private static boolean rangeSpansEqual(IRangeComparator right, int rightStart, int rightLen, IRangeComparator left, int leftStart, int leftLen) {
if (rightLen == leftLen) {
int i= 0;
for (i= 0; i < rightLen; i++) {
if (!rangesEqual(right, rightStart + i, left, leftStart + i))
break;
}
if (i == rightLen)
return true;
}
return false;
}
/*
* Reverses the range differences
*/
private static LinkedRangeDifference reverseDifferences(LinkedRangeDifference start) {
LinkedRangeDifference ep, behind, ahead;
ahead= start;
ep= null;
while (ahead != null) {
behind= ep;
ep= ahead;
ahead= ahead.getNext();
ep.setNext(behind);
}
return ep;
}
}
下面是一段关于如何使用这些类的简单的测试代码
public class RangeDifferencerTest extends TestCase {
InputStream left = null;
InputStream right = null;
/**
* @see junit.framework.TestCase#setUp()
*/
protected void setUp() throws Exception {
String file1 = "d:/temp/1.txt";
String file2 = "d:/temp/2.txt";
left = new FileInputStream(new File(file1));
right = new FileInputStream(new File(file2));
super.setUp();
}
/**
* @see junit.framework.TestCase#tearDown()
*/
protected void tearDown() throws Exception {
left.close();
right.close();
super.tearDown();
}
public static void main(String[] args) {
}
/*
* Test method for 'com.greatroad.smbnm.compare.RangeDifferencer.findDifferences(IRangeComparator, IRangeComparator)'
*/
public void testFindDifferences() {
try {
RangeDifference[] rds = RangeDifferencer.findRanges(new LineComparator(left,"GBK"),new LineComparator(right,"GBK"));
if(rds != null ){
for(int i=0; i<rds.length; i++){
RangeDifference rd = rds[i];
int length = rd.leftLength();
System.out.println(
"kind = "+rd.kind()
+",left["+rd.leftStart()+"-"+rd.leftEnd()
+"],right["+rd.rightStart()+"-"+rd.rightEnd()+"]");
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
‘拾’ 椭圆曲线加密算法
这需要自己设计，如果明文空间为M，则需要构造一个映射，将M中的元素（一般为二进制序列）映射到椭圆曲线上的点。
一种可能的做法是：将M转化为十进制整数m，然后令椭圆曲线中点的横坐标为m，根据曲线方程计算出纵坐标，便得到了一个点。