Bignums and flonums #63
Conversation
src/lib/bignum.scm
Outdated
| bn0) | ||
| ((##eqv? (##bn< bn0 a) (##bn< bn0 b)) ;; positive quotient? (same parity) | ||
|
|
||
| ;; if b is a fixnum, we need to pad both a and b with a 0 for the |
There was a problem hiding this comment.
La condition est un peu bizarre. Tu devrait implémenté l'algorithme de division entre bignum(dividande) et un fixnum (diviseur) et l'utilisé dans bn-quotient. C'est un cas très fréquent de divisé par un fixnum, on veut que ce soit rapide.
src/lib/bignum.scm
Outdated
| (##quotient a b) ;; no need to normalize | ||
| (bn-norm (##bn-quotient (fixnum->bignum a) (fixnum->bignum b))))) | ||
|
|
||
| (define (##bn-quotient a b) |
There was a problem hiding this comment.
Techniquement l'algorithme retourne le résultat de la division et le reste de la division. Peut-etre changer le nom par ##bn-quotient-reminder ?
src/lib/bignum.scm
Outdated
|
|
||
| (let* ((d (##dummy-bn-quotient (##bn- bn-base bn1) (bn-get b 0 (##- 0 1)))) ;; normalize a and b | ||
| (_a (##bn* a d)) | ||
| (_b (##bn* b d)) |
There was a problem hiding this comment.
Quand tu choisiras d comme une puissance de 2, alors les multiplications deviendrons des bitshift (plus rapide)
src/lib/bignum.scm
Outdated
| (let loop ((j m) ;; probably never will be a bignum | ||
| (q bn0) | ||
| (a _a)) | ||
| (if (##< j 0) | ||
| q | ||
| (let* ((top-a (bn-get a j (##+ b-bits 1))) ;; (a_j+n ... a_j) i.e. |n|+1 digits | ||
| (lower-a (bn-get a 0 j)) ;; (a_j-1 ... a_0) | ||
| (top3-a ;; top 3 bits from (a_j+n ... a_j), some could be 0s | ||
| (bn-get top-a (##- (bn-length top-a) 3) 3))) | ||
|
|
||
| (if (##bn< (bn-next top3-a) b_n-1) ;; quotient is 0? | ||
| (loop (##- j 1) (bn-cons 0 q) a) | ||
| (let* ((q-hat-estimate (calculate-q-hat top3-a b_n-1 b_n-2)) | ||
| (q-hat (add-back top-a _b q-hat-estimate)) | ||
| (new-top-a (##bn- top-a (##bn* (bn-cons q-hat bn0) _b)))) | ||
|
|
||
| ;; FIXME, steps missing in the add-back part of the algorithm | ||
| ;; (dif (bn- q-hat q-hat-estimate)) ;; number of add back iterations | ||
| ;; (_top-a (if (bn= bn0 dif) ;; | ||
| ;; __top-a | ||
| ;; (bn-concatenate __top-a dif))) | ||
| ;; (bn-concatenate (no-carry-bn+ (bn* dif _b) __top-a) dif))) | ||
|
|
||
| (loop (##- j 1) | ||
| (bn-cons q-hat q) | ||
| (bn-concatenate lower-a new-top-a))))))))) |
There was a problem hiding this comment.
Au lieux d'avoir un conteur j et d'indexer j dans le bignum avec bn-get à chaque tour de boucle, tu peux faire une optimization.
Si tu vois le bignum comme une liste, tu peux inversé la liste et bouclée dessus en prenant les deux première valeurs. Ça te sauve beaucoup d'indexation de la liste avec bn-get
src/lib/bignum.scm
Outdated
| (q-hat (##quotient div b_n-1)) | ||
| ;; (r-hat (##remainder div b_n-1))) | ||
| (r-hat (##modulo div b_n-1))) | ||
| (r-hat (##modulo div b_n-1))) |
There was a problem hiding this comment.
It would be interesting to see the difference in performance when ##modulo is a primitive instead of a function. I think the improvement would be significative
src/lib/bignum.scm
Outdated
| (##< (##+ (##* base r-hat) a_j+n-2) | ||
| (##* q-hat b_n-2))) | ||
| (let ((q-hat (##- q-hat 1)) | ||
| (r-hat (##+ r-hat b_n-1))) | ||
| (if (and (##< r-hat base) | ||
| (or (##< base-1 q-hat) | ||
| (##< (##+ (##* base r-hat) a_j+n-2) | ||
| (##* q-hat b_n-2)))) | ||
| (##- q-hat 1) | ||
| q-hat)) | ||
| q-hat))) |
There was a problem hiding this comment.
I have the impression that this can be optimized further to avoid repetition, but I'm not quite sure how to do it
src/lib/bignum.scm
Outdated
| @@ -445,11 +447,11 @@ | |||
|
|
|||
There was a problem hiding this comment.
Commentaire pour bn-concatenate, c'est une fonction équivalente à append pour les listes. Tu peux faire en sorte que la fonction est "tail call" en rajoutant un argument. On avait vu ça dans le cours de compilation ;)
|
@l4haie Apparently, deleting the |
No description provided.