feat(package): initial commit

Author: jedwards1211

.eslintrc

@@ -5,6 +5,7 @@
   "ecmaVersion": 5,
   "env": {
     "es6": false,
-    "shared-node-browser": true
+    "shared-node-browser": true,
+    "commonjs": true
   }
 }

README.md

@@ -7,3 +7,54 @@
 
 computes floor and ceiling for any modulus, not just 1
 
+```
+node
+> require('mod-floor-ceiling').modFloor(3.8, 1.7)
+3.4
+> require('mod-floor-ceiling').modFloor(3.4, 1.7)
+3.4
+> require('mod-floor-ceiling').modCeiling(-17.8, 2.5)
+-17.5
+> require('mod-floor-ceiling').modLower(15, 5)
+10
+> require('mod-floor-ceiling').modLower(16, 5)
+15
+> require('mod-floor-ceiling').modHigher(15, 5)
+20
+> require('mod-floor-ceiling').modHigher(14, 5)
+15
+
+```
+
+## Usage
+
+```
+npm install mod-floor-ceiling
+```
+
+### `modFloor(value: number, modulus: number, anchor?: number = 0): number`
+
+Returns the greatest (closest to positive infinity) multiple of `modulus` that is `<= value`.
+
+### `modCeiling(value: number, modulus: number, anchor?: number = 0): number`
+
+Returns the least (closest to negative infinity) multiple of `modulus` that is `>= value`.
+
+### `modLower(value: number, modulus: number, anchor?: number = 0): number`
+
+Returns the greatest (closest to positive infinity) multiple of `modulus` that is `< value`.
+
+### `modHigher(value: number, modulus: number, anchor?: number = 0): number`
+
+Returns the greatest (closest to positive infinity) multiple of `modulus` that is `> value`.
+
+### What is `anchor`?
+
+**Anchor controls the offset of multiples of modulus.**
+
+For example, with a modulus of 3 and the default anchor of 0, possible return values include -6, -3, 0, 3, 6, etc.
+
+But with anchor of 1, possible return values include -5, -2, 1, 4, 7, etc.
+
+It's simple; `modFloor(value, modulus, anchor)` just computes `anchor + modFloor(value - anchor, modulus)`.
+

lib/index.js

@@ -1,2 +1,59 @@
-/* eslint-disable no-console, no-undef */
-console.log('Hello world!')
+/**
+ * @param {number} value - the number to get the floor of
+ * @param {number} modulus - the modulus of division
+ * @param {number} [anchor=0] - controls the offset of multiples of modulus.  For example, with a modulus of 3
+ * and an anchor of 1, possible return values include -2, 1, 4, 7, etc.
+ * @return the greatest (closest to positive infinity) multiple of modulus that is <= value.
+ */
+function modFloor(value, modulus, anchor) {
+  if (anchor) return anchor + modFloor(value - anchor, modulus)
+  if (value < 0.0) return -modCeiling(-value, modulus)
+  modulus = Math.abs(modulus)
+  return value - value % modulus
+}
+
+/**
+ * @param {number} value - the number to get the ceiling of
+ * @param {number} modulus - the modulus of division
+ * @param {number} [anchor=0] - controls the offset of multiples of modulus.  For example, with a modulus of 3
+ * and an anchor of 1, possible return values include -2, 1, 4, 7, etc.
+ * @return the least (closest to negative infinity) multiple of modulus that is >= value.
+ */
+function modCeiling(value, modulus, anchor) {
+  if (anchor) return anchor + modCeiling(value - anchor, modulus)
+  if (value < 0.0) return -modFloor(-value, modulus)
+  modulus = Math.abs(modulus)
+  var rem = value % modulus
+  if (rem !== 0.0) value += modulus - rem
+  return value
+}
+
+/**
+ * @param {number} value - any number
+ * @param {number} modulus - the modulus of division
+ * @param {number} [anchor=0] - controls the offset of multiples of modulus.  For example, with a modulus of 3
+ * and an anchor of 1, possible return values include -2, 1, 4, 7, etc.
+ * @return the greatest (closest to positive infinity) multiple of modulus that is < value.
+ */
+function modLower(value, modulus, anchor) {
+  var result = modFloor(value, modulus, anchor)
+  return result < value ? result : result - modulus
+}
+
+/**
+ * @param {number} value - any number
+ * @param {number} modulus - the modulus of division
+ * @param {number} [anchor=0] - controls the offset of multiples of modulus.  For example, with a modulus of 3
+ * and an anchor of 1, possible return values include -2, 1, 4, 7, etc.
+ * @return the least (closest to negative infinity) multiple of modulus that is > value.
+ */
+function modHigher(value, modulus, anchor) {
+  var result = modCeiling(value, modulus, anchor)
+  return result > value ? result : result + modulus
+}
+
+exports.modFloor = modFloor
+exports.modCeiling = modCeiling
+exports.modLower = modLower
+exports.modHigher = modHigher
+

lib/index.js.flow

@@ -1,3 +1,7 @@
 // @flow
 
-declare module.exports: {};
+declare export function modFloor(value: number, modulus: number, anchor?: number): number;
+declare export function modCeiling(value: number, modulus: number, anchor?: number): number;
+declare export function modLower(value: number, modulus: number, anchor?: number): number;
+declare export function modHigher(value: number, modulus: number, anchor?: number): number;
+

test/index.js

@@ -1,8 +1,118 @@
-require('../lib')
+// @flow
 
-describe('test setup', function () {
-  it('works', function () {
+var describe = require('mocha').describe
+var it = require('mocha').it
+var expect = require('chai').expect
 
+var modFloor = require('../lib').modFloor,
+  modCeiling = require('../lib').modCeiling,
+  modLower = require('../lib').modLower,
+  modHigher = require('../lib').modHigher
+
+describe('modFloor', function () {
+  it('works for simple case', function () {
+    expect(modFloor(5, 5)).to.equal(5)
+    expect(modFloor(6, 5)).to.equal(5)
+    expect(modFloor(11, 5)).to.equal(10)
+    expect(modFloor(11, 2.5)).to.equal(10)
+    expect(modFloor(11, 3.5)).to.equal(10.5)
+  })
+  it('works with anchor', function () {
+    expect(modFloor(5, 5, -1)).to.equal(4)
+    expect(modFloor(5, 5, 1)).to.equal(1)
+    expect(modFloor(6, 5, 1)).to.equal(6)
+    expect(modFloor(6, 5, -1)).to.equal(4)
+    expect(modFloor(11, 5)).to.equal(10)
+    expect(modFloor(11, 5, 2)).to.equal(7)
+    expect(modFloor(11, 5, -2)).to.equal(8)
+  })
+  it('works with negative numbers', function () {
+    expect(modFloor(-5, 5, -1)).to.equal(-6)
+    expect(modFloor(-5, 5, 1)).to.equal(-9)
+    expect(modFloor(-6, 5, 1)).to.equal(-9)
+    expect(modFloor(-6, 5, -1)).to.equal(-6)
+    expect(modFloor(-11, 5)).to.equal(-15)
+    expect(modFloor(-11, 5, 2)).to.equal(-13)
+    expect(modFloor(-11, 5, -2)).to.equal(-12)
+  })
+})
+describe('modLower', function () {
+  it('works for simple case', function () {
+    expect(modLower(5, 5)).to.equal(0)
+    expect(modLower(6, 5)).to.equal(5)
+    expect(modLower(11, 5)).to.equal(10)
+    expect(modLower(11, 2.5)).to.equal(10)
+    expect(modLower(11, 3.5)).to.equal(10.5)
+  })
+  it('works with anchor', function () {
+    expect(modLower(5, 5, -1)).to.equal(4)
+    expect(modLower(5, 5, 1)).to.equal(1)
+    expect(modLower(6, 5, 1)).to.equal(1)
+    expect(modLower(6, 5, -1)).to.equal(4)
+    expect(modLower(11, 5)).to.equal(10)
+    expect(modLower(11, 5, 2)).to.equal(7)
+    expect(modLower(11, 5, -2)).to.equal(8)
+  })
+  it('works with negative numbers', function () {
+    expect(modLower(-5, 5, -1)).to.equal(-6)
+    expect(modLower(-5, 5, 1)).to.equal(-9)
+    expect(modLower(-6, 5, 1)).to.equal(-9)
+    expect(modLower(-6, 5, -1)).to.equal(-11)
+    expect(modLower(-11, 5)).to.equal(-15)
+    expect(modLower(-11, 5, 2)).to.equal(-13)
+    expect(modLower(-11, 5, -2)).to.equal(-12)
+  })
+})
+describe('modCeiling', function () {
+  it('works for simple case', function () {
+    expect(modCeiling(5, 5)).to.equal(5)
+    expect(modCeiling(6, 5)).to.equal(10)
+    expect(modCeiling(11, 5)).to.equal(15)
+    expect(modCeiling(11, 2.5)).to.equal(12.5)
+    expect(modCeiling(11, 3.5)).to.equal(14)
+  })
+  it('works with anchor', function () {
+    expect(modCeiling(5, 5, -1)).to.equal(9)
+    expect(modCeiling(5, 5, 1)).to.equal(6)
+    expect(modCeiling(6, 5, 1)).to.equal(6)
+    expect(modCeiling(6, 5, -1)).to.equal(9)
+    expect(modCeiling(11, 5, 2)).to.equal(12)
+    expect(modCeiling(11, 5, -2)).to.equal(13)
+  })
+  it('works with negative numbers', function () {
+    expect(modCeiling(-5, 5, -1)).to.equal(-1)
+    expect(modCeiling(-5, 5, 1)).to.equal(-4)
+    expect(modCeiling(-6, 5, 1)).to.equal(-4)
+    expect(modCeiling(-6, 5, -1)).to.equal(-6)
+    expect(modCeiling(-11, 5)).to.equal(-10)
+    expect(modCeiling(-11, 5, 2)).to.equal(-8)
+    expect(modCeiling(-11, 5, -2)).to.equal(-7)
+  })
+})
+describe('modHigher', function () {
+  it('works for simple case', function () {
+    expect(modHigher(5, 5)).to.equal(10)
+    expect(modHigher(6, 5)).to.equal(10)
+    expect(modHigher(11, 5)).to.equal(15)
+    expect(modHigher(11, 2.5)).to.equal(12.5)
+    expect(modHigher(11, 3.5)).to.equal(14)
+  })
+  it('works with anchor', function () {
+    expect(modHigher(5, 5, -1)).to.equal(9)
+    expect(modHigher(5, 5, 1)).to.equal(6)
+    expect(modHigher(6, 5, 1)).to.equal(11)
+    expect(modHigher(6, 5, -1)).to.equal(9)
+    expect(modHigher(11, 5, 2)).to.equal(12)
+    expect(modHigher(11, 5, -2)).to.equal(13)
+  })
+  it('works with negative numbers', function () {
+    expect(modHigher(-5, 5, -1)).to.equal(-1)
+    expect(modHigher(-5, 5, 1)).to.equal(-4)
+    expect(modHigher(-6, 5, 1)).to.equal(-4)
+    expect(modHigher(-6, 5, -1)).to.equal(-1)
+    expect(modHigher(-11, 5)).to.equal(-10)
+    expect(modHigher(-11, 5, 2)).to.equal(-8)
+    expect(modHigher(-11, 5, -2)).to.equal(-7)
   })
 })