Fix for #3

Author: lemire

FastIntegerCompression.js

@@ -21,6 +21,7 @@
 function FastIntegerCompression() {
 }
 
+// private function
 function bytelog(val) {
   if (val < (1 << 7)) {
     return 1;
@@ -34,7 +35,19 @@ function bytelog(val) {
   return 5;
 }
 
+// private function
+function zigzag_encode(val) {
+  return (val + val) ^ (val >> 31);;
+}
+
+// private function
+function zigzag_decode(val) {
+  return  (val >> 1) ^ (- (val & 1));
+}
+
+
 // compute how many bytes an array of integers would use once compressed
+// input is expected to be an array of non-negative integers
 FastIntegerCompression.computeCompressedSizeInBytes = function(input) {
   var c = input.length;
   var answer = 0;
@@ -45,7 +58,20 @@ FastIntegerCompression.computeCompressedSizeInBytes = function(input) {
 };
 
 
-// compress an array of integers, return a compressed buffer (as an ArrayBuffer)
+// compute how many bytes an array of integers would use once compressed
+// input is expected to be an array of integers, some of them can be negative
+FastIntegerCompression.computeCompressedSizeInBytesSigned = function(input) {
+  var c = input.length;
+  var answer = 0;
+  for(var i = 0; i < c; i++) {
+    answer += bytelog(zigzag_encode(input[i]));
+  }
+  return answer;
+};
+
+// Compress an array of integers, return a compressed buffer (as an ArrayBuffer).
+// It is expected that the integers are non-negative: the caller is responsible
+// for making this check. Floating-point numbers are not supported.
 FastIntegerCompression.compress = function(input) {
   var c = input.length;
   var buf = new ArrayBuffer(FastIntegerCompression.computeCompressedSizeInBytes(input));
@@ -89,6 +115,8 @@ FastIntegerCompression.computeHowManyIntegers = function(input) {
   return c - count;
 }
 // uncompress an array of integer from an ArrayBuffer, return the array
+// it is assumed that they were compressed using the compress function, the caller
+// is responsible for ensuring that it is the case.
 FastIntegerCompression.uncompress = function(input) {
   var array = []
   var inbyte = new Int8Array(input);
@@ -127,6 +155,80 @@ FastIntegerCompression.uncompress = function(input) {
 };
 
 
+// Compress an array of integers, return a compressed buffer (as an ArrayBuffer).
+// The integers can be signed (negative), but floating-point values are not supported.
+FastIntegerCompression.compressSigned = function(input) {
+  var c = input.length;
+  var buf = new ArrayBuffer(FastIntegerCompression.computeCompressedSizeInBytesSigned(input));
+  var view   = new Int8Array(buf);
+  var pos = 0;
+  for(var i = 0; i < c; i++) {
+    var val = zigzag_encode(input[i]);
+    if (val < (1 << 7)) {
+      view[pos++] = val ;
+    } else if (val < (1 << 14)) {
+      view[pos++] = (val & 0x7F) | 0x80;
+      view[pos++] = val >>> 7;
+    } else if (val < (1 << 21)) {
+      view[pos++] = (val & 0x7F) | 0x80;
+      view[pos++] = ( (val >>> 7) & 0x7F ) | 0x80;
+      view[pos++] = val >>> 14;
+    } else if (val < (1 << 28)) {
+      view[pos++] = (val & 0x7F ) | 0x80 ;
+      view[pos++] = ( (val >>> 7) & 0x7F ) | 0x80;
+      view[pos++] = ( (val >>> 14) & 0x7F ) | 0x80;
+      view[pos++] = val >>> 21;
+    } else {
+      view[pos++] = ( val & 0x7F ) | 0x80;
+      view[pos++] = ( (val >>> 7) & 0x7F ) | 0x80;
+      view[pos++] = ( (val >>> 14) & 0x7F ) | 0x80;
+      view[pos++] = ( (val >>> 21) & 0x7F ) | 0x80;
+      view[pos++] = val >>> 28;
+    }
+  }
+  return buf;
+};
+
+// uncompress an array of integer from an ArrayBuffer, return the array
+// it is assumed that they were compressed using the compressSigned function, the caller
+// is responsible for ensuring that it is the case.
+FastIntegerCompression.uncompressSigned = function(input) {
+  var array = []
+  var inbyte = new Int8Array(input);
+  var end = inbyte.length;
+  var pos = 0;
+  while (end > pos) {
+        var c = inbyte[pos++];
+        var v = c & 0x7F;
+        if (c >= 0) {
+          array.push(zigzag_decode(v))
+          continue;
+        }
+        c = inbyte[pos++];
+        v |= (c & 0x7F) << 7;
+        if (c >= 0) {
+          array.push(zigzag_decode(v))
+          continue;
+        }
+        c = inbyte[pos++];
+        v |= (c & 0x7F) << 14;
+        if (c >= 0) {
+          array.push(zigzag_decode(v))
+          continue;
+        }
+        c = inbyte[pos++];
+        v |= (c & 0x7F) << 21;
+        if (c >= 0) {
+          array.push(zigzag_decode(v))
+          continue;
+        }
+        c = inbyte[pos++];
+        v |= c << 28;
+        array.push(zigzag_decode(v))
+  }
+  return array;
+};
+
 ///////////////
 
 module.exports = FastIntegerCompression;

README.md

@@ -3,7 +3,7 @@
 [![codebeat badge](https://codebeat.co/badges/fbff9479-9394-40c6-b12d-8c6b666c115e)](https://codebeat.co/projects/github-com-lemire-fastintegercompression-js)
 
 This is an integer compression library in JavaScript, useful for work on indexes.
-Given an array of small non-negative integers, it produces an ArrayBuffer that uses far fewer bytes
+Given an array of small integers, it produces an ArrayBuffer that uses far fewer bytes
 than the original (using VByte compression). It assumes a modern JavaScript engine with
 typed arrays.
 
@@ -18,6 +18,17 @@ From the compressed data, you can later recover the original  array quickly
    var back = FastIntegerCompression.uncompress(buf); // gets back [10,100000,65999,10,10,0,1,1,2000]
 ``` 
 
+By default, non-negative integers are expected. If you have signed (negative and positive) integers, then you must use distinct functions since we need to code the sign bit:
+
+
+```javascript
+   // var FastIntegerCompression = require("fastintcompression");// if you use node
+   var array = [10,100000,65999,10,10,0,-1,-1,-2000];
+   var buf = FastIntegerCompression.compressSigned(array);
+   var back = FastIntegerCompression.uncompressSigned(buf); // gets back [10,100000,65999,10,10,0,-1,-1,-2000]
+``` 
+
+
 You can install the library under node with the command line
 ```bash
    npm install fastintcompression

package.json

@@ -22,7 +22,7 @@
   "homepage": "https://github.com/lemire/FastIntegerCompression.js#readme",
   "devDependencies": {
     "benchmark": "~1.0.0",
-    "mocha": "^2.3.4"
+    "mocha": "^2.5.3"
   },
   "author": "Daniel Lemire <lemire@gmail.com> (http://lemire.me/en/)"
 }

unit/basictests.js

@@ -24,4 +24,13 @@ describe('FastIntegerCompression', function() {
   });
 
 
+
+  it('Testing simple compression (signed)', function() {
+    var array = [10,100000,65999,10,10,0,-1,-1,-2000];
+    var buf = FastIntegerCompression.compressSigned(array);
+    if(! FastIntegerCompression.computeHowManyIntegers(buf) == array.length) throw "bad count";
+    var back = FastIntegerCompression.uncompressSigned(buf);
+    if(!arraysEquals(array,back)) throw "bad";
+
+  });
 });