Simple performance test of sum-like functions

node_results.md

for 4000 iterations, on node:

• sumHaskellLike: 39.031886
• sumJSFunctional: 15.758613999999994
• sumJSLoop: 3.674158999999996

Testing_Sum.js

// accurate time resolution
// stolen from https://github.com/myrne/performance-now
const now = (function(){
	if((typeof performance !== "undefined" && performance !== null) && performance.now) {
		return function nowPerformance() {
			return performance.now();
		};
	}
	if ((typeof process !== "undefined" && process !== null) && process.hrtime) {
		let hrtime = process.hrtime;
		let loadTime = getNanoSeconds();
		function getNanoSeconds(){
			var hr;
			hr = hrtime();
			return hr[0] * 1e9 + hr[1];
		};
		return function nowHrTime(){
			return (getNanoSeconds() - loadTime) / 1e6;
		};
	}
	if (Date.now) {
		let loadTime = Date.now();
		return function nowDate(){
			return Date.now() - loadTime;
		};
	}
	let loadTime = new Date().getTime();
	return function nowDefault() {
		return new Date().getTime() - loadTime;
	};
})();

function isEmpty(xs) {
	return xs.length === 0;
}

function sumHaskellLike(x, ...xs) {
	return isEmpty(xs) ? x : x + sumHaskellLike(...xs);
}

function sumJSFunctional(...xs) {
	return xs.reduce((x, total) => x + total);
}

function sumJSLoop(...xs){
	var sum = 0, i = 0, l = xs.length;
	for(i;i<l;i++){
		sum+=xs[i];
	}
	return sum;
}

function test(iterations,fn,...n){
	let t1 = now();
	let result;
	while(iterations--){
		result = fn(...n);
	}
	if(result!=210){throw new Error('result is incorrect');}
	let t2 = now();
	console.log(fn.name+':',(t2-t1));
}

const iterations = 4000;

test(iterations,sumHaskellLike,1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20);
test(iterations,sumJSFunctional,1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20);
test(iterations,sumJSLoop,1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20);

Testing_Sum_ES5.js

"use strict";
//transpiled Testing_Sum.js
var now = (function () {
	if (typeof performance !== "undefined" && performance !== null && performance.now) {
		return function nowPerformance() {
			return performance.now();
		};
	}
	if (typeof process !== "undefined" && process !== null && process.hrtime) {
		var _ret = (function () {
			var getNanoSeconds = function () {
				var hr;
				hr = hrtime();
				return hr[0] * 1000000000 + hr[1];
			};

			var hrtime = process.hrtime;
			var loadTime = getNanoSeconds();
			;
			return {
				v: function nowHrTime() {
					return (getNanoSeconds() - loadTime) / 1000000;
				}
			};
		})();

		if (typeof _ret === "object") return _ret.v;
	}
	if (Date.now) {
		var _ret2 = (function () {
			var loadTime = Date.now();
			return {
				v: function nowDate() {
					return Date.now() - loadTime;
				}
			};
		})();

		if (typeof _ret2 === "object") return _ret2.v;
	}
	var loadTime = new Date().getTime();
	return function nowDefault() {
		return new Date().getTime() - loadTime;
	};
})();

function isEmpty(xs) {
	return xs.length === 0;
}

function sumHaskellLike(x) {
	for (var _len = arguments.length, xs = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
		xs[_key - 1] = arguments[_key];
	}

	return isEmpty(xs) ? x : x + sumHaskellLike.apply(undefined, xs);
}

function sumJSFunctional() {
	for (var _len2 = arguments.length, xs = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
		xs[_key2] = arguments[_key2];
	}

	return xs.reduce(function (x, total) {
		return x + total;
	});
}

function sumJSLoop() {
	for (var _len3 = arguments.length, xs = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
		xs[_key3] = arguments[_key3];
	}

	var sum = 0,
	    i = 0,
	    l = xs.length;
	for (i; i < l; i++) {
		sum += xs[i];
	}
	return sum;
}

function test(iterations, fn) {
	for (var _len4 = arguments.length, n = Array(_len4 > 2 ? _len4 - 2 : 0), _key4 = 2; _key4 < _len4; _key4++) {
		n[_key4 - 2] = arguments[_key4];
	}

	var t1 = now();
	var result = undefined;
	while (iterations--) {
		result = fn.apply(undefined, n);
	}
	if (result != 210) {
		throw new Error("result is incorrect");
	}
	var t2 = now();
	console.log(fn.name + ":", t2 - t1);
}

var iterations = 4000;

test(iterations, sumHaskellLike, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20);
test(iterations, sumJSFunctional, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20);
test(iterations, sumJSLoop, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20);