feat(decimal): the factory takes decimal and normalise returns decimal

README.md

@@ -13,13 +13,14 @@ Rescale data
 ## Usage
 
 ```js
-var rescale = require('rescale')(require('floating-adapter')).rescale;
+var Decimal = require('linear-arbitrary-precision')(require('floating-adapter'));
+var rescale = require('rescale')(Decimal).rescale;
 
-rescale(-1); // => -1
-rescale(2.5, [0, 5]); // => 0.5 as [0, 1] is the default new scale
+rescale(-1); // => Decimal -1
+rescale(2.5, [0, 5]); // => Decimal 0.5 as [0, 1] is the default new scale
 
-rescale(-1, [-3, 5], [10, 20]); // => 12.5
-rescale(40, [0, 100], [32, 212]); // => 104
+rescale(-1, [-3, 5], [10, 20]); // => Decimal 12.5
+rescale(40, [0, 100], [32, 212]); // => Decimal 104
 ```
 
 See [spec](test/spec.js).

package.json

@@ -30,12 +30,13 @@
     "gulp-coveralls": "^0.1.3",
     "gulp-istanbul": "^0.6.0",
     "gulp-mocha": "^2.0.0",
+    "linear-arbitrary-precision": "^3.0.2",
     "rimraf": "^2.3.2",
     "should": "^5.0.0"
   },
   "dependencies": {
-    "linear-arbitrary-precision": "^3.0.2",
     "lodash.isundefined": "^3.0.1",
-    "normalise": "^6.0.0"
+    "normalise": "^7.0.0",
+    "scale-normalised": "^7.0.0"
   }
 }

src/rescale.js

@@ -2,27 +2,21 @@
 
 'use strict';
 
-var arbitraryPrecision = require('linear-arbitrary-precision');
 var isUndefined = require('lodash.isundefined');
 var normaliseFactory = require('normalise');
+var scaleFactory = require('scale-normalised');
 
-module.exports = function factory(adapter) {
-  var Decimal = arbitraryPrecision(adapter);
-  var normalise = normaliseFactory(adapter).normalise;
+module.exports = function factory(Decimal) {
+  var normalise = normaliseFactory(Decimal).normalise;
+  var scale = scaleFactory(Decimal).scale;
   var api = {};
 
   api.rescale = function rescale(x, oldScale, newScale) {
     if (isUndefined(newScale)) {
       return normalise(x, oldScale);
     }
 
-    var newScale0 = new Decimal(newScale[0].toString());
-    var oldScale0 = new Decimal(oldScale[0].toString());
-
-    return Number(
-      new Decimal(x.toString()).minus(oldScale0).times(new Decimal(newScale[1].toString()).minus(newScale0))
-        .div(new Decimal(oldScale[1].toString()).minus(oldScale0)).plus(newScale0)
-    );
+    return scale(normalise(x, oldScale), newScale);
   };
 
   return api;

test/spec.js

@@ -4,43 +4,49 @@
 
 require('should');
 
-var rescaleFactory = require('../src/rescale');
+
+var arbitraryPrecision = require('linear-arbitrary-precision');
 var bigjsAdapter = require('bigjs-adapter');
 var floatingAdapter = require('floating-adapter');
+var rescaleFactory = require('../src/rescale');
 
 describe('rescaling', function() {
   describe('without scales', function() {
-    var rescale = rescaleFactory(floatingAdapter).rescale;
+    var Decimal = arbitraryPrecision(floatingAdapter);
+    var rescale = rescaleFactory(Decimal).rescale;
 
     it('should be the identity', function() {
-      rescale(Math.E).should.be.exactly(Math.E);
-      rescale(-4).should.be.exactly(-4);
+      rescale(Math.E).val().val().should.be.exactly(Math.E);
+      rescale(-4).val().val().should.be.exactly(-4);
     });
   });
 
   describe('without a new scale', function() {
-    var rescale = rescaleFactory(floatingAdapter).rescale;
+    var Decimal = arbitraryPrecision(floatingAdapter);
+    var rescale = rescaleFactory(Decimal).rescale;
 
     it('should also delegate to normalise', function() {
-      rescale(0.4, [0.3, 0.5]).should.be.exactly(0.5000000000000001);
-      rescale(-3, [-5, 1]).should.be.exactly(1/3);
+      rescale(0.4, [0.3, 0.5]).val().val().should.be.exactly(0.5000000000000001);
+      rescale(-3, [-5, 1]).val().val().should.be.exactly(1/3);
     });
   });
 
   describe('with scales', function() {
     describe('when arbitrary precision is unavailable', function() {
-      var rescale = rescaleFactory(floatingAdapter).rescale;
+      var Decimal = arbitraryPrecision(floatingAdapter);
+      var rescale = rescaleFactory(Decimal).rescale;
 
       it('should compose normalise and scale', function() {
-        rescale(0.4, [0.3, 0.5], [0.1, 0.2]).should.be.exactly(0.15000000000000002);
+        rescale(0.4, [0.3, 0.5], [0.1, 0.2]).val().val().should.be.exactly(0.15000000000000002);
       });
     });
 
     describe('when arbitrary precision is available', function() {
-      var rescale = rescaleFactory(bigjsAdapter).rescale;
+      var Decimal = arbitraryPrecision(bigjsAdapter);
+      var rescale = rescaleFactory(Decimal).rescale;
 
       it('should rescale with arbitrary precision', function() {
-        rescale(0.4, [0.3, 0.5], [0.1, 0.2]).should.be.exactly(0.15);
+        rescale(0.4, [0.3, 0.5], [0.1, 0.2]).val().eq(new Decimal('0.15')).should.be.exactly(true);
       });
     });
   });