本文是关于在 Solidity 中进行数学运算的系列文章中的第四篇。这次的主题是：复利。

介绍

在我们之前的文章中，我们讨论了百分比以及它们是如何在 Solidity 中计算的。在金融数学中，百分比通常与贷款和存款支付的利息有关。在每个时间段结束时，比如一个月或一年，本金的一定百分比将支付给贷方或存款持有人。这种模式称为单利，每期支付的百分比称为定期利率。

在计算机程序中，通常使用利率而不是利率。例如，对于 3% 的利率，该比率为 0.03。因此，一个时期的利息支付金额可以计算为利息率乘以本金金额，并且从上一篇文章中我们已经知道如何在 Solidity 中有效且准确地执行此操作。

单利模式很简单，但如果利息不是立即支付给贷方或存款持有人，而是加到本金上，事情就会变得更加复杂。在这种情况下，过去期间累积的利息会影响未来收取的利息金额。

在本文中，我们将讨论如何在 Solidity 中实现该模式，该模式的名称为：复利。

定期复利

我们已经知道如何计算单利。计算复利的直接解决方案是在每个时间段结束时计算单利，然后将计算出的利息与本金相加。在高级语言中，例如 JavaScript，它看起来像这样：

principal += ratio * principal; // Do after each time period

我们使用mulDiv上一篇文章中的函数，并假设它ratio是一个定点数，点后有 18 位小数。

上面的代码在大多数情况下都可以工作，但它的+=操作可能会溢出，所以为了使代码安全，我们需要这样修改它：

principal = add (principal, mulDiv (ratio, principal, 10^18));

这种变体可能适合生产，但难以阅读。在本文中，为简单起见，我们将使用普通算术运算，就好像 Solidity 支持分数并且算术运算不会溢出一样。在实际代码中，这些操作应该被适当的函数代替。

一旦我们知道如何计算单个期间的复利，问题就是：

我们如何在每个时间段结束时触发复利？

剧透：我们不应该

与传统应用程序不同，智能合约不能有任何后台活动。合约的字节码仅在交易调用合约时执行，无论是直接调用还是通过另一个智能合约调用。可以依靠第三方服务，如Provable（以前称为 Oraclize）定期调用特定的智能合约，或者可以从经济上激励普通人这样做。

这种方法可行，但有许多缺点。首先，有人必须为汽油付费，所以它不是免费的。其次，必须在每期末计算复利，即使在接下来的时间段内没有人会使用更新后的本金。第三，时间越短，复合越频繁，消耗的gas越多。第四，对于短时间，这种方法是不准确的，因为交易挖掘时间不可预测，并且在网络负载高的时候可能会非常大。

因此，如果在每个周期结束时复利对 Solidity 来说不是一个好主意，那么

我们什么时候应该复利？

剧透：“惰性”复合

与其在每个时间段结束时复利，更好的方法是仅在有人需要获取本金或债务或存款时才复利，并在此时对自复利以来结束的所有时间段执行复利最后一次：

uint currentPeriod = block.timestamp / periodLength;
for (uint period = lastPeriod; period < currentPeriod; period++)
  principal += ratio * principal;
lastPeriod = currentPeriod;

此代码将所有尚未复利的利息添加到本金中，并且每次有人想要访问时都必须执行principal。这种方法被称为“惰性”复利，实际计算会推迟到有人真正需要他们的结果时才进行。

然而，上面显示的“惰性”复合的实现有一个重要问题。实际的 gas 消耗量线性取决于自上次执行复利计算以来经过了多少时间间隔。如果时间段很短，或者上一次复利是很久以前进行的，那么在所有经过的时间段内复利所需的气体量可能会超过区块气体限制，从而有效地使进一步的复利变得不可能。所以问题是：

如何更高效地进行“惰性”复利？

剧透：间隔加倍

首先我们注意到，单个时间段的组合利息可以这样重写：

principal *= 1 + ratio;

对于两个时间间隔，这将是：

principal *= (1 + ratio) * (1 + ratio);

然后我们注意到，(1+ r )²=1+(2 r + r ²)，所以双倍时间间隔的有效利率为 2 r + r ²，其中r是单倍时间间隔的利率。如果我们想要复利的时间间隔数是偶数，我们可以通过将时间间隔持续时间加倍来减半时间间隔数。当时间间隔数为奇数时，我们可以只进行一次复利，从而使剩余的时间间隔数为偶数。这是代码：

function compound (uint principal, uint ratio, uint n)
public pure returns (uint) {
  while (n > 0) {
    if (n % 2 == 1) {
      principal += principal * ratio;
      n -= 1;
    } else {
      ratio = 2 * ratio + ratio * ratio;
      n /= 2;
    }
  }
  return principal;
}

上面的代码具有对数复杂度，并且在principal和ratio较大时运行良好，因此principal * ratioproduct 具有足够的有效小数位以获得不错的精度。但是，如果principal和ratio很小，上面的代码可能会产生不准确的结果。现在的问题是：

如何提高惰性复利的精度？

剧透：通过平方求幂

在上面显示的代码中，以下单独的代码丢失了精度：

principal += principal * ratio;

这是因为我们假设principal是整数，所以赋值必须舍入计算值。舍入可能会执行多次，舍入误差会累加。

为了解决这个问题，我们可能会注意到，对于 n 个时间间隔，利息可能会像这样复合：

principal *= (1 + ratio) ** n;

如果 Solidity 支持分数，这段代码就可以工作，但只要不支持，我们就需要自己实现求幂。我们使用与上一节中相同的对数复杂度方法，因此代码非常相似：

function pow (uint x, uint n)
public pure returns (uint r) {
  r = 1.0;
  while (n > 0) {
    if (n % 2 == 1) {
      r *= x;
      n -= 1;
    } else {
      x *= x;
      n /= 2;
    }
  }
}
function compound (uint principal, uint ratio, uint n)
public pure returns (uint) {
  return principal * pow (1 + ratio, n);
}

请注意该表达式：r = 1.0. 在这里要记住，我们在这里使用分数，就好像 Solidity 确实支持它们，但实际上并不支持它们。人们将不得不用实现分数数学的函数替换所有算术运算。例如，下面是使用ABDK Math 64.64库实现 64.64 位定点数算术运算的真实代码：

function pow (int128 x, uint n)
public pure returns (int128 r) {
  r = ABDKMath64x64.fromUInt (1);
  while (n > 0) {
    if (n % 2 == 1) {
      r = ABDKMath64x64.mul (r, x);
      n -= 1;
    } else {
      x = ABDKMath64x64.mul (x, x);
      n /= 2;
    }
  }
}
function compound (uint principal, uint ratio, uint n)
public pure returns (uint) {
  return ABDKMath64x64.mulu (
    pow (
      ABDKMath64x64.add (
        ABDKMath64x64.fromUInt (1), 
        ABDKMath64x64.divu (
          ratio,
          10**18)),
      n),
    principal);
}

实际上，这个库已经有pow功能，可以用来代替我们的实现。

上面的代码非常精确和直接，但它仅适用于离散时间间隔。如果我们需要对任意时间间隔进行复利怎么办？这种模式被称为