# negative modulo (v7)

## Preparation HTML

``````<table id="tableRes"></table>
<script>
var dividends = [0, 1, 3, 16, -3, -7];
var divisors = [2, 4, 9];

function amod(n, d) {
return n - (d * Math.floor(n / d));
}

function amodFast(n, d) {
var q = ~~(n / d);
if (n < 0) q = q - 1;
return n - (d * q);
}

function amodFaster(n, d) {
var q = ~~(n / d);
(n < 0) ? --q : q;
return n - (d * q);
}

function bmod(n, d) {
var remain = n % d;
return remain >= 0 ? remain : remain + d;
};

function mmod(n, d) {
return ((n % d) + d) % d;
}

function qmod(n, d) {
// works only when n is a power of 2
return n & (d - 1);
}

var testFunction = function (f) {
Benchmark.forEach(divisors, function (d) {
Benchmark.forEach(dividends, function (n) {
f(n, d);
});
});
};

var tableRes = \$('#tableRes');

var firstTr = \$('<tr>').appendTo(tableRes);
\$('<th>').text('dividend').appendTo(firstTr);
\$('<th>').text('divisor').appendTo(firstTr);
ui.each(function(b, index) {
if (index > 0) {
\$('<th>').text(b.name).appendTo(firstTr);
}
});
}

Benchmark.forEach(divisors, function (d) {
Benchmark.forEach(dividends, function (n) {
var tr = \$('<tr>').appendTo(tableRes);
\$('<th>').text(n).appendTo(tr);
\$('<th>').text(d).appendTo(tr);
var firstResult = null;
ui.each(function(b, index) {
fnName = b.fn.split('testFunction(')[1].split(');')[0];
var result = eval(fnName + '(' + n + ',' + d + ')')
if (index === 0) {
firstResult = result;
} else {
\$('<th>').text(result).addClass(firstResult === result ? 'matched' : 'unmatched').appendTo(tr);
}
});
});
});
}

</script>

<style>
.matched {
background-color: green;
}
.unmatched {
background-color: red;
}
</style>``````

## Test runner

Testing in
TestOps/sec
amodFast
``````// var q = ~~(n / d);
// if (n < 0) q = q - 1;
// return n - (d * q);
testFunction(amodFast);``````
bmod
``````// var remain = n % d;
// return remain >= 0 ? remain : remain + d;
testFunction(bmod);``````
mmod
``````// ((n % d) + d) % d
testFunction(mmod);``````
qmod
``````// n & (d - 1)
// WARNING: n should be a power of 2
testFunction(qmod);``````
amodFaster
``````// var q = ~~(n / d);
// (n < 0) ? --q : q;
// return n - (d * q);
testFunction(amodFaster);``````
``````// 1st test always win, so this is one is repeated
``````// n - (d * Math.floor(n / d))