This article [2] has some interesting details on the swinging factorial function n≀, but I can't seem to find the essay that it references: "Swing, divide and conquer the factorial", 2008.
Then the algorithms I understand less kick in. Most of those involve some form of modo math to wrap the number space based on one or more origami like folds and use well known and test algorithms which were previously exhaustively proven to cover the entire 32 bit number-space when utilized in a composite fashion.
If it runs fast there, it will run fast everywhere, as integers are made of Lisp conses on purpose, so you can see Lisp built from itself as if they were Peano axioms:
(require 'nmath)
(gc)
(define (fac n)
(fi '#1 n))
(define (fi a n)
(or
(and (= n '#0) 1)
(and (= n '#1) a)
(and
(fi
(* a n)
(- n '#1)
))))
(fac '#10)
(fac '#0)
-:cat fact.l | ./zl
zenlisp 2013-11-22 by Nils M Holm
=> :t
=> '(#125434 #5638)
=> 'fac
=> 'fi
=> '#3628800
=> '1
zenlisp 2013-11-22 by Nils M Holm
=> :t
=> '(#125434 #5638)
=> 'fac
=> 'fi
=> :t
+ (fi #1 #10)
+ (fi #10 #9)
+ (fi #90 #8)
+ (fi #720 #7)
+ (fi #5040 #6)
+ (fi #30240 #5)
+ (fi #151200 #4)
+ (fi #604800 #3)
+ (fi #1814400 #2)
+ (fi #3628800 #1)
=> '#3628800
+ (fi #1 #0)
=> '1
Integers are not actual integers, but lists.
'#3628800 it's '(3 6 2 8 8 0 0).
Open "nmath.l" to see how are digits implemented. Base.t it's interesting too, as it explains you some functions.
https://www.sciencedirect.com/science/article/pii/S089396591...