3.3 程序變換

power0是有關算法的一個令人滿意的實現,它適用于運算的代價高于函數遞歸調用開銷的情況.本節要推導出一個迭代算法,它執行運算的次數和power0一樣.這里將要做一系列程序變換,這些變換也可以用在其他許多情況中.5 在本書后面的部分,通常將只給出算法的最終版本或幾乎最終版本.
power0包含兩個相同的遞歸調用,它每次只執行其中一個.這使我們可能通過公共子表達式刪除技術來縮小代碼的規模:

template<typename I, typename Op> requires(Integer(I) && BinaryOperation(Op)) Domain(Op) power 1(Domain(Op) a, I n, Op op) 
{ 
//前條件:associative(op)∧n>0
if (n == I(1)) return a;Domain(Op) r = power 1(op(a, a), n / I(2), op);if (n % I(2) != I(0)) r = op(r, a);return r;
}

現在的目標是刪除遞歸調用,為此要做的第一步是把過程變換到尾遞歸形式(tail-recursiveform),其中在過程執行的最后一步是對自身的遞歸調用.完成該變換的一種技術是引入累積變量(accumulation-variableintroduction),用于在不同遞歸調用之間攜帶累積的結果:

template<typename I, typename Op> requires(Integer(I) && BinaryOperation(Op)) Domain(Op) power accumulate 0(Domain(Op) r, Domain(Op) a, I n, Op op) 
{ 
//前條件:associative(op)∧n.0
if (n == I(0)) return r;

5.只有在運算的語義和復雜性已知的情況下,編譯器才會對一些內部類型做類似變換.規范性概念是類型創建者的一個斷言,它保證程序員和編譯器可以安全地執行這些變換.

if (n % I(2) != I(0)) r = op(r, a); 
return power accumulate 0(r, op(a, a), n / I(2), op); }

設r0,a0和n0是r,a和n的原值,下面不變式(recursioninvariant)在每次遞歸調用時都成立:ran=r0an0 0 .這個版本還有另一優點,它不僅計算冪,還能計算乘以一個系數的冪.它也處理了指數為0的情況.但是在指數從1變到0時poweraccumulate0將多做一次平方.增加一種情況就可以消除它:

template<typename I, typename Op> requires(Integer(I) && BinaryOperation(Op)) Domain(Op) power accumulate 1(Domain(Op) r, Domain(Op) a, I n, Op op) 
{ 
//前條件:associative(op)∧n.0
if (n == I(0)) return r; 
if (n == I(1)) return op(r, a); 
if (n % I(2) != I(0)) r = op(r, a); 
return power accumulate 1(r, op(a, a), n / I(2), op); }

增加額外情況導致重復出現的子表達式,也使三個檢測不獨立了.通過仔細分析檢測之間的依賴性和順序,考慮它們的出現頻率,可以給出

template<typename I, typename Op> requires(Integer(I) && BinaryOperation(Op)) Domain(Op) power accumulate 2(Domain(Op) r, Domain(Op) a, I n, Op op) 
{ 
//前條件:associative(op)∧n.0
if (n % I(2) != I(0)) { 
r = op(r, a); 
if (n == I(1)) return r; 
} else if (n == I(0)) return r; return power accumulate 2(r, op(a, a), n / I(2), op); 
}

在一個尾遞歸過程里,如果所有遞歸調用中的過程形參都是對應的實參,它就是一個嚴格尾遞歸的(stricttail-recursive)過程:

template<typename I, typename Op> requires(Integer(I) && BinaryOperation(Op)) Domain(Op) power accumulate 3(Domain(Op) r, Domain(Op) a, I n, Op op) 
{ 
//前條件:associative(op)∧n.0
if (n % I(2) != I(0)) { 
r = op(r, a); 
if (n == I(1)) return r; 
} else if (n == I(0)) return r; 
a = op(a, a); 
n = n / I(2); 
return power accumulate 3(r, a, n, op); }

嚴格尾遞歸過程可以變換為一個迭代過程,方法是把每個遞歸調用代換為一個到過程開始的goto,也可以用一個等價的迭代結構:

template<typename I, typename Op> requires(Integer(I) && BinaryOperation(Op)) Domain(Op) power accumulate 4(Domain(Op) r, Domain(Op) a, I n, Op op) 
{ 
//前條件:associative(op)∧n.0
while (true) { 
if (n % I(2) != I(0)) { 
r = op(r, a); 
if (n == I(1)) return r; } else if (n == I(0)) return r;a = op(a, a);n = n / I(2);
} }

遞歸不變式變成了這里的循環不變式(loopinvariant).如果開始時n>0,在變成0前要先經過1.我們借用這種情況消去對0的檢查并加強前條件(strengthening`javascript
precondition):
template requires(Integer(I) && BinaryOperation(Op))
Domain(Op) power accumulate positive 0(Domain(Op) r, Domain(Op) a, I n, Op op)
{
//前條件:associative(op)∧n>0
while (true) {
if (n % I(2) != I(0)) {r = op(r, a);if (n == I(1)) return r;
}
a = op(a, a);n = n / I(2);
} }

知道了n>0會很有用.在開發組件的過程中經常會發現新的接口情況.現在放松前條件(relaxingprecondition):

template requires(Integer(I) && BinaryOperation(Op)) Domain(Op) power accumulate 5(Domain(Op) r, Domain(Op) a, I n, Op op)

{
//前條件:associative(op)∧n.0
if (n == I(0)) return r;return power accumulate positive 0(r, a, n, op);
}
通過一個簡單的等式,就可以用poweraccumulate實現power:
nn.1
a = aa

這一變換就是消去累積變量(accumulation-variableelimination):

template requires(Integer(I) && BinaryOperation(Op)) Domain(Op) power 2(Domain(Op) a, I n, Op op)
{
//前條件:associative(op)∧n>0
return power accumulate 5(a, a, n -I(1), op);
}

這個算法多做了一些不必要的運算.例如,當n是16時它要執行7次運算,其中只有4次是必要的.當n是奇數時這個算法很好.避免上述問題的方法是反復做a的平方,并不斷將指數折半直至它變成奇數:

template requires(Integer(I) && BinaryOperation(Op)) Domain(Op) power 3(Domain(Op) a, I n, Op op)
{
//前條件:associative(op)∧n>0
while (n % I(2) == I(0)) {a = op(a, a);n = n / I(2);
}
n = n / I(2);if (n == I(0)) return a;
return power accumulate positive 0(a, op(a, a), n, op);
}

練習3.1 請自己確認最后三行代碼是正確的.