Plato - libs/mathlib.js

(function(sc) {
  "use strict";

require("./libs");
  require("./random");

var rand = sc.libs.random;
  var mathlib = {};

mathlib.rand = function(a) {
    return rand.next() * a;
  };

mathlib["+"] = function(a, b) {
    return a + b;
  };

mathlib["-"] = function(a, b) {
    return a - b;
  };

mathlib["*"] = function(a, b) {
    return a * b;
  };

mathlib["/"] = function(a, b) {
    return a / b;
  };

mathlib.mod = function(a, b) {
    if (a === 0 || b === 0) {
      return 0;
    }
    if ((a > 0 && b < 0) || (a < 0 && b > 0)) {
      return b + a % b;
    }
    return a % b;
  };

mathlib.div = function(a, b) {
    if (b === 0) {
      return a|0;
    }
    return (a / b)|0;
  };

mathlib.pow = function(a, b) {
    return Math.pow(a, b);
  };

mathlib.min = Math.min;
  mathlib.max = Math.max;

mathlib.bitAnd = function(a, b) {
    return a & b;
  };

mathlib.bitOr = function(a, b) {
    return a | b;
  };

mathlib.bitXor = function(a, b) {
    return a ^ b;
  };

var gcd = function(a, b) {
    var t;

a = a|0;
    b = b|0;

while (b !== 0) {
      t = a % b;
      a = b;
      b = t;
    }

return Math.abs(a);
  };

mathlib.lcm = function(a, b) {
    if (a === 0 && b === 0) {
      return 0;
    }
    return Math.abs((a|0) * (b|0)) / gcd(a, b);
  };

mathlib.gcd = function(a, b) {
    return gcd(a, b);
  };

mathlib.round = function(a, b) {
    return b === 0 ? a : Math.round(a / b) * b;
  };

mathlib.roundUp = function(a, b) {
    return b === 0 ? a : Math.ceil(a / b) * b;
  };

mathlib.trunc = function(a, b) {
    return b === 0 ? a : Math.floor(a / b) * b;
  };

mathlib.atan2 = Math.atan2;

mathlib.hypot = function(a, b) {
    return Math.sqrt((a * a) + (b * b));
  };

mathlib.hypotApx = function(a, b) {
    var x = Math.abs(a);
    var y = Math.abs(b);
    var minxy = Math.min(x, y);
    return x + y - (Math.sqrt(2) - 1) * minxy;
  };

mathlib.leftShift = function(a, b) {
    if (b < 0) {
      return a >> -b;
    }
    return a << b;
  };

mathlib.rightShift = function(a, b) {
    if (b < 0) {
      return a << -b;
    }
    return a >> b;
  };

mathlib.unsignedRightShift = function(a, b) {
    if (b < 0) {
      return (a << -b) >>> 0;
    }
    return a >>> b;
  };

mathlib.ring1 = function(a, b) {
    return a * b + a;
  };

mathlib.ring2 = function(a, b) {
    return a * b + a + b;
  };

mathlib.ring3 = function(a, b) {
    return a * a * b;
  };

mathlib.ring4 = function(a, b) {
    return a * a * b - a * b * b;
  };

mathlib.difsqr = function(a, b) {
    return a * a - b * b;
  };

mathlib.sumsqr = function(a, b) {
    return a * a + b * b;
  };

mathlib.sqrsum = function(a, b) {
    return (a + b) * (a + b);
  };

mathlib.sqrdif = function(a, b) {
    return (a - b) * (a - b);
  };

mathlib.absdif = function(a, b) {
    return Math.abs(a - b);
  };

mathlib.thresh = function(a, b) {
    return a < b ? 0 : a;
  };

mathlib.amclip = function(a, b) {
    return a * 0.5 * (b + Math.abs(b));
  };

mathlib.scaleneg = function(a, b) {
    b = 0.5 * b + 0.5;
    return (Math.abs(a) - a) * b + a;
  };

mathlib.clip2 = function(a, b) {
    return Math.max(-b, Math.min(a, b));
  };

mathlib.fold2 = function(a, b) {
    var x, c, range, range2;

if (b === 0) {
      return 0;
    }

x = a + b;
    if (a >= b) {
      a = b + b - a;
      if (a >= -b) {
        return a;
      }
    } else if (a < -b) {
      a = -b - b - a;
      if (a < b) {
        return a;
      }
    } else {
      return a;
    }

range  = b + b;
    range2 = range + range;
    c = x - range2 * Math.floor(x / range2);

if (c >= range) {
      c = range2 - c;
    }

return c - b;
  };

mathlib.wrap2 = function(a, b) {
    var range;

if (b === 0) {
      return 0;
    }

if (a >= b) {
      range = b + b;
      a -= range;
      if (a < b) {
        return a;
      }
    } else if (a < -b) {
      range = b + b;
      a += range;
      if (a >= -b) {
        return a;
      }
    } else {
      return a;
    }

return a - range * Math.floor((a + b) / range);
  };

mathlib.excess = function(a, b) {
    return a - Math.max(-b, Math.min(a, b));
  };

mathlib.firstArg = function(a) {
    return a;
  };

mathlib.rrand = function(a, b) {
    return a + rand.next() * (b - a);
  };

mathlib.exprand = function(a, b) {
    return a * Math.exp(Math.log(b / a) * rand.next());
  };

mathlib.clip = function(val, lo, hi) {
    return Math.max(lo, Math.min(val, hi));
  };

mathlib.iwrap = function(val, lo, hi) {
    var range;

range = hi - lo + 1;
    val -= range * Math.floor((val - lo) / range);

return val;
  };

mathlib.wrap = function(val, lo, hi) {
    var range;

if (hi === lo) {
      return lo;
    }

range = (hi - lo);
    if (val >= hi) {
      val -= range;
      if (val < hi) {
        return val;
      }
    } else if (val < lo) {
      val += range;
      if (val >= lo) {
        return val;
      }
    } else {
      return val;
    }

return val - range * Math.floor((val - lo) / range);
  };

mathlib.ifold = function(val, lo, hi) {
    var x, range1, range2;

range1 = hi - lo;
    range2 = range1 * 2;
    x = val - lo;
    x -= range2 * Math.floor(x / range2);

if (x >= range1) {
      return range2 - x + lo;
    }

return x + lo;
  };

mathlib.fold = function(val, lo, hi) {
    var x, range1, range2;

if (hi === lo) {
      return lo;
    }

if (val >= hi) {
      val = (hi * 2) - val;
      if (val >= lo) {
        return val;
      }
    } else if (val < lo) {
      val = (lo * 2) - val;
      if (val < hi) {
        return val;
      }
    } else {
      return val;
    }

range1 = hi - lo;
    range2 = range1 * 2;
    x = val - lo;
    x -= range2 * Math.floor(x / range2);

if (x >= range1) {
      return range2 - x + lo;
    }

return x + lo;
  };

mathlib.clipIndex = function(index, len) {
    return Math.max(0, Math.min(index, len - 1));
  };

mathlib.wrapIndex = function(index, len) {
    index = index % len;
    if (index < 0) {
      index += len;
    }
    return index;
  };

mathlib.foldIndex = function(index, len) {
    var len2 = len * 2 - 2;

index = (index|0) % len2;
    if (index < 0) {
      index += len2;
    }
    if (len <= index) {
      return len2 - index;
    }
    return index;
  };

sc.libs.mathlib = mathlib;
})(sc);

libs/mathlib.js

Maintainability

Lines of code

Difficulty

Estimated Errors

Function weight

By Complexity

By SLOC