MR Algoreisms

// P1: MR MR Algoreisms.
// P2: MR naught.
// P1: OSAR. CM remains.
// P2: LIB. MR MR Algoreisms.

Algorithm MR (My Remainder Algorithm). Given two integers n and m where m is not zero, find the remainder when |n| (the absolute value of n) is divided by |m|.
MR0. [Assert Inputs]: Assert n and m are integers and m is not zero. If the assertion is false, raise an error and do not continue; the algorithm must terminate. ∎
MR1. [Remove Sign]: Set n ← |n|, m ← |m|. (We will have n ≥ 0 and m > 0.)
MR2. [Reduce]: Set n ← n – m.
MR3. [Positive?]: If n > 0, go back to step MR2.
MR4. [Remainder?]: (We will have n ≤ 0.) If n equals zero, there is no remainder (i.e. the answer is zero); otherwise, n + m is the answer. Return the answer; the algorithm terminates. ∎

        ↓
(0. Assert Inputs) → error
        | ok             ______________
        ↓               ↓          yes |       no                no
[1. Remove Sign] → [2. Reduce] → (3. Positive?) → (4. Remainder?) →
                                                          ↓ yes

See also: Algorithms

Implementations, Dopplegangers, and Traps — Oh my!

// Nearly identical implementations
// that use the same sort of for loop

function MRF1(n, m) {
  ASSERT(n, m);
  n = ABS(n);
  m = ABS(m);
  for (n = SUB(n, m); POS(n); n = SUB(n, m));
  return ZER(n) ? 0 : ADD(n, m);
}

function MRF2(n, m) {
  ASSERT(n, m);
  n = ABS(n);
  m = ABS(m);
  for (n = SUB(n, m); POS(n); n = SUB(n, m)) {
    // do nothing
  }
  return ZER(n) ? 0 : ADD(n, m);
}

// Implementations that
// use different while loops

function MRW1(n, m) {
  ASSERT(n, m);
  n = ABS(n);
  m = ABS(m);
  n = SUB(n, m);
  while (POS(n)) {
    n = SUB(n, m);
  }
  return ZER(n) ? 0 : ADD(n, m);
}

function MRW2(n, m) {
  ASSERT(n, m);
  n = ABS(n);
  m = ABS(m);
  while (true) {
    n = SUB(n, m);
    if (!POS(n)) {
      return ZER(n) ? 0 : ADD(n, m);
    }
  }
}

// Dangerous functions (traps!) that
// might return the correct answer,
// might not return the correct answer, or
// might not return at all!

function MRDT1(n, m) {
  n = SUB(n, m);
  if (POS(n)) {
    return MRDT1(n, m);
  }
  return ZER(n) ? 0 : ADD(n, m);
}

function MRDT2(n, m) {
  while (true) {
    n = SUB(n, m);
    if (!POS(n)) {
      return ZER(n) ? 0 : ADD(n, m);
    }
  }
}

// Implementations that
// use dangerous functions responsibly.

function MRR1(n, m) {
  ASSERT(n, m);
  n = ABS(n);
  m = ABS(m);
  return MRDT1(n, m);
}

function MRR2(n, m) {
  ASSERT(n, m);
  n = ABS(n);
  m = ABS(m);
  return MRDT2(n, m);
}

// Dopplegangers that answer correctly
// but implement a deviant algorithm

function MRD1(n, m) {
  while (true) {
    ASSERT(n, m);
    n = ABS(n);
    m = ABS(m);
    n = SUB(n, m);
    if (!POS(n)) {
      return ZER(n) ? 0 : ADD(n, m);
    }
  }
}

function MRD2(n, m) {
  ASSERT(n, m);
  n = ABS(n);
  m = ABS(m);
  n = SUB(n, m);
  if (!POS(n)) {
    return ZER(n) ? 0 : ADD(n, m);
  }
  return MRD2(n, m);
}

function MRD3(n, m) {
  ASSERT(n, m);
  n = ABS(n);
  m = ABS(m);
  n = SUB(n, m);
  if (POS(n)) {
    return MRD3(n, m);
  }
  return ZER(n) ? 0 : ADD(n, m);
}

Components

// An output utility

function OUT(s) {
  console.log(s);
}

// Components that may be used to implement MR Algorithm

function ASSERT(n, m) {
  OUT("Assert Inputs");
  n = parseFloat(n);
  m = parseFloat(m);
  if (n === parseInt(n) && m === parseInt(m) && m !== 0) {
    return;
  }
  throw Error("Invalid Arguments!");
}

function ABS(n) {
  OUT("Remove Sign:" + n.toString());
  return n < 0 ? -n : n;
}

function POS(n) {
  OUT("Positive?:" + n.toString());
  return n > 0;
}

function ZER(n) {
  OUT("Remainder?:" + n.toString());
  return n === 0;
}

function ADD(n, m) {
  OUT("Add:" + (n + m).toString());
  return n + m;
}

function SUB(n, m) {
  OUT("Reduce:" + (n - m).toString());
  return n - m;
}