2. 程式人生 > >三角函式計算，Cordic 演算法入門

三角函式計算，Cordic 演算法入門

阿新 • • 發佈：2019-01-01

三角函式計算，Cordic 演算法入門

三角函式的計算是個複雜的主題，有計算機之前，人們通常通過查詢三角函式表來計算任意角度的三角函式的值。這種表格在人們剛剛產生三角函式的概念的時候就已經有了，它們通常是通過從已知值（比如sin(π/2)=1）開始並重復應用半形和和差公式而生成。

現在有了計算機，三角函式表便推出了歷史的舞臺。但是像我這樣的喜歡刨根問底的人，不禁要問計算機又是如何計算三角函式值的呢。最容易想到的辦法就是利用級數展開，比如泰勒級數來逼近三角函式，只要項數取得足夠多就能以任意的精度來逼近函式值。除了泰勒級數逼近之外，還有其他許多的逼近方法，比如切比雪夫逼近、最佳一致逼近和Padé

逼近等。

所有這些逼近方法本質上都是用多項式函式來近似我們要計算的三角函式，計算過程中必然要涉及到大量的浮點運算。在缺乏硬體乘法器的簡單裝置上（比如沒有浮點運算單元的微控制器），用這些方法來計算三角函式會非常的費時。為了解決這個問題，J. Volder於1959年提出了一種快速演算法，稱之為CORDIC(COordinate Rotation DIgital Computer) 演算法，這個演算法只利用移位和加減運算，就能計算常用三角函式值，如Sin，Cos，Sinh，Cosh等函式。 J. Walther在1974年在這種演算法的基礎上進一步改進，使其可以計算出多種超越函式，更大的擴充套件了Cordic 演算法的應用

。因為Cordic 演算法只用了移位和加法，很容易用純硬體來實現，因此我們常能在FPGA運算平臺上見到它的身影。不過，大多數的軟體程式設計師們都沒有聽說過這種演算法，也更不會主動的去用這種演算法。其實，在嵌入式軟體開發，尤其是在沒有浮點運算指令的嵌入式平臺（比如定點型DSP）上做開發時，還是會遇上可以用到Cordic 演算法的情況的，所以掌握基本的Cordic演算法還是有用的。

從二分查詢法說起

先從一個例子說起，知道平面上一點在直角座標系下的座標（X,Y）=（100，200），如何求的在極座標系下的座標（ρ,θ）。用計算器計算一下可知答案是（223.61，63.435）。


圖 1 直角座標系到極座標系的轉換

為了突出重點，這裡我們只討論X和Y都為正數的情況。這時θ=atan(y/x)。求θ的過程也就是求atan 函式的過程。Cordic演算法採用的想法很直接，將（X，Y）旋轉一定的度數，如果旋轉完縱座標變為了0，那麼旋轉的度數就是θ。座標旋轉的公式可能大家都忘了，這裡把公式列出了。設（x,y）是原始座標點，將其以原點為中心，順時針旋轉θ之後的座標記為（x’,y’）,則有如下公式：

也可以寫為矩陣形式：

如何旋轉呢，可以借鑑二分查詢法的思想。我們知道θ的範圍是0到90度。那麼就先旋轉45度試試。

旋轉之後縱座標為70.71，還是大於0，說明旋轉的度數不夠，接著再旋轉22.5度（45度的一半）。

這時總共旋轉了45+22.5=67.5度。結果縱座標變為了負數，說明θ<67.5度，這時就要往回轉，還是二分查詢法的思想，這次轉11.25度。

這時總共旋轉了45+22.5-11.25=56.25度。又轉過頭了，接著旋轉，這次順時針轉5.625度。

這時總共旋轉了45+22.5-11.25+5.625=61.875度。這時縱座標已經很接近0了。我們只是說明演算法的思想，因此就不接著往下計算了。計算到這裡我們給的答案是 61.875±5.625。二分查詢法本質上查詢的是一個區間，因此我們給出的是θ值的一個範圍。同時，座標到原點的距離ρ也求出來了，ρ=223.52。與標準答案比較一下計算的結果還是可以的。旋轉的過程圖示如下。

可能有讀者會問，計算中用到了 sin 函式和 cos 函式，這些值又是怎麼計算呢。很簡單，我們只用到很少的幾個特殊點的sin 函式和 cos 函式的值，提前計算好存起來，用時查表。

下面給出上面方法的C 語言實現。

#include <stdio.h>
#include <stdlib.h>

double my_atan2(double x, double y);
int main(void)
{
    double z = my_atan2(100.0, 200.0);
    printf("\n z = %f \n", z);

    return 0;
}


double my_atan2(double x, double y)
{
    const double sine[] = {0.7071067811865,0.3826834323651,0.1950903220161,0.09801714032956,
0.04906767432742,0.02454122852291,0.01227153828572,0.006135884649154,0.003067956762966
,0.001533980186285,7.669903187427045e-4,3.834951875713956e-4,1.917475973107033e-4,
9.587379909597735e-5,4.793689960306688e-5,2.396844980841822e-5
                         };

    const double cosine[] = {0.7071067811865,0.9238795325113,0.9807852804032,0.9951847266722,
0.9987954562052,0.9996988186962,0.9999247018391,0.9999811752826,0.9999952938096,
0.9999988234517,0.9999997058629,0.9999999264657,0.9999999816164,0.9999999954041,
0.999999998851,0.9999999997128
                           };


    int i = 0;
    double x_new, y_new;
    double angleSum = 0.0;
    double angle = 45.0;

    for(i = 0; i < 15; i++)
    {
        if(y > 0)
        {
            x_new = x * cosine[i] + y * sine[i];
            y_new = y * cosine[i] - x * sine[i];
            x = x_new;
            y = y_new;
            angleSum += angle;
        }
        else
        {
            x_new = x * cosine[i] - y * sine[i];
            y_new = y * cosine[i] + x * sine[i];
            x = x_new;
            y = y_new;
            angleSum -= angle;
        }
        printf("Debug: i = %d angleSum = %f, angle = %f\n", i, angleSum, angle);
        angle /= 2;
    }
    return angleSum;
}

程式執行的輸出結果如下：

Debug: i = 0 angleSum = 45.000000, angle = 45.000000
Debug: i = 1 angleSum = 67.500000, angle = 22.500000
Debug: i = 2 angleSum = 56.250000, angle = 11.250000
Debug: i = 3 angleSum = 61.875000, angle = 5.625000
Debug: i = 4 angleSum = 64.687500, angle = 2.812500
Debug: i = 5 angleSum = 63.281250, angle = 1.406250
Debug: i = 6 angleSum = 63.984375, angle = 0.703125
Debug: i = 7 angleSum = 63.632813, angle = 0.351563
Debug: i = 8 angleSum = 63.457031, angle = 0.175781
Debug: i = 9 angleSum = 63.369141, angle = 0.087891
Debug: i = 10 angleSum = 63.413086, angle = 0.043945
Debug: i = 11 angleSum = 63.435059, angle = 0.021973
Debug: i = 12 angleSum = 63.424072, angle = 0.010986
Debug: i = 13 angleSum = 63.429565, angle = 0.005493
Debug: i = 14 angleSum = 63.432312, angle = 0.002747

 z = 63.432312

減少乘法運算

現在已經有點 Cordic 演算法的樣子了，但是我們看到沒次迴圈都要計算 4 次浮點數的乘法運算，運算量還是太大了。還需要進一步的改進。改進的切入點當然還是座標變換的過程。我們將座標變換公式變一下形。

可以看出 cos(θ)可以從矩陣運算中提出來。我們可以做的再徹底些，直接把 cos(θ) 給省略掉。

省略cos(θ)後發生了什麼呢，每次旋轉後的新座標點到原點的距離都變長了，放縮的係數是1/cos(θ)。不過沒有關係，我們求的是θ，不關心ρ的改變。這樣的變形非常的簡單，但是每次迴圈的運算量一下就從4次乘法降到了2次乘法了。

還是給出 C 語言的實現：

double my_atan3(double x, double y)
{
    const double tangent[] = {1.0,0.4142135623731,0.1989123673797,0.09849140335716,0.04912684976947,
0.02454862210893,0.01227246237957,0.006136000157623,0.003067971201423,
0.001533981991089,7.669905443430926e-4,3.83495215771441e-4,1.917476008357089e-4,
9.587379953660303e-5,4.79368996581451e-5,2.3968449815303e-5
                         };


    int i = 0;
    double x_new, y_new;
    double angleSum = 0.0;
    double angle = 45.0;

    for(i = 0; i < 15; i++)
    {
        if(y > 0)
        {
            x_new = x + y * tangent[i];
            y_new = y - x * tangent[i];
            x = x_new;
            y = y_new;
            angleSum += angle;
        }
        else
        {
            x_new = x - y * tangent[i];
            y_new = y + x * tangent[i];
            x = x_new;
            y = y_new;
            angleSum -= angle;
        }
        printf("Debug: i = %d angleSum = %f, angle = %f, ρ = %f\n", i, angleSum, angle, hypot(x,y));
        angle /= 2;
    }
    return angleSum;
}

計算的結果是：

Debug: i = 0 angleSum = 45.000000, angle = 45.000000, ρ = 316.227766
Debug: i = 1 angleSum = 67.500000, angle = 22.500000, ρ = 342.282467
Debug: i = 2 angleSum = 56.250000, angle = 11.250000, ρ = 348.988177
Debug: i = 3 angleSum = 61.875000, angle = 5.625000, ρ = 350.676782
Debug: i = 4 angleSum = 64.687500, angle = 2.812500, ρ = 351.099697
Debug: i = 5 angleSum = 63.281250, angle = 1.406250, ρ = 351.205473
Debug: i = 6 angleSum = 63.984375, angle = 0.703125, ρ = 351.231921
Debug: i = 7 angleSum = 63.632813, angle = 0.351563, ρ = 351.238533
Debug: i = 8 angleSum = 63.457031, angle = 0.175781, ρ = 351.240186
Debug: i = 9 angleSum = 63.369141, angle = 0.087891, ρ = 351.240599
Debug: i = 10 angleSum = 63.413086, angle = 0.043945, ρ = 351.240702
Debug: i = 11 angleSum = 63.435059, angle = 0.021973, ρ = 351.240728
Debug: i = 12 angleSum = 63.424072, angle = 0.010986, ρ = 351.240734
Debug: i = 13 angleSum = 63.429565, angle = 0.005493, ρ = 351.240736
Debug: i = 14 angleSum = 63.432312, angle = 0.002747, ρ = 351.240736

 z = 63.432312

消除乘法運算

我們已經成功的將乘法的次數減少了一半，還有沒有可能進一步降低運算量呢？還要從計算式入手。

第一次迴圈時，tan(45)=1，所以第一次迴圈實際上是不需要乘法運算的。第二次運算呢？

Tan(22.5)=0.4142135623731,很不幸，第二次迴圈乘數是個很不整的小數。是否能對其改造一下呢？答案是肯定的。第二次選擇22.5度是因為二分查詢法的查詢效率最高。如果選用個在22.5到45度之間的值，查詢的效率會降低一些。如果稍微降低一點查詢的效率能讓我們有效的減少乘法的次數，使最終的計算速度提高了，那麼這種改進就是值得的。

我們發現tan(26.565051177078)=0.5，如果我們第二次旋轉採用26.565051177078度，那麼乘數變為0.5，如果我們採用定點數運算的話（沒有浮點協處理器時為了加速計算我們會大量的採用定點數演算法）乘以0.5就相當於將乘數右移一位。右移運算是很快的，這樣第二次迴圈中的乘法運算也被消除了。

類似的方法，第三次迴圈中不用11.25度，而採用 14.0362434679265 度。

Tan(14.0362434679265)= 1/4

乘數右移兩位就可以了。剩下的都以此類推。

tan(45)= 1
tan(26.565051177078)= 1/2
tan(14.0362434679265)= 1/4
tan(7.1250163489018)= 1/8
tan(3.57633437499735)= 1/16
tan(1.78991060824607)= 1/32
tan(0.8951737102111)= 1/64
tan(0.4476141708606)= 1/128
tan(0.2238105003685)= 1/256

還是給出C語言的實現程式碼，我們採用循序漸進的方法，先給出浮點數的實現（因為用到了浮點數，所以並沒有減少乘法運算量，查詢的效率也比二分查詢法要低，理論上說這個演算法實現很低效。不過這個程式碼的目的在於給出演算法實現的示意性說明，還是有意義的）。

double my_atan4(double x, double y)
{
    const double tangent[] = {1.0, 1 / 2.0, 1 / 4.0, 1 / 8.0, 1 / 16.0,
                              1 / 32.0, 1 / 64.0, 1 / 128.0, 1 / 256.0, 1 / 512.0,
                              1 / 1024.0, 1 / 2048.0, 1 / 4096.0, 1 / 8192.0, 1 / 16384.0
                             };
    const double angle[] = {45.0, 26.565051177078, 14.0362434679265, 7.1250163489018, 3.57633437499735,
                            1.78991060824607, 0.8951737102111, 0.4476141708606, 0.2238105003685, 0.1119056770662,
                            0.0559528918938, 0.027976452617, 0.01398822714227, 0.006994113675353, 0.003497056850704
                           };

    int i = 0;
    double x_new, y_new;
    double angleSum = 0.0;

    for(i = 0; i < 15; i++)
    {
        if(y > 0)
        {
            x_new = x + y * tangent[i];
            y_new = y - x * tangent[i];
            x = x_new;
            y = y_new;
            angleSum += angle[i];
        }
        else
        {
            x_new = x - y * tangent[i];
            y_new = y + x * tangent[i];
            x = x_new;
            y = y_new;
            angleSum -= angle[i];
        }
        printf("Debug: i = %d angleSum = %f, angle = %f, ρ = %f\n", i, angleSum, angle[i], hypot(x, y));
    }
    return angleSum;
}
程式執行的輸出結果如下：
Debug: i = 0 angleSum = 45.000000, angle = 45.000000, ρ = 316.227766
Debug: i = 1 angleSum = 71.565051, angle = 26.565051, ρ = 353.553391
Debug: i = 2 angleSum = 57.528808, angle = 14.036243, ρ = 364.434493
Debug: i = 3 angleSum = 64.653824, angle = 7.125016, ρ = 367.270602
Debug: i = 4 angleSum = 61.077490, angle = 3.576334, ρ = 367.987229
Debug: i = 5 angleSum = 62.867400, angle = 1.789911, ρ = 368.166866
Debug: i = 6 angleSum = 63.762574, angle = 0.895174, ρ = 368.211805
Debug: i = 7 angleSum = 63.314960, angle = 0.447614, ρ = 368.223042
Debug: i = 8 angleSum = 63.538770, angle = 0.223811, ρ = 368.225852
Debug: i = 9 angleSum = 63.426865, angle = 0.111906, ρ = 368.226554
Debug: i = 10 angleSum = 63.482818, angle = 0.055953, ρ = 368.226729
Debug: i = 11 angleSum = 63.454841, angle = 0.027976, ρ = 368.226773
Debug: i = 12 angleSum = 63.440853, angle = 0.013988, ρ = 368.226784
Debug: i = 13 angleSum = 63.433859, angle = 0.006994, ρ = 368.226787
Debug: i = 14 angleSum = 63.437356, angle = 0.003497, ρ = 368.226788

 z = 63.437356

有了上面的準備，我們可以來討論定點數演算法了。所謂定點數運算，其實就是整數運算。我們用256 表示1度。這樣的話我們就可以精確到1/256=0.00390625 度了，這對於大多數的情況都是足夠精確的了。256 表示1度，那麼45度就是 45*256 = 115200。其他的度數以此類推。

序號

度數

×256

取整

1

45.0

11520

11520

2

26.565051177078

6800.65310133196

6801

3

14.0362434679265

3593.27832778918

3593

4

7.1250163489018

1824.00418531886

1824

5

3.57633437499735

915.541599999322

916

6

1.78991060824607

458.217115710994

458

7

0.8951737102111

229.164469814035

229

8

0.4476141708606

114.589227740302

115

9

0.2238105003685

57.2954880943458

57

10

0.1119056770662

28.647853328949

29

11

0.0559528918938

14.3239403248137

14

12

0.027976452617

7.16197186995294

7

13

0.01398822714227

3.58098614841984

4

14

0.006994113675353

1.79049310089035

2

15

0.003497056850704

0.8952465537802

1

C 程式碼如下：

int my_atan5(int x, int y)
{
    const int angle[] = {11520, 6801, 3593, 1824, 916, 458, 229, 115, 57, 29, 14, 7, 4, 2, 1};

    int i = 0;
    int x_new, y_new;
    int angleSum = 0;

    x *= 1024;// 將 X Y 放大一些，結果會更準確
    y *= 1024;

    for(i = 0; i < 15; i++)
    {
        if(y > 0)
        {
            x_new = x + (y >> i);
            y_new = y - (x >> i);
            x = x_new;
            y = y_new;
            angleSum += angle[i];
        }
        else
        {
            x_new = x - (y >> i);
            y_new = y + (x >> i);
            x = x_new;
            y = y_new;
            angleSum -= angle[i];
        }
        printf("Debug: i = %d angleSum = %d, angle = %d\n", i, angleSum, angle[i]);
    }
    return angleSum;
}

計算結果如下：

Debug: i = 0 angleSum = 11520, angle = 11520
Debug: i = 1 angleSum = 18321, angle = 6801
Debug: i = 2 angleSum = 14728, angle = 3593
Debug: i = 3 angleSum = 16552, angle = 1824
Debug: i = 4 angleSum = 15636, angle = 916
Debug: i = 5 angleSum = 16094, angle = 458
Debug: i = 6 angleSum = 16323, angle = 229
Debug: i = 7 angleSum = 16208, angle = 115
Debug: i = 8 angleSum = 16265, angle = 57
Debug: i = 9 angleSum = 16236, angle = 29
Debug: i = 10 angleSum = 16250, angle = 14
Debug: i = 11 angleSum = 16243, angle = 7
Debug: i = 12 angleSum = 16239, angle = 4
Debug: i = 13 angleSum = 16237, angle = 2
Debug: i = 14 angleSum = 16238, angle = 1

 z = 16238

16238/256=63.4296875度，精確的結果是63.4349499度，兩個結果的差為0.00526，還是很精確的。

到這裡 CORDIC 演算法的最核心的思想就介紹完了。當然，這裡介紹的只是CORDIC演算法最基本的內容，實際上，利用CORDIC 演算法不光可以計算 atan 函式，其他的像 Sin，Cos，Sinh，Cosh 等一系列的函式都可以計算，不過那些都不在本文的討論範圍內了。另外，每次旋轉時到原點的距離都會發生變化，而這個變化是確定的，因此可以在迴圈運算結束後以此補償回來，這樣的話我們就同時將（ρ,θ）都計算出來了。

想進一步深入學習的可以閱讀 John Stephen Walther 於2000年發表在 Journal of VLSI signal processing systems for signal, image and video technology上的綜述性文章“The Story of Unified Cordic”。


相關推薦

三角函式計算，Cordic 演算法入門

三角函式計算，Cordic 演算法入門 三角函式的計算是個複雜的主題，有計算機之前，人們通常通過查詢三角函式表來計算任意角度的三角函式的值。這種表格在人們剛剛產生三角函式的概念的時候就已經有了，它們通常是通過從已知值（比如sin(π/2)=1）開始並重復應用半形和和差公式

cordic演算法計算sin等三角函式值

查了一下計算機如何計算sin等三角函式，除了泰勒級數，查到了一個叫cordic演算法的 查到了一篇講解很細緻的部落格: 《三角函式計算，Cordic演算法入門》   http://blog.csdn.net/liyuanbhu/article/details/8458769

【轉載】最全的計算廣告資料，廣告演算法工程師入門

在廣告這樣的參與者可以針對同一個標的物不斷調整出價的拍賣環境中,通過聰明的定價策略,完全可能為整個市場創造更高的收益以及其他好處。 拍賣方式 分配規則 支付方式 是否知道別人的出價 應用場景 英式拍賣(Open) 競買者逐步加價, 直到最後只剩下一個投標人為止 出價最高者得

利用CORDIC演算法計算三角函式

這裡主要先介紹如何利用CORDIC演算法計算固定角度$\phi$的$cos(\phi)$、$sin(\phi)$值。參考了這兩篇文章[[1]](https://mp.weixin.qq.com/s/c4oro0bOhdDUmBt0yyLpTA)、[[2]](https://blog.csdn.net/qq_3

Python演算法入門——第2章 1，佇列

有一串經過加密的數字需要解密。解密規則是這樣的：首先將第 1 個數刪除，緊接著將第 2 個數放到這串數的末尾，再將第 3 個數刪除並將第 4 個數放到這串數的末尾，再將第 5 個數刪除……直到剩下最後一個數，將最後一個數也刪除。   class Solution(): '''

Python演算法入門——第1章 2，氣泡排序

上一篇文章已經說過，桶排序會極大地浪費資源，因此需要用一種更簡單的排序方式來完成：氣泡排序。其原理是1.從第一個數字開始，與第二個數進行比較，如果小於第二個數（按從大到小排序），則將其交換數值；2.接著，第二個數與第三個數比較，重複此步驟，直至完成與最後一個數的比較。這樣，第一個數就到了它應該呆的地

Python演算法入門——第1章 1，桶排序

假如你有7個數需要排序，最大的數為100，那麼你就需要101個桶，桶的編號為0-100。你的數列中的數是多少，就往對應的桶裡面加一，最後按照順序列印桶的編號即可。但此排序方式浪費資源極大，資料量大的時候不建議使用，本文只是介紹最基本的演算法實現原理，作為入門使用。 class Solution(

Python演算法入門——第1章 1，桶排序

假如你有7個數需要排序，最大的數為100，那麼你就需要101個桶，桶的編號為0-100。你的數列中的數是多少，就往對應的桶裡面加一，最後按照順序列印桶的編號即可。但此排序方式浪費資源極大，資料量大的時候不建議使用，本文只是介紹最基本的演算法實現原理，作為入門使用。 clas

基於求導的快速exp()演算法，exp()快速計算，exp導數演算法，exp函式C語言實現

基於求導的快速exp()演算法 如果需要得到exp(x)的連續數列，那麼常規方法需要一個一個數的運算，運算量會非常大。此時可以使用以下方法，得到連續的exp(x)數列。 我們知道的導數等於本身。設                                    

資料探勘--協同過濾演算法，基於集合交集相似性計算的mapreduce演算法設計

第一個過程程的mapreduce函式： import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.Iterator; import j

樓梯上有n階臺階，上樓時可以一步上1階，也可以一步上兩階，編寫演算法計算共有多少種不同的上樓梯的方法。

數學模型：此問題如果按照習慣，從前向後思考，也就是從第一階開始，考慮怎麼樣到第二階、第三節、第四階……則很難找到問題的規律；而反過來先思考“到第n階有哪幾種情況”，答案就簡單了，只有兩種情況； （1）

走在前往架構師的路上（專注於分散式計算，大資料，資料探勘，機器學習演算法等領域的研究）

新書<<深度剖析Hadoop HDFS>>釋出上市，此書源自於筆者部落格，重新經過整理，完善而成，此書的定位並不是一本純原始碼分析的書籍，其中有許多筆者在工作和學習中對於HDFS的一些有趣的看法和理解。 連結： 淘寶京東 (adsbygoog

[演算法入門]快速排序非遞迴方法（Java實現），大家一起來找茬啊～

基礎 總結一下，快速排序的步驟： 1、找到一個key值（就是陣列第一個值），先從右到左找，找到一個比它小的值，記錄下標。 2、然後從左往右找，找到一個比它大的值，記錄下標。 3、交換找到的兩個數

轉置矩陣的分塊並行乘法（C語言實現），計算矩陣C[rawn][rawn]=A[rawm][rawn]'*B[rawm][rawn]，子塊大小為S*T，其演算法實現原理參加本程式碼的附件。

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <math.h> #define rawm 4 #define rawn 4 #defi

演算法入門--堆排序（最大堆，從小到大排序）

#include <stdio.h> #include <stdlib.h> /*由於不會動態獲得當前堆的元素數量heap_size，所以暫時用傳參的方法，但是當多次執行後發現 為了防止錯誤應該把heap_size設定為全域性變數，主函式初始化後，讓

cordic演算法計算sin和cos

%根據cordic演算法計算sin&cos %共迭代16次 %輸入:-pi~pi %輸出:sin&cos function [s,c]=cordic(theta) tanx=0:15; tanx=2.^tanx; tanx=1./tanx; atanx=at

雲端計算部署模型和服務模式，雲行業入門的第一步

       雲端計算、大資料、物聯網、人工智慧，可謂是最近幾年大熱之詞，熱度一浪高過一浪，今天主要介紹的是雲端計算，私有云、公有云、混合雲、社群雲，大家都耳熟能詳，卻不知道屬於什麼，這篇文章以雲端計算部署模型和服務模式為主題，為大家介紹。        雲端計算的4種部署模

CF 86D Powerful array 分塊演算法入門，n*sqrt(n)

簡介：分塊演算法主要是把區間劃分成sqrt(n)塊，從而降低暴力的複雜度， 其實這算是一種優化的暴力吧，複雜度O(n*sqrt(n)) 題意：給定一個數列：a[i]    (1<= i

城市計算，大數據的用武之地！

專訪 數據監測 可能 aliyun 應用 楊致遠 art 決策者 相互 上圖：反映北京出租車軌跡數據分布的熱度圖，微軟亞洲研究院供圖 近年來，城市計算（Urban Computing）逐漸走入公眾視野，並且越來越受到社會關註。這是一個以計算機科學為基礎、涉及了多項其

雲計算，SDN，虛擬化三者關系

雲計算、虛擬化、sdn　　雲計算是一種按需分配、按使用量收費的使用模式，提供了一個可配置的資源共享池，用戶可以通過網絡訪問，獲取存儲空間、網絡帶寬、服務器、應用軟件等等服務。　　 NFV，即網絡功能虛擬化，Network Function Virtualization。通過使用x86等通用性硬件以及虛擬化技術