Plato - classlib/Math/SimpleNumber.js

SCScript.install(function(sc) {
  "use strict";

require("./Number");

var $ = sc.lang.$;
  var $nil  = $.nil;
  var $int0 = $.int0;
  var $int1 = $.int1;
  var random = sc.libs.random;
  var strlib = sc.libs.strlib;

var SCArray = $("Array");
  var SCRoutine = $("Routine");

function prOpSimpleNumber(selector, func) {
    return function($aNumber, $adverb) {
      var tag = $aNumber.__tag;

switch (tag) {
      case sc.TAG_INT:
      case sc.TAG_FLOAT:
        return $.Boolean(func(this._, $aNumber._));
      }

if ($aNumber.isSequenceableCollection().__bool__()) {
        return $aNumber.performBinaryOpOnSimpleNumber(
          $.Symbol(selector), this, $adverb
        );
      }

return $.False();
    };
  }

sc.lang.klass.refine("SimpleNumber", function(builder) {
    builder.addMethod("__newFrom__", $.Float);

builder.addMethod("__bool__", function() {
      return this._ !== 0;
    });

builder.addMethod("__dec__", function() {
      return this.__newFrom__(this._ - 1);
    });

builder.addMethod("__inc__", function() {
      return this.__newFrom__(this._ + 1);
    });

builder.addMethod("__int__", function() {
      if (!isFinite(this._)) {
        return this._;
      }
      return this._|0;
    });

builder.addMethod("__num__", function() {
      return this._;
    });

builder.shouldUseLiterals("new");

builder.addMethod("isValidUGenInput", function() {
      return $.Boolean(!isNaN(this._));
    });

builder.addMethod("numChannels", function() {
      return $int1;
    });

builder.addMethod("magnitude", function() {
      return this.abs();
    });

builder.addMethod("angle", function() {
      return $.Float(this._ >= 0 ? 0 : Math.PI);
    });

builder.addMethod("neg", function() {
      return this.__newFrom__(-this._);
    });

// bitNot: implemented by subclass

builder.addMethod("abs", function() {
      return this.__newFrom__(Math.abs(this._));
    });

builder.addMethod("ceil", function() {
      return this.__newFrom__(Math.ceil(this._));
    });

builder.addMethod("floor", function() {
      return this.__newFrom__(Math.floor(this._));
    });

builder.addMethod("frac", function() {
      var a = this._;

if (a < 0) {
        return this.__newFrom__(1 + (a - (a|0)));
      }
      return this.__newFrom__(a - (a|0));
    });

builder.addMethod("sign", function() {
      var a = this._;
      return this.__newFrom__(
        a > 0 ? 1 : a === 0 ? 0 : -1
      );
    });

builder.addMethod("squared", function() {
      return this.__newFrom__(this._ * this._);
    });

builder.addMethod("cubed", function() {
      return this.__newFrom__(this._ * this._ * this._);
    });

builder.addMethod("sqrt", function() {
      return $.Float(Math.sqrt(this._));
    });

builder.addMethod("exp", function() {
      return $.Float(Math.exp(this._));
    });

builder.addMethod("reciprocal", function() {
      return $.Float(1 / this._);
    });

builder.addMethod("midicps", function() {
      return $.Float(
        440 * Math.pow(2, (this._ - 69) * 1 / 12)
      );
    });

builder.addMethod("cpsmidi", function() {
      return $.Float(
        Math.log(Math.abs(this._) * 1 / 440) * Math.LOG2E * 12 + 69
      );
    });

builder.addMethod("midiratio", function() {
      return $.Float(
        Math.pow(2, this._ * 1 / 12)
      );
    });

builder.addMethod("ratiomidi", function() {
      return $.Float(
        Math.log(Math.abs(this._)) * Math.LOG2E * 12
      );
    });

builder.addMethod("ampdb", function() {
      return $.Float(
        Math.log(this._) * Math.LOG10E * 20
      );
    });

builder.addMethod("dbamp", function() {
      return $.Float(
        Math.pow(10, this._ * 0.05)
      );
    });

builder.addMethod("octcps", function() {
      return $.Float(
        440 * Math.pow(2, this._ - 4.75)
      );
    });

builder.addMethod("cpsoct", function() {
      return $.Float(
        Math.log(Math.abs(this._) * 1 / 440) * Math.LOG2E + 4.75
      );
    });

builder.addMethod("log", function() {
      return $.Float(Math.log(this._));
    });

builder.addMethod("log2", function() {
      return $.Float(Math.log(Math.abs(this._)) * Math.LOG2E);
    });

builder.addMethod("log10", function() {
      return $.Float(Math.log(this._) * Math.LOG10E);
    });

builder.addMethod("sin", function() {
      return $.Float(Math.sin(this._));
    });

builder.addMethod("cos", function() {
      return $.Float(Math.cos(this._));
    });

builder.addMethod("tan", function() {
      return $.Float(Math.tan(this._));
    });

builder.addMethod("asin", function() {
      return $.Float(Math.asin(this._));
    });

builder.addMethod("acos", function() {
      return $.Float(Math.acos(this._));
    });

builder.addMethod("atan", function() {
      return $.Float(Math.atan(this._));
    });

function _sinh(a) {
      return (Math.pow(Math.E, a) - Math.pow(Math.E, -a)) * 0.5;
    }

builder.addMethod("sinh", function() {
      return $.Float(_sinh(this._));
    });

function _cosh(a) {
      return (Math.pow(Math.E, a) + Math.pow(Math.E, -a)) * 0.5;
    }

builder.addMethod("cosh", function() {
      return $.Float(_cosh(this._));
    });

builder.addMethod("tanh", function() {
      return $.Float(_sinh(this._) / _cosh(this._));
    });

builder.addMethod("rand", function() {
      return this.__newFrom__(
        random.next() * this._
      );
    });

builder.addMethod("rand2", function() {
      return this.__newFrom__(
        (random.next() * 2 - 1) * this._
      );
    });

builder.addMethod("linrand", function() {
      return this.__newFrom__(
        Math.min(random.next(), random.next()) * this._
      );
    });

builder.addMethod("bilinrand", function() {
      return this.__newFrom__(
        (random.next() - random.next()) * this._
      );
    });

builder.addMethod("sum3rand", function() {
      return this.__newFrom__(
        (random.next() + random.next() + random.next() - 1.5) * 2 / 3 * this._
      );
    });

builder.addMethod("distort", function() {
      return $.Float(
        this._ / (1 + Math.abs(this._))
      );
    });

builder.addMethod("softclip", function() {
      var a = this._, abs = Math.abs(a);
      return $.Float(abs <= 0.5 ? a : (abs - 0.25) / a);
    });

builder.addMethod("coin", function() {
      return $.Boolean(random.next() < this._);
    });

builder.addMethod("isPositive", function() {
      return $.Boolean(this._ >= 0);
    });

builder.addMethod("isNegative", function() {
      return $.Boolean(this._ < 0);
    });

builder.addMethod("isStrictlyPositive", function() {
      return $.Boolean(this._ > 0);
    });

builder.addMethod("isNaN", function() {
      return $.Boolean(isNaN(this._));
    });

builder.addMethod("asBoolean", function() {
      return $.Boolean(this._ > 0);
    });

builder.addMethod("booleanValue", function() {
      return $.Boolean(this._ > 0);
    });

builder.addMethod("binaryValue", function() {
      return this._ > 0 ? $int1 : $int0;
    });

builder.addMethod("rectWindow", function() {
      var a = this._;
      if (a < 0 || 1 < a) {
        return $.Float(0);
      }
      return $.Float(1);
    });

builder.addMethod("hanWindow", function() {
      var a = this._;
      if (a < 0 || 1 < a) {
        return $.Float(0);
      }
      return $.Float(0.5 - 0.5 * Math.cos(a * 2 * Math.PI));
    });

builder.addMethod("welWindow", function() {
      var a = this._;
      if (a < 0 || 1 < a) {
        return $.Float(0);
      }
      return $.Float(Math.sin(a * Math.PI));
    });

builder.addMethod("triWindow", function() {
      var a = this._;
      if (a < 0 || 1 < a) {
        return $.Float(0);
      }
      if (a < 0.5) {
        return $.Float(2 * a);
      }
      return $.Float(-2 * a + 2);
    });

builder.addMethod("scurve", function() {
      var a = this._;
      if (a <= 0) {
        return $.Float(0);
      }
      if (1 <= a) {
        return $.Float(1);
      }
      return $.Float(a * a * (3 - 2 * a));
    });

builder.addMethod("ramp", function() {
      var a = this._;
      if (a <= 0) {
        return $.Float(0);
      }
      if (1 <= a) {
        return $.Float(1);
      }
      return $.Float(a);
    });

// +: implemented by subclass
    // -: implemented by subclass
    // *: implemented by subclass
    // /: implemented by subclass
    // mod: implemented by subclass
    // div: implemented by subclass
    // pow: implemented by subclass
    // min: implemented by subclass
    // max: implemented by subclass
    // bitAnd: implemented by subclass
    // bitOr : implemented by subclass
    // bitXor: implemented by subclass

builder.addMethod("bitTest", function($bit) {
      return $.Boolean(
        this.bitAnd($int1.leftShift($bit)).__num__() !== 0
      );
    });

// lcm     : implemented by subclass
    // gcd     : implemented by subclass
    // round   : implemented by subclass
    // roundUp : implemented by subclass
    // trunc   : implemented by subclass
    // atan2   : implemented by subclass
    // hypot   : implemented by subclass
    // hypotApx: implemented by subclass
    // leftShift         : implemented by subclass
    // rightShift        : implemented by subclass
    // unsignedRightShift: implemented by subclass
    // ring1 : implemented by subclass
    // ring2 : implemented by subclass
    // ring3 : implemented by subclass
    // ring4 : implemented by subclass
    // difsqr: implemented by subclass
    // sumsqr: implemented by subclass
    // sqrsum: implemented by subclass
    // sqrdif: implemented by subclass
    // absdif: implemented by subclass
    // thresh: implemented by subclass
    // amclip: implemented by subclass
    // clip2 : implemented by subclass
    // fold2 : implemented by subclass
    // wrap2 : implemented by subclass
    // excess: implemented by subclass
    // firstArg: implemented by subclass
    // rrand   : implemented by subclass
    // exprand : implemented by subclass

builder.addMethod("==", function($aNumber) {
      return $.Boolean(this._ === $aNumber._);
    });

builder.addMethod("!=", function($aNumber) {
      return $.Boolean(this._ !== $aNumber._);
    });

builder.addMethod("<", prOpSimpleNumber("<", function(a, b) {
      return a < b;
    }));

builder.addMethod(">", prOpSimpleNumber(">", function(a, b) {
      return a > b;
    }));

builder.addMethod("<=", prOpSimpleNumber("<=", function(a, b) {
      return a <= b;
    }));

builder.addMethod(">=", prOpSimpleNumber(">=", function(a, b) {
      return a >= b;
    }));

builder.addMethod("equalWithPrecision", {
      args: "that; precision=0.0001"
    }, function($that, $precision) {
      return this.absdif($that) ["<"] ($precision);
    });

builder.addMethod("asInteger", function() {
      return $.Integer(this._);
    });

builder.addMethod("asFloat", function() {
      return $.Float(this._);
    });

// TODO: implements asComplex
    // TODO: implements asRect

builder.addMethod("degrad", function() {
      return $.Float(this._ * Math.PI / 180);
    });

builder.addMethod("raddeg", function() {
      return $.Float(this._ * 180 / Math.PI);
    });

builder.addMethod("performBinaryOpOnSimpleNumber", function($aSelector) {
      throw new Error(strlib.format("binary operator '#{0}' failed", $aSelector.__sym__()));
    });

// TODO: implements performBinaryOpOnComplex

builder.addMethod("performBinaryOpOnSignal", function($aSelector) {
      throw new Error(strlib.format("binary operator '#{0}' failed", $aSelector.__sym__()));
    });

builder.addMethod("nextPowerOfTwo", function() {
      return $.Float(
        Math.pow(2, Math.ceil(Math.log(this._) / Math.log(2)))
      );
    });

builder.addMethod("nextPowerOf", {
      args: "base"
    }, function($base) {
      return $base.pow(
        (this.log() ["/"] ($base.$("log"))).ceil()
      );
    });

builder.addMethod("nextPowerOfThree", function() {
      return $.Float(
        Math.pow(3, Math.ceil(Math.log(this._) / Math.log(3)))
      );
    });

builder.addMethod("previousPowerOf", {
      args: "base"
    }, function($base) {
      return $base.pow(
        (this.log() ["/"] ($base.$("log"))).ceil().__dec__()
      );
    });

builder.addMethod("quantize", {
      args: "quantum=1.0; tolerance=0.05; strength=1.0"
    }, function($quantum, $tolerance, $strength) {
      var $round, $diff;

$round = this.round($quantum);
      $diff = $round ["-"] (this);

if ($diff.abs() < $tolerance) {
        return this ["+"] ($strength.$("*", [ $diff ]));
      }

return this;
    });

builder.addMethod("linlin", {
      args: "inMin; inMax; outMin; outMax; clip=\\minmax"
    }, function($inMin, $inMax, $outMin, $outMax, $clip) {
      var $res = null;