标签：stop start actor 方法 equals 十进制 off 逻辑移位 是什么
最近那谁出的程序媛计划，先不说这个事情是好是坏，这个程序做的是好是坏（坏）...
只是最近微博上，尤其是非CST专业的人，居然有很多人认为入门学编程不需要学习算法....
连程序媛计划的发起人都在微博中说 “不需要数学和英文基础”
而其支持者的态度也是 “入门时不需要学习算法，甚至工作中用到算法的也不多，用到了再学就行”
不得不说这真是一副培训班的忽悠口吻....
入门为什么要学算法？
并不是说不学算法就没法学编程，而是说接触了算法之后，会帮助更好的去思考编程的逻辑，而这个逻辑的培养正是新手学习编程的初期最需要的东西。
（至于工作后不需要算法这个事情就懒得吐槽了，大概是我们对程序员有不同的理解吧）
举个栗子：
计算一个数的平方根，编写一个函数，input一个数字，output这个数字的平方根的近似值
1. 用最接近人类的方法实现：
如果是没有数学基础的人，其想法一般是什么呢？
先取一个小的数字 a，计算 a的平方，如果a的平方小于input数字，则把a加大，
然后循环，直到大于或等于input数字了，则这时的a就是input数字的平方根的近似值
不仅没有考虑精度问题，函数不仅完全没有效率，也会出现很多错误
x = 25 epsilon = 0.01 step = epsilon**2 numGuesses = 0 ans = 0.0 while (abs(ans**2 - x)) >= epsilon and ans <= x: ans += step numGuesses += 1 print(‘numGuesses = ‘ + str(numGuesses)) if abs(ans**2-x) >= epsilon: print(‘Failed on square root of ‘ + str(x)) else: print(str(ans) + ‘ is close to the square root of ‘ + str(x))
在这个方法中，仅仅是求x=25的近似平方根，就会执行49990次，而且精度很低
numGuesses = 49990
4.999 is close to the square root of 25
2. 用稍微clever的方法实现
如果现在你已经有一些“聪明”的想法，或者知道有个算法叫二分法，那么便可以写出聪明的方法
注意，现在你已经不是 “完全不需要算法的状态了”
二分法简单的图示
# 二分法计算平方根 x = 12345 epsilon = 0.01 numGuesses = 0 low = 0.0 high = x ans = (high + low)/2.0 while abs(ans**2 - x) >= epsilon: numGuesses += 1 if ans**2 < x: low = ans else: high = ans ans = (high + low)/2.0 print(‘numGuesses = ‘ + str(numGuesses)) print(str(ans) + ‘ is close to square root of ‘ + str(x))
同样计算25的平方根，只需要计算13次，而且精度更高
numGuesses = 13
5.00030517578 is close to square root of 25
计算12345五位数的平方根，也没有增加多少，只需要26次
numGuesses = 26
111.108076461 is close to square root of 12345
3. 用数学的方法实现
这个时候就开始需要数学了，从这里开始，也变得越来越复杂，效率也变得越来越高
3.1 牛顿-拉夫逊 （Newton & Raphson) 算法
最基础的平方根算法之一
其数学原理为：
用公式表示为：
# Newton-Raphson for square root epsilon = 0.01 y = 12345.0 guess = y/2.0 numGuesses = 0 while abs(guess*guess - y) >= epsilon: numGuesses += 1 guess -= ((guess**2) - y)/(2*guess) # print(guess) print(‘numGuesses = ‘ + str(numGuesses)) print(‘Square root of ‘ + str(y) + ‘ is about ‘ + str(guess))
此时，计算12345五位数的平方根，仅需要9次
numGuesses = 9 Square root of 12345.0 is about 111.108057705
你以为这就结束了？
远远不呢，3.1的方法中，有一个明显的缺陷就是初始值的选择，虽然使用了牛顿法去收敛，但初始值仍然是 y/2.0
那么，如果我们能够一开始就选择一个非常近似的值，就能够大大减少计算的次数，提高运算效率了
3.2 基于泰勒公式的级数逼近（泰勒级数+牛顿法）
微积分中的泰勒级数可以表示为：
符号a表示某个常量，记号f‘、f‘‘和f‘‘‘表示函数f的一阶、二阶和三阶导数，以此类推
这个公式称为泰勒公式，基于这个公式，我们平方根公式的展开式为：
根据该公式我们可以在一定精度内逼近真实值。
在泰勒级数展开中，平方根函数的公式当且仅当参数值位于一个有效范围内时才有效，在该范围内计算趋于收敛。
该范围即是收敛半径，当我们对平方根函数用a=1进行计算时，泰勒级数公式希望x处于范围:$0<x<2$之间。
如果x在收敛半径之外，则展开式中的项会越来越大，泰勒级数离答案也就越来越远。
为了解决该问题，我们可以考虑当待开平方数大于4时以4去除它，最后将得到的数乘以相同次数的2即可。
C参考实现（Github上的方法，原链接似乎失效了）
public double TSqrt() { //设置修正系数 double correction = 1; //因为要对原值进行缩小,因此设置临时值 double tempValue = value; while (tempValue >= 2) { tempValue = tempValue / 4; correction *= 2; } return this.TSqrtIteration(tempValue) * correction; } private double TSqrtIteration(double value) { double sum = 0, coffe = 1, factorial = 1, xpower = 1, term = 1; int i = 0; while (Math.abs(term) > 0.000001) { sum += term; coffe *= (0.5 - i); factorial *= (i + 1); xpower *= (value - 1); term = coffe * xpower / factorial; i++; } return sum; }
再次，你以为这就结束了？
图样图奶衣服
3.3 平方根倒数速算法（卡马克快速平方根算法）（What the FUCK方法）
这个方法实在可怕，完全不明白
其通俗的解释为：
首先接收一个32位带符浮点数，然后将之作为一个32位整数看待，以将其向右进行一次逻辑移位的方式将之取半。
用十六进制“魔术数字” 0x5f3759df 减之，如此即可得对输入的浮点数的平方根倒数的首次近似值；
而后重新将其作为浮点数，以牛顿法计算，求出更精确的近似值。
在计算浮点数的平方根倒数的同一精度的近似值时，此算法比直接使用浮点数除法要快四倍。
在wiki上帝详细解释，认输.jpg：
https://en.wikipedia.org/wiki/Fast_inverse_square_root
float InvSqrt (float x) { float xhalf = 0.5f*x; int i = *(int*)&x; i = 0x5f3759df - (i >> 1); // 计算第一个近似根 x = *(float*)&i; x = x*(1.5f - xhalf*x*x); // 牛顿迭代法 return x; }
对没错只有这么点儿，而且那个 0x5f3759df 是什么玩意儿？
而且它通过某种方法算出了一个与真根非常接近的近似根，因此它只需要使用一次迭代过程就获得了较满意的解。
以下引用链接中对此方法的解释：
http://www.cnblogs.com/vagerent/archive/2007/06/25/794695.html
IEEE标准下，float类型的数据在32位系统上是这样表示的（大体来说就是这样，但省略了很多细节，有兴趣可以GOOGLE）：
bits：31 30 ... 0 31：符号位 30-23：共8位，保存指数（E） 22-0：共23位，保存尾数（M）
所以，32位的浮点数用十进制实数表示就是：M*2^E。
开根然后倒数就是：M^(-1/2)*2^(-E/2)。
现在就十分清晰了。语句i> >1其工作就是将指数除以2，实现2^(E/2)的部分。
而前面用一个常数减去它，目的就是得到M^(1/2)同时反转所有指数的符号。
至于那个0x5f3759df，呃，我只能说，的确是一个超级的Magic Number。
那个Magic Number是可以推导出来的，但我并不打算在这里讨论，因为实在太繁琐了。
简单来说，其原理如下：因为IEEE的浮点数中，尾数M省略了最前面的1，所以实际的尾数是1+M。
如果你在大学上数学课没有打瞌睡的话，那么当你看到(1+M)^(-1/2)这样的形式时，应该会马上联想的到它的泰勒级数展开，而该展开式的第一项就是常数。
下面给出简单的推导过程：
对于实数R>0，假设其在IEEE的浮点表示中， 指数为E，尾数为M，则： R^(-1/2) = (1+M)^(-1/2) * 2^(-E/2) 将(1+M)^(-1/2)按泰勒级数展开，取第一项，得： 原式 = (1-M/2) * 2^(-E/2) = 2^(-E/2) - (M/2) * 2^(-E/2) 如果不考虑指数的符号的话， (M/2)*2^(E/2)正是(R>>1)， 而在IEEE表示中，指数的符号只需简单地加上一个偏移即可， 而式子的前半部分刚好是个常数，所以原式可以转化为： 原式 = C - (M/2)*2^(E/2) = C - (R>>1)，其中C为常数 所以只需要解方程： R^(-1/2) = (1+M)^(-1/2) * 2^(-E/2) = C - (R>>1) 求出令到相对误差最小的C值就可以了
最后，引用链接中的code，对3.1-3.3三种算法进行效率对比
https://segmentfault.com/a/1190000006122223
@Test public void testBabylonian() { for (int i = 0; i < 10000; i++) { Assert.assertEquals(2.166795861438391, squareRoots.Babylonian(), 0.000001); } } @Test public void testTSqrt() { for (int i = 0; i < 10000; i++) { Assert.assertEquals(2.166795861438391, squareRoots.TSqrt(), 0.000001); } } @Test public void testFastInverseSquareRoot() { for (int i = 0; i < 10000; i++) { Assert.assertEquals(2.1667948388864198, squareRoots.FastInverseSquareRoot(), 0.000001); } }
@Test public void benchMark() { //巴比伦算法计时器 long babylonianTimer = 0; //级数逼近算法计时器 long tSqrtTimer = 0; //平方根倒数速算法计时器 long fastInverseSquareRootTimer = 0; //随机数生成器 Random r = new Random(); for (int i = 0; i < 100000; i++) { double value = r.nextDouble() * 1000; SquareRoots squareRoots = new SquareRoots(value); long start, stop; start = System.currentTimeMillis(); squareRoots.Babylonian(); babylonianTimer += (System.currentTimeMillis() - start); start = System.currentTimeMillis(); squareRoots.TSqrt(); tSqrtTimer += (System.currentTimeMillis() - start); start = System.currentTimeMillis(); squareRoots.FastInverseSquareRoot(); fastInverseSquareRootTimer += (System.currentTimeMillis() - start); } System.out.println("巴比伦算法:" + babylonianTimer); System.out.println("级数逼近算法:" + tSqrtTimer); System.out.println("平方根倒数速算法:" + fastInverseSquareRootTimer); }
最后的结论是：
结果为: 巴比伦算法:17 级数逼近算法:34 平方根倒数速算法:7
最最后，附赠一个关于魔法数字 0x5f3759df 的链接（看不懂）
http://blog.jobbole.com/105295/
怎么样？编程很好玩吧？
（不
也许我们工作中大部分的程序员都用不到如此级别的算法，但是说算法完全用不到是不可能的，即使是最最不需要数学的二分法，也是算法了。
而且，在学习编程的时候，研究这些 “聪明” 的方法，或者仅仅是观看，也会享受到编程的乐趣，和逻辑的美。
这对提高兴趣有极大的帮助，总不能一辈子做一个苦逼的初级码农吧。
希望本文能够为初学者提供一个正确学习编程的思路：“ 编程为什么需要研究算法？”
对了，如果你问为什么一个计算平方根，要搞得如此变态？反正电脑的计算速度很强不是吗？
其实方法3.3 最早于计算机图形学的硬件与软件领域有所应用，如SGI和3dfx就曾在产品中应用此算法。
在 3D 图形中，你使用平面法线，长度为 1 的三坐标向量，来表示光线和反射。
你会使用很多平面法线，计算它们时需要对向量进行标准化。
而如何标准化一个向量呢？每个坐标分别除以向量的长度，因此，每个坐标需乘上
计算平方和加法相对开销很小，但计算平方根和除法，就需要很大的开销了。
想想3D图形中，用到这个计算的地方会有多少？当这个开销被放大到非常大时，还使用笨办法，电脑的计算能力还扛得住吗？
标签：stop start actor 方法 equals 十进制 off 逻辑移位 是什么
原文地址：http://www.cnblogs.com/Liubit/p/7669086.html
