'use strict'; var cvs, ctx; // TODO: Optimize numeric for matrix operation over entire sweep // My hope is that the accelerated datatype takes over // Background workers? /* Library links: http://mikemcl.github.io/bignumber.js/ https://mikemcl.github.io/decimal.js/ */ // preloaded values var frameRate = 90; // up to 120 fps works as long as event loop can handle events within 5s (to prevent SoloLearn abort) var debugMode = false; // gathers intermediate calculations into a text panel. Adds about 100ms to 1000 steps, currently only inserted into Math but easy to add to others. var debugBuffer = ""; // gathers debug output, flushDebugLines() prints at end of operation function fnNull() {} var fns = { 'NULL': {'init': fnNull, 'draw':fnNull}, 'math': {'init': math_init, 'draw': math_runner}, 'bignumber' : {'init': bignumber_init, 'draw': bignumber_runner}, 'decimal' : {'init':decimal_init, "draw":decimal_runner}, 'numeric' : {'init':numeric_init, "draw":numeric_runner}, }; var rangeLabels = ["0 - 2π", "π/2 - 5π/2", "π - 3π", "3π/2 - 7π/2", "2π - 4π", "Custom"]; var elRangeDefault; var initSteps=1000; var parms = { 'math': { "startSteps" : initSteps, "stopSteps" : 0, "precision" : 15.8, "template": "Math.PI * x", }, 'bignumber' : { "startSteps" : initSteps, "stopSteps" : 0, "precision" : 20, "template": "PI.times(x)", }, 'decimal' : { "startSteps" : initSteps, "stopSteps" : 0, "precision" : 30, // 20 still has badsum effects; 30 does not "template": "PI.times(x)", }, 'numeric' : { "startSteps": initSteps, "stopSteps": 0, "precision": 15.8, "template": "numeric.mul(PI, x)", }, }; // more data panel for whatever reason var elDebug; var gebi; // bound to getElementById var elFPS, actualFPS="--"; // replaced depending on library var r; // radius ... half canvas square var realX, realY; var lastX, lastY, thisX, thisY; // for numeric function var realXY, lastXY, thisXY; var centerXY; var totalDistance; // sum of step lengths (pythag sum) var startTime; var rotation; // 0 to 2π var centerX, centerY; // circle, arc start var PI, twoPI; var startRadians; // used while correcting a range anomaly var targetRadians; // end of spiral var radianSweep; // targetRadians - startRadians; var actualDistance; var fnInit, fnDraw; var elStartSteps, elStopSteps, elStartRadians, elTargetRadians, elRadsError, elOutput; var mode; // mostly to separate numeric and normal math, which don't create objects // range control + display var startSteps; var currentSteps; var stopSteps; var running = false; var stopRequested = false; var btnRunStop; var elActualDistance; var elRadius; var elPrecision, elPrecisionError; // BadMath / good math slushpile var integerStep, steps, stepsz, radsz, temp, firstRun; var useBadMath = false; // set by checkbox /* Length of archimedian spiral, THIS CASE _ 2π | L = | sqrt[ r^2 + (dr/dtheta)^2 ] dtheta _| 0π becomes ... (from notes, find sources later) ==> 1/2x [x * sqrt(1 + x^2) + sinh^-1(x) ] where x == theta radians (2π is used here) */ //~ 3.3830442855; // that integral 0..2π function updateFPS(){ elFPS.innerHTML = actualFPS + "/"+frameRate+" : actual/target fps"; } window.onload=function(){ gebi = document.getElementById.bind(document); elFPS = gebi("fps"); elDebug = gebi("debugPanel"); cvs = gebi("cvs"); elRadius = gebi("radius"); elRangeDefault = gebi("rangeDefault"); elStartRadians = gebi("startRadians"); elTargetRadians = gebi("targetRadians"); elStartSteps = gebi("startSteps"); elStopSteps = gebi("stopSteps"); elRadsError = gebi('radsError'); elOutput = gebi("output"); elPrecision = gebi("precision"); elPrecisionError = gebi("precError"); btnRunStop = gebi("runstop"); if(debugMode) elDebug.style.display = ""; else elDebug.style.display = "none"; ctx = cvs.getContext("2d"); btnRunStop.disabled = true; btnRunStop.innerHTML ="- ? -"; for (var x=0; x<6; x++) { var el = document.createElement("option"); el.innerHTML = rangeLabels[x]; el.value = x*0.5; // start of range, width hardcoded to 2pi if(rangeLabels[x] == "Custom") el.value = -1; elRangeDefault.appendChild(el); } startSteps = 0; stopSteps = 0; elStartSteps.value = startSteps; elStopSteps.value = stopSteps; updateFPS(); addOutputLine("ready!"); }; window.onbeforeunload=function(){ // SoloLearner navigated away stopRequested = true; running = false; currentSteps = stopSteps; rotation = targetRadians; }; var showedBadMathNoticeThisPanel = false; function badMathNotice(event) { useBadMath = event.checked; if(!showedBadMathNoticeThisPanel && useBadMath) { //addOutputLine("

BADMATH: Run 'Math library' with/without box ticked, compare the 3rd decimal digit, which is corrupted(not a plain precision error; try 10,000 + 50 steps, watch position 4...).Run Decimal @ 777 steps (or Numeric @ 1000) with/without tick. Use '+more steps' with math library to watch accuracy bounce backwards over +50 runs.

"); addOutputLine("Decimal has a slight anomaly, Numeric has a large one. Try 1000 steps with/without checkbox set.

") showedBadMathNoticeThisPanel = true; } } function wipeAndCircleCanvas() { cvs.width = cvs.width; ctx.beginPath(); ctx.arc(centerX,centerY,r, 0,twoPI); ctx.closePath(); ctx.strokeStyle="#bbb"; ctx.stroke(); ctx.beginPath(); } function setRangeDefault(event) { // undefined if never loaded, NULL if library is unset if(mode=="NULL" || mode===undefined) return false; if(elRangeDefault.value == "-1") { // custom radsChange(); // evaluate what's there, don't change anything return false; } var template = parms[mode].template; var start, target; start = Number(elRangeDefault.value); target = start + 2; var io = template.indexOf("x"); elStartRadians.value = template.substr(0, io) + start + template.substr(io+1); elTargetRadians.value = template.substr(0, io) + target + template.substr(io+1); radsChange(); } function setPrecision(event) { if(typeof event == "number") elPrecision.value = event; elPrecision.disabled = true; elPrecisionError.innerHTML = ""; if(!(mode=="bignumber" || mode=="decimal")) return false; elPrecision.disabled = false; // keypresses fall through, ignoring event try { var newPrecision = Number(elPrecision.value); if(mode=="bignumber") BigNumber.config({ DECIMAL_PLACES: newPrecision, ROUNDING_MODE: BigNumber.ROUND_UP }); else if(mode=="decimal") Decimal.set({ precision: newPrecision}); // Decimal9 = Decimal.clone({ precision: 9 }) } catch(e) { elPrecisionError.innerHTML = e; } if(typeof event == "object") elPrecision.focus(); } function setupLibrary(event) { if(running) { stopRequested = true; currentSteps = stopSteps; // stop any extra iters setTimeout(function() {setupLibrary(event)}, 200); return false; } mode = event.value; // does not fire onchange() // elPrecision.value = parms[mode].precision; setPrecision(parms[mode].precision); // setRangeDefault(); fnInit = fns[event.value].init; fnDraw = fns[event.value].draw; fnInit(); currentSteps = startSteps; if(event.value == "NULL") { btnRunStop.disabled = true; btnRunStop.innerHTML = "- ? -"; } else { btnRunStop.disabled = false; btnRunStop.innerHTML = "Run"; } } // Because not every library has asinh(); spoils purity a little function math_asinh(z) { return Math.log(z+Math.sqrt(1+Math.pow(z,2),10)); } function timeElapsed() { return " (" + (Date.now() - startTime) + "ms)"; } function radsChange(event) { // keypress should auto-flip to custom if(event !== undefined) elRangeDefault.value = -1; elRadsError.innerHTML = " OK"; try{ startRadians = eval(elStartRadians.value); targetRadians = eval(elTargetRadians.value); if(mode == "bignumber") { //if(targetRadians instanceof BigNumber) { // No trig functions + precision(15) radianSweep = targetRadians.minus(startRadians); actualDistance = ((radianSweep.pow(2)).plus(1)).sqrt().times(radianSweep).plus( math_asinh(Number(radianSweep)).toPrecision(15) // targetRadians.asinh() ).div(radianSweep.times(2)); } else if(mode == "decimal") { // if(targetRadians instanceof Decimal) { // Decimal has asinh() + arbitrary precision radianSweep = targetRadians.minus(startRadians); actualDistance = ((radianSweep.pow(2)).plus(1)).sqrt().times(radianSweep).plus( radianSweep.asinh() ).div(radianSweep.times(2)); } else { if(mode == "numeric") { // numeric result comes in as an array // no asinh() radianSweep = numeric.sub(targetRadians, startRadians); actualDistance = numeric.sqrt(numeric.add(numeric.pow(radianSweep, 2), 1)); actualDistance = numeric.mul(actualDistance, radianSweep); actualDistance = numeric.add(actualDistance, math_asinh(Number(radianSweep))); actualDistance = numeric.div(actualDistance, numeric.mul(radianSweep, 2)); } else { // just normal math radianSweep = targetRadians - startRadians; actualDistance = (radianSweep * Math.sqrt(1+Math.pow(radianSweep, 2)) + math_asinh(radianSweep) // asinh(targetRadians) ) / (2*radianSweep); } } // look for type elRadius.innerHTML = "Canvas radius: "+r + " Target Length: " + actualDistance;// showRTargetLen(r, actualDistance); addDebugLine("init", {"mode": mode, "radius" : r, 'centerX' : centerX, 'centerY' : centerY, 'PI': PI, 'twoPI': twoPI, "startRadians" : startRadians, "targetRadians": targetRadians, "radianSweep": radianSweep, "targetLength" : actualDistance}); flushDebugLines(); } catch(e) { elRadsError.innerHTML="* ERR * [" + e + "]"; } } // radsChange function addDebugLine(label, obj) { if(!debugMode) return false; var s = label + ": "; s += JSON.stringify(obj); debugBuffer += s + "\n"; } function flushDebugLines() { if(!debugMode) return false; elDebug.innerHTML += debugBuffer; debugBuffer = ""; } function addOutputLine(s){ var div = document.createElement("div"); div.innerHTML = s;// + "
"; //elOutput.prepend(div); // not on all browsers elOutput.insertBefore(div, elOutput.childNodes[0]); } // Run/Stop button clicked function runstop() { if(running) { stopRequested = true; currentSteps=stopSteps; rotation = targetRadians; } else { stopRequested = false; running = true; btnRunStop.innerHTML = "Stop"; firstRun = true; // rudimentary fix for empty stop steps, not trying to error check too deeply startSteps = eval(elStartSteps.value); if(elStopSteps.value === "") elStopSteps.value = '0'; stopSteps = startSteps + eval(elStopSteps.value); currentSteps = startSteps; // batches get a separator var tmp = (stopSteps != startSteps); // single to batch also gets an hr if(addAnHR === false && tmp === true) addOutputLine("

"); addAnHR = tmp; // no harm in letting events run setTimeout(iterator, 1000/frameRate); } } // runs selected draw function asynchronously var addAnHR; var nextSecond = 0, iterCount = 0; function iterator(){ var curTime = Date.now(); if(curTime > nextSecond){ actualFPS = iterCount; iterCount = 0; nextSecond = curTime + 1000; } iterCount++; // step in -y direction, rotate, repeat fnDraw(currentSteps); if(running && currentSteps <= stopSteps) { setTimeout(iterator, 1000/frameRate); } else { btnRunStop.innerHTML = "Run"; running = false; if(addAnHR) addOutputLine("

"); nextSecond=0;iterCount=0;actualFPS="--"; } updateFPS(); } /************************************* Library Initializers - paired with Runners - feels like I should be able to consolidate these **************************************/ function math_init(){ centerX = cvs.width / 2; centerY = cvs.width / 2; r = centerX; PI = 4 * Math.atan(1); // 3.1415926535897932384; twoPI = 2*PI; var p = parms.math; elStartSteps.value = p.startSteps; // 10000 and 10 runs just fine (but only for math, 1000+ is slow for others) elStopSteps.value = p.stopSteps; setRangeDefault(); // calls radsChange(); //radsChange(); addOutputLine("^^ Math library selected ^^"); } function bignumber_init() { centerX = new BigNumber(cvs.width).dividedBy(2); centerY = new BigNumber(cvs.height).dividedBy(2); r = centerX; // no trig functions in BigNumber and need 15 digits precision PI = new BigNumber(3.14159265358979); // ...32384... twoPI = PI.times(2); var p = parms.bignumber; elStartSteps.value = p.startSteps; elStopSteps.value = p.stopSteps; //elStartRadians.value= p.startRadians; //elTargetRadians.value = p.targetRadians; setRangeDefault(); //radsChange(); addOutputLine("^^ BigNumber library selected ^^"); } function decimal_init() { centerX = new Decimal(cvs.width).dividedBy(2); centerY = new Decimal(cvs.height).dividedBy(2); r = centerX; // Only 15 digits... // PI = new Decimal(4).times(Decimal.atan(1)); // ...but this is 50 PI = new Decimal("3.1415926535897932384626433832795028841971693993751"); twoPI = PI.times(2); var p = parms.decimal; elStartSteps.value = p.startSteps; elStopSteps.value = p.stopSteps; //elStartRadians.value= p.startRadians; //elTargetRadians.value = p.targetRadians; setRangeDefault(); //radsChange(); addOutputLine("^^ Decimal library selected ^^"); } function numeric_init() { //numeric.precision = 50; // this only affects prettyPrint centerXY = new numeric.T(numeric.div(cvs.width, 2), numeric.div(cvs.height, 2)); // for arc centerX = centerXY.x; centerY = centerXY.y; r = centerXY.x; // freezes the script // r = new numeric.T(numeric.mul(centerY, 1)); // 15 digits PI = numeric.mul(4, numeric.atan([1])); twoPI = numeric.mul(PI, 2); var p = parms.numeric; elStartSteps.value = p.startSteps; elStopSteps.value = p.stopSteps; //elStartRadians.value= p.startRadians; //elTargetRadians.value = p.targetRadians; setRangeDefault(); // radsChange(); addOutputLine("^^ Numeric library selected ^^"); } /************************************* Library Rotators - paired with Runners - feels like I should be able to consolidate these ************************************** * Rotation matrix Coordinate * [ cos(theta) sin(theta) ] [ X ] * [ ] * [ ] * [ -sin(theta) cos(theta) ] [ Y ] * * cx,cy : rotation center * move "-" to other sin() to switch direction. */ function math_rotate(cx,cy,x,y,rads){ var COS=Math.cos(rads); var SIN=Math.sin(rads); var xx=COS*(x-cx) + SIN*(y-cy) + cx; var yy=COS*(y-cy) - SIN*(x-cx) + cy; // swapped order for easy access to negative return [xx,yy]; } function bignumber_rotate(cx,cy,x,y,rads){ // can't load more than 15 digits into BigNumber // BigNumber doesn't have trig functions var COS=new BigNumber(Math.cos(rads).toPrecision(15)); var SIN=new BigNumber(Math.sin(rads).toPrecision(15)); var xx=COS.times(x.minus(cx)).plus(SIN.times(y.minus(cy))).plus(cx); var yy=COS.times(y.minus(cy)).minus(SIN.times(x.minus(cx))).plus(cy); return [xx,yy]; } function decimal_rotate(cx,cy,x,y,rads){ var COS=new Decimal(rads).cos(); var SIN=new Decimal(rads).sin(); var xx=COS.times(x.minus(cx)).plus(SIN.times(y.minus(cy))).plus(cx); var yy=COS.times(y.minus(cy)).minus(SIN.times(x.minus(cx))).plus(cy); return [xx,yy]; } function numeric_rotate(cxy,xy,rads) { var COS=numeric.cos([rads]); var SIN=numeric.sin([rads]); var mat = [ [COS, SIN], [-SIN, COS], ]; // matrix dot product var dotProduct = numeric.dotMV(mat, [numeric.sub(xy.x, cxy.x), numeric.sub(xy.y, cxy.y)]); // recenter dotProduct = numeric.add(dotProduct, [cxy.x, cxy.y]); return dotProduct; } /************************************* Library RUNNERS - Feels like I should be able to condense these **************************************/ function math_runner(steps){ wipeAndCircleCanvas(); startTime = Date.now(); rotation = startRadians; totalDistance = 0.0; realX = centerX; realY = centerY; var stepsz = r/steps; // how far I move -y var radsz = radianSweep / steps; // how far each y move rotates var temp = math_rotate(centerX, centerY, realX, realY, rotation); thisX = temp[0]; thisY = temp[1]; integerStep = 0; while(true) { if(steps>=25) { ctx.strokeStyle="crimson"; } ctx.moveTo(Number(thisX), Number(thisY)); //if(useBadMath) { // causes a large amount of deviation, apparent if range is from PI to 3PI vs -PI to PI if(integerStep >0){ realX += stepsz; rotation += radsz; } addDebugLine("increment", {"realY": realY, "rotation": rotation, "mode": "badMath" }); /* } else { realX = centerX + integerStep * stepsz; rotation = startRadians + integerStep * radsz; addDebugLine("increment", {"realX": realX, "rotation": rotation, "mode" : "integerStep " + integerStep}); }*/ if(rotation>targetRadians) rotation=targetRadians; lastX = thisX; lastY = thisY; var temp = math_rotate(centerX, centerY, realX, realY, rotation); thisX = temp[0]; thisY = temp[1]; var xsq = Math.pow(thisX - lastX, 2); var ysq = Math.pow(thisY - lastY, 2); var dist = Math.sqrt(xsq + ysq); totalDistance += dist; ctx.lineTo(Number(thisX), Number(thisY)); addDebugLine("distance", {"thisDistance": dist, "distanceSoFar": totalDistance, "lastXSquared": xsq, "lastYSquared":ysq, "rotation == targetRadians" : rotation == targetRadians}); if(stopRequested || rotation >= targetRadians){ //if(integerStep != steps ) alert("Only got to step " + integerStep + " before exceeded target radians") ; break; } integerStep += 1; if(integerStep > steps) break; } ctx.stroke(); currentSteps += 1; addOutputLine(""+ steps + ": " + totalDistance / r + " Err: " + ((actualDistance - (totalDistance/r))/actualDistance*100).toPrecision(2) + "%" + "" + timeElapsed()); flushDebugLines(); } function bignumber_runner(stepz) { if(firstRun) { wipeAndCircleCanvas(); startTime = Date.now(); firstRun = false; steps = new BigNumber(stepz); rotation = startRadians; totalDistance = new BigNumber(0.0); realX = centerX; realY = centerY; stepsz = r.dividedBy(steps); radsz= radianSweep.dividedBy(steps); temp = bignumber_rotate(centerX, centerY, realX, realY, rotation); thisX = temp[0]; thisY = temp[1]; ctx.moveTo(Number(thisX), Number(thisY)); integerStep = 0; } if(steps.gte(20) == 1){ ctx.strokeStyle="crimson";} // gte ... >= if(useBadMath) { // causes a large amount of deviation, apparent if range is from PI to 3PI vs -PI to PI if(integerStep >0){ realX = realX.plus(stepsz); // realX += stepsz; rotation = rotation.plus(radsz); //+= radsz;*/ } } else { var tmp = new BigNumber(integerStep); // same result, both no better than badMath // realY = centerY.minus(tmp.times(stepsz)); // rotation = startRadians.plus(tmp.times(radsz)); realX = centerX.plus(stepsz.times(integerStep)); rotation = startRadians.plus(radsz.times(integerStep)); } if(rotation.gt(targetRadians) == 1) rotation=targetRadians; lastX = thisX; lastY = thisY; var temp = bignumber_rotate(centerX, centerY, realX, realY, rotation); thisX = temp[0]; thisY = temp[1]; var xsq = thisX.minus(lastX).pow(2); var ysq = thisY.minus(lastY).pow(2); var dist = (xsq.add(ysq)).sqrt(); totalDistance = totalDistance.add(dist); ctx.lineTo(Number(thisX), Number(thisY)); if(integerStep % 3 === 0) { ctx.stroke(); ctx.beginPath(); ctx.moveTo(Number(thisX), Number(thisY));} if(stopRequested || rotation.gte(targetRadians) == 1) { ctx.stroke(); currentSteps += 1; addOutputLine(""+ steps + ": " + totalDistance.div(r) + " Err: " + actualDistance.minus(totalDistance.div(r)).div(actualDistance).times(100).toPrecision(2) + "%" + timeElapsed()); firstRun = true; return true; } integerStep += 1; return false; } function decimal_runner(stepz) { if(firstRun) { wipeAndCircleCanvas(); startTime = Date.now(); firstRun = false; steps = new Decimal(stepz); rotation = startRadians; // For badmath, otherwise it's just overridden totalDistance = new Decimal(0.0); realX = centerX; realY = centerY; stepsz = r.dividedBy(steps); radsz= radianSweep.dividedBy(steps); temp = decimal_rotate(centerX, centerY, realX, realY, rotation); thisX = temp[0]; thisY = temp[1]; ctx.moveTo(Number(thisX), Number(thisY)); integerStep = 0; } if(steps.gte(20) == 1){ ctx.strokeStyle="crimson";} // gte ... >= if(integerStep % 3 === 0) { ctx.stroke(); ctx.beginPath(); ctx.moveTo(Number(thisX), Number(thisY));} if(useBadMath) { if(integerStep >0){ // causes a large amount of deviation, apparent if range is from PI to 3PI vs -PI to PI realX = realX.plus(stepsz); // realX += stepsz; rotation = rotation.plus(radsz); //+= radsz;*/ } } else { realX = centerX.plus(stepsz.times(integerStep)); rotation = startRadians.plus(radsz.times(integerStep)); } if(rotation.gt(targetRadians) == 1) rotation=targetRadians; lastX = thisX; lastY = thisY; var temp = decimal_rotate(centerX, centerY, realX, realY, rotation); thisX = temp[0]; thisY = temp[1]; var xsq = thisX.minus(lastX).pow(2); var ysq = thisY.minus(lastY).pow(2); var dist = (xsq.add(ysq)).sqrt(); totalDistance = totalDistance.add(dist); ctx.lineTo(Number(thisX), Number(thisY)); if(stopRequested || rotation.gte(targetRadians) == 1) { ctx.stroke(); currentSteps += 1; firstRun = true; addOutputLine(""+ steps + ": " + totalDistance.div(r) + " Err: " + actualDistance.minus(totalDistance.div(r)).div(actualDistance).times(100).toPrecision(2) + "%" + timeElapsed()); return true; } integerStep += 1; return false; } function numeric_runner(steps) { if(firstRun) { wipeAndCircleCanvas(); startTime = Date.now(); firstRun = false; rotation = startRadians; totalDistance = 0.0; realXY = centerXY; stepsz = numeric.div(r, steps); radsz= numeric.div(radianSweep, steps); thisXY = numeric_rotate(centerXY, realXY, rotation); ctx.moveTo(thisXY[0], thisXY[1]); integerStep = 0; } if(numeric.geq(steps, 20) === true){ ctx.strokeStyle="crimson";} // gte ... >= if(useBadMath) { // causes a large amount of deviation, apparent if range is from PI to 3PI vs -PI to PI if(integerStep >0){ var tmp = numeric.add([realXY.x, realXY.y], [stepsz, 0]); realXY = new numeric.T(tmp[0], tmp[1]); rotation = numeric.add(rotation, radsz); //+= radsz; } } else { // a little convoluted var tmp = numeric.add([centerXY.x, centerXY.y], [numeric.mul(stepsz, integerStep), 0]); realXY = new numeric.T(tmp[0], tmp[1]); rotation = numeric.add(startRadians, numeric.mul(radsz, integerStep)); } if(numeric.gt(rotation, targetRadians) === true) rotation=targetRadians; lastXY = thisXY; thisXY = numeric_rotate(centerXY, realXY, rotation); var diffs = numeric.sub(thisXY, lastXY); var dist = numeric.norm2(diffs); totalDistance = numeric.add(totalDistance, dist); ctx.lineTo(thisXY[0], thisXY[1]); if(integerStep % 3 === 0) { ctx.stroke(); ctx.beginPath(); ctx.moveTo(thisXY[0], thisXY[1]); } // weird bug related to this returning an OBJECT if(stopRequested || numeric.geq(rotation, targetRadians)[0] === true) { ctx.stroke(); currentSteps += 1; // numeric.addeq() not functional firstRun = true; addOutputLine(""+ steps + ": " + numeric.div(totalDistance, r) + " Err: " + numeric.mul(numeric.div(numeric.sub(actualDistance, numeric.div(totalDistance, r)), actualDistance), 100)[0].toPrecision(2) + "%" + timeElapsed()); return true; } integerStep += 1; return false; }

Spiral+accuracy: Math, BigNumber, Decimal, NumericJS