I'm reading R5RS spec and it shows this:

(modulo 13 4)                   ===>  1
(remainder 13 4)                ===>  1

(modulo -13 4)                  ===>  3
(remainder -13 4)               ===>  -1

(modulo 13 -4)                  ===>  -3
(remainder 13 -4)               ===>  1

(modulo -13 -4)                 ===>  -1
(remainder -13 -4)              ===>  -1

(remainder -13 -4.0)            ===>  -1.0  ; inexact

Is this correct? I thought that modulo and remainder differ only in minus sign. And here it shows that (modulo -13 4) should return 3, in JavaScript it returns 1.

What are proper algorithms to calculate modulo and remainder? I need this for my Scheme in JavaScript implementation.

I've found this code at quora.

function modulo(num1, num2) {
  if (num2 === 0 || isNaN(num1) || isNaN(num2)) {
    return NaN;
  }

  var isPositive = num1 >= 0;

  num1 = Math.abs(num1);
  num2 = Math.abs(num2);

  while (num1 >= num2) {
    num1 = num1 - num2;
  }

  return isPositive ? num1 : -num1;
}

but it don't work like in R5RS spec, it returns -1 for modulo(-13, 4). Also I thought that JavaScript's % is the same as remainder. How to implement both functions in JavaScript or in Scheme?

My exact question is: how the algorithm for both functions should look like or how JavaScript code to calculate them both should look like?

I'm reading R5RS spec and it shows this:

(modulo 13 4)                   ===>  1
(remainder 13 4)                ===>  1

(modulo -13 4)                  ===>  3
(remainder -13 4)               ===>  -1

(modulo 13 -4)                  ===>  -3
(remainder 13 -4)               ===>  1

(modulo -13 -4)                 ===>  -1
(remainder -13 -4)              ===>  -1

(remainder -13 -4.0)            ===>  -1.0  ; inexact

Is this correct? I thought that modulo and remainder differ only in minus sign. And here it shows that (modulo -13 4) should return 3, in JavaScript it returns 1.

What are proper algorithms to calculate modulo and remainder? I need this for my Scheme in JavaScript implementation.

I've found this code at quora.

function modulo(num1, num2) {
  if (num2 === 0 || isNaN(num1) || isNaN(num2)) {
    return NaN;
  }

  var isPositive = num1 >= 0;

  num1 = Math.abs(num1);
  num2 = Math.abs(num2);

  while (num1 >= num2) {
    num1 = num1 - num2;
  }

  return isPositive ? num1 : -num1;
}

but it don't work like in R5RS spec, it returns -1 for modulo(-13, 4). Also I thought that JavaScript's % is the same as remainder. How to implement both functions in JavaScript or in Scheme?

My exact question is: how the algorithm for both functions should look like or how JavaScript code to calculate them both should look like?

• javascript
• scheme
• modulo
• r5rs
• language-implementation

• Is this correct? Yes. Different languages define the modulo and remainder operations differently, as explained in here. – Óscar López Commented Mar 25, 2020 at 18:28
• @ÓscarLópez do you know if that 3 is correct or is just typo in the spec? – jcubic Commented Mar 26, 2020 at 8:01
• It's correct, just try it in any implementation pliant with the spec. Javascript simply does things differently, you'll have to adapt it to match Scheme's spec. Also take a look at this post, Python is similar to Scheme in this regard and it'll help you understand how and why the modulo is calculated in a different way. – Óscar López Commented Mar 26, 2020 at 8:04
• @ÓscarLópez The problem is I don't see how this should be implemented, I see only examples in the spec no explanation whatsoever. R5RS ch 6.2.5 – jcubic Commented Mar 26, 2020 at 8:09
• 1 your own link provides an explanation, above the examples. I've edited your question to add the more precise link, check it out. :) – Will Ness Commented Mar 27, 2020 at 8:29

4 Answers 4

This is Chibi's implementation:

• remainder: https://github./ashinn/chibi-scheme/blob/12636f4b19e732bcf257ab50808a93c323823099/bignum.c#L1784

• modulo: https://github./ashinn/chibi-scheme/blob/12636f4b19e732bcf257ab50808a93c323823099/lib/init-7.scm#L1403

The author is one of the authors of R7RS.

Here is how I implemented the functions in Urlang:

    (define/export/arity (quotient n m) 
      (Math.floor (/ n m)))

    (define/export/arity (remainder n m)
      (% n m))

    (define/export/arity (quotient/remainder n m)
      (values (quotient n m) (remainder n m)))

    (define/export/arity (modulo n m)
      (var [who (λ() (string->symbol "modulo"))])
      (unless (and (number? n) (not (infinite? n))) 
         (raise-argument-error (who) "integer?" 1 n m))
      (unless (and (number? m) (not (infinite? m))) 
         (raise-argument-error (who) "integer?" 2 n m))
      (% (+ (% n m) m) m))

Here Math.floor, % and + are the standard JavaScript functions/operators.

For the curious, here is the JavaScript produced:

function remainder(n,m){if(!((arguments.length===2)===false))VOID;else (raise_arity_error_m((string__gsymbol("remainder")),2,arguments));;return (n%m);};
function quotient_qremainder(n,m){if(!((arguments.length===2)===false))VOID;else (raise_arity_error_m((string__gsymbol("quotient/remainder")),2,arguments));;return (values((quotient(n,m)),(remainder(n,m))));};
function modulo(n,m){if(!((arguments.length===2)===false))VOID;else (raise_arity_error_m((string__gsymbol("modulo")),2,arguments));;var who=(function(){return (string__gsymbol("modulo"));});(((!((number_p(n))&&(!(infinite_p(n)))))===false)?undefined:((function(){return (raise_argument_error((who()),"integer?",1,n,m));})()));(((!((number_p(m))&&(!(infinite_p(m)))))===false)?undefined:((function(){return (raise_argument_error((who()),"integer?",2,n,m));})()));return (((n%m)+m)%m);};

UPDATE

Here is a little context. The code implements remainder and modulo for a Scheme runtime. The runtime is implemented in Urlang (which is JavaScript with s-expression-syntax).

From the output JavaScript, you can see that:

• Scheme remainder is implemented as n%m.
• Scheme modulo is implemented as ((n%m)+m)%m

This assumes that Scheme numbers are represented as JavaScript numbers (i.e. no bignums).

If someone is interested I've asked the same question on Reddit (with link to this question) and got the answer with exact scheme code:

https://www.reddit./r/scheme/ments/fpt1b8/help_with_modulo_and_reminder_in_r5rs/

(define (modulo a b)
  (- a (* b (floor (/ a b)))))

(define (remainder a b)
  (- a (* b (truncate (/ a b)))))

;; as @soegaard show reminder is just JavaScript % so this can be
;; if % is proper function
(define (remainder a b)
  (% a b))

it works the same with examples from R5RS:

(list
  (= (modulo 13 4) 1)
  (= (remainder 13 4) 1)      ;; ===>  1

  (= (modulo -13 4) 3)        ;; ===>  3
  (= (remainder -13 4) -1)    ;; ===>  -1

  (= (modulo 13 -4) -3)       ;; ===>  -3
  (= (remainder 13 -4) 1)     ;; ===>  1

  (= (modulo -13 -4) -1)      ;; ===>  -1
  (= (remainder -13 -4) -1)   ;; ===>  -1

  (= (remainder -13 -4.0) -1.0)) ;; ===>  -1.0  ; inexact

floor is Math.floor and truncate is:

var truncate = (function() {
    if (Math.trunc) {
        return Math.trunc;
    } else {
        return function(x) {
            if (x === 0) {
                return 0;
            } else if (x < 0) {
                return Math.ceil(x);
            } else {
                return Math.floor(x);
            }
        };
    }
})();

You might be interested in SRFI 141: Integer division, by Taylor Campbell. It is a proposed extension to Scheme that "...provides a fairly plete set of integral division and remainder operators."