Pourquoi la version itérative prend-elle plus de temps?

Je regardais http://programming.lispdream.com/blog/2011/06/recursion-vs-iteration/ et j'ai vu que sur son implémentation des implémentations récursives et itératives de la fonction factorielle, l'itératif prend en fait plus de temps étant donné n = 1000. Je ne peux pas comprendre pourquoi (il n'explique pas, mais dit que c'est un exercice pour le lecteur). Désolé pour ma nouveauté à tout cela.

Les deux programmes ne sont pas équivalents. La version récursive est informatique

(... ((1 * 2) * 3) * 4 ... * n)

tandis que l'itératif est le calcul

(... ((n * (n-1)) * (n-2) ... * 1)

ainsi les quantités intermédiaires augmentent plus rapidement pour la version itérative et le calcul de gros num est plus rapide lorsque les nombres impliqués sont petits (Computing 1000! sans big num n'a aucun sens et le dialecte lisp passe automatiquement à big num).

Lorsque vous rendez un algorithme récursif itératif, vous devez implémenter explicitement la pile qui suit les résultats. Cet acte ajoute des opérations supplémentaires traitant de la poussée et de l'éclatement de la pile que l'algorithme récursif obtient gratuitement (enfin pas tout à fait gratuitement, mais les opérations supplémentaires représentent plus que le coût de la récursivité).

Je peux seulement deviner, je ne suis même pas sûr si ces repères proviennent du C ou du code SBLC. Je suppose que le coupable mute la variable. 1000! est un nombre assez important, il est peut-être plus rapide de remplir la pile avec des intermédiaires et de nettoyer que de créer une copie et de l'écraser.