drafts

Author: make-github-pseudonymous-again

.jshintrc

@@ -0,0 +1,3 @@
+{
+	"esnext" : true
+}

js/src/dummy.js

@@ -0,0 +1,35 @@
+
+let _inplace = function ( split ) {
+
+	/**
+	 * In place implementation of radix sort. NOT STABLE.
+	 *
+	 * @param {function} msb takes two arguments `(key, shift)` and returns the most
+	 * significant bit of `key` shifted to the left by `shift` places.
+	 * @param {array} a The input array.
+	 * @param {int} ai Input array left offset.
+	 * @param {int} aj Input array right offset.
+	 * @param {int} si The number of places the keys are shifted before
+	 * computing the LSB.
+	 * @param {int} sj `sj-si` gives the number of symbols considered by the
+	 * sorting algorithm.
+	 */
+
+	let inplace = function ( msb , a , ai , aj , si , sj ) {
+
+		if ( si >= sj ) return ;
+
+		let pivot = split( x => msb( x , si ) , a , ai , aj ) ;
+
+		// sort according to remaining symbols
+
+		inplace( msb , a , ai , pivot , si + 1 , sj ) ;
+		inplace( msb , a , pivot + 1 , aj , si + 1 , sj ) ;
+
+	} ;
+
+	return inplace ;
+
+} ;
+
+exports._inplace = _inplace ;

js/src/inplace.js

@@ -0,0 +1,54 @@
+
+
+/**
+ * In-place, stable implementation of radix-sort for singly linked lists.
+ *
+ * @param {function} lsb takes two arguments `(key, shift)` and returns the least
+ * significant bit of `key` shifted to the right by `shift` places.
+ * @param {array} head The first node of the input list.
+ * @param {int} hi A next pointer ({ next : null }).
+ * @param {int} lo A next pointer ({ next : null }).
+ * @param {int} si The number of places the keys are shifted before
+ * computing the LSB.
+ * @param {int} sj `sj-si` gives the number of symbols considered by the
+ * sorting algorithm.
+ *
+ */
+
+let nodes = function ( lsb , head , hi , lo , si , sj ) {
+
+	if ( si >= sj ) return head ;
+
+	let _lo = lo , _hi = hi ;
+
+	while ( head !== null ) {
+
+		if ( lsb ( head.value , si ) === 0 ) _lo = _lo.next = head ;
+
+		else _hi = _hi.next = head ;
+
+		head = head.next ;
+
+	}
+
+	if ( lo.next === null ) {
+
+		head = hi.next ;
+		hi.next = null ;
+
+	}
+
+	else {
+
+		_lo.next = hi.next ;
+		head = lo.next ;
+		lo.next = null ;
+		hi.next = null ;
+
+	}
+
+	return nodes( lsb , head , hi , lo , si + 1 , sj ) ;
+
+} ;
+
+exports.nodes = nodes ;

js/src/nodes.js

@@ -0,0 +1,44 @@
+
+let _stable = function ( split ) {
+
+	/**
+	 * In place implementation of radix sort. NOT STABLE.
+	 *
+	 * @param {function} lsb takes two arguments `(key, shift)` and returns the least
+	 * significant bit of `key` shifted to the right by `shift` places.
+	 * @param {array} a The input array.
+	 * @param {int} ai Input array left offset.
+	 * @param {int} aj Input array right offset.
+	 * @param {array} b The counting array.
+	 * @param {int} bi Counting array left offset.
+	 * @param {int} bj Counting array right offset.
+	 * @param {array} c The output array.
+	 * @param {int} ci Output array left offset.
+	 * @param {int} cj Output array right offset.
+	 * @param {int} si The number of places the keys are shifted before
+	 * computing the LSB.
+	 * @param {int} sj `sj-si` gives the number of symbols considered by the
+	 * sorting algorithm.
+	 */
+
+	let stable = function ( lsb , a , ai , aj , b , bi , bj , c , ci , cj , si , sj ) {
+
+		if ( si >= sj ) return ;
+
+		split( x => lsb( x , si ) , a , ai , aj , b , bi , bj , c , ci ) ;
+
+		// reset the counting buffer
+
+		for ( let bk = bi ; bk < bj ; ++bk ) b[bk] = 0 ;
+
+		// sort according to remaining symbols
+
+		stable( lsb , c , ci , cj , b , bi , bj , a , ai , aj , si + 1 , sj ) ;
+
+	} ;
+
+	return stable ;
+
+} ;
+
+exports._stable = _stable ;

js/src/stable.js

@@ -0,0 +1,40 @@
+
+
+/**
+ * In-place, stable implementation of radix-sort for a stack.
+ *
+ * @param {function} lsb takes two arguments `(key, shift)` and returns the least
+ * significant bit of `key` shifted to the right by `shift` places.
+ * @param {array} main The input stack..
+ * @param {int} hi An empty stack.
+ * @param {int} lo An empty stack.
+ * @param {int} si The number of places the keys are shifted before
+ * computing the LSB.
+ * @param {int} sj `sj-si` gives the number of symbols considered by the
+ * sorting algorithm.
+ *
+ */
+
+let stack = function ( lsb , main , hi , lo , si , sj ) {
+
+	if ( si >= sj ) return ;
+
+	while ( !main.empty( ) ) {
+
+		let key = main.pop( ) ;
+
+		if ( lsb ( key , si ) === 0 ) lo.push( key ) ;
+
+		else hi.push( key ) ;
+
+	}
+
+	while ( !hi.empty( ) ) main.push( hi.pop( ) ) ;
+
+	while ( !lo.empty( ) ) main.push( lo.pop( ) ) ;
+
+	stack( lsb , main , hi , lo , si + 1 , sj ) ;
+
+} ;
+
+exports.stack = stack ;