DRY bits calc

dingosky · dingosky · commit 39f324fce11c · 2017-08-11T16:54:43.000-07:00
diff --git a/lib/charSet.js b/lib/charSet.js
@@ -10,7 +10,7 @@ var CharSet = (function() {
       throw new Error('EntropyString only supports CharSets with a power of 2 characters')
     }
     const bitsPerByte = 8
-    
+
     const privProps = {
       chars: chars,
       bitsPerChar: bitsPerChar,
@@ -19,7 +19,7 @@ var CharSet = (function() {
     }
     propMap.set(this, privProps)
   }
-  
+
   CharSet.prototype.getChars = function() {
     return propMap.get(this).chars
   }
@@ -55,14 +55,18 @@ var CharSet = (function() {
 
   const ndxFn = (bitsPerChar) => {
     let bitsPerByte = 8
-    
+
+    // If bitsPerBytes is a multiple of bitsPerChar, we can slice off an integer number
+    // of chars per byte.
     if (lcm(bitsPerChar, bitsPerByte) === bitsPerByte) {
       return function(chunk, slice, bytes) {
         let lShift = bitsPerChar
         let rShift = bitsPerByte - bitsPerChar
         return ((bytes[chunk]<<(lShift*slice))&0xff)>>rShift
       }
     }
+    // Otherwise, while slicing off bits per char, we will possibly straddle a couple
+    // of bytes, so a bit more work is involved
     else {
       return function(chunk, slice, bytes) {
         let slicesPerChunk = lcm(bitsPerChar, bitsPerByte) / bitsPerByte
@@ -80,7 +84,7 @@ var CharSet = (function() {
           ndx += bytes[bNum+rOffset]>>rShiftIt
         }
         return ndx
-      }      
+      }
     }
   }
   return CharSet
diff --git a/lib/entropy.js b/lib/entropy.js
@@ -13,32 +13,27 @@ const _endianByteNum = (() => {
   return (buf8[0] === 0xff) ? [2,3,4,5,6,7] : [0,1,2,3,6,7]
 })()
 
-const bits = (total, risk) => {
-  if (total == 0) { return 0 }
+const _totalOf = (numStrings, log2Risk) => {
+  if (numStrings == 0) { return 0 }
 
-  let N = 0
-  if (total < 10001) {
-    N = _log2(total) + _log2(total-1) + (_log2_10 * _log10(risk)) - 1
+  let N
+  if (numStrings < 10001) {
+    N = _log2(numStrings) + _log2(numStrings-1)
   }
   else {
-    const n = 2 * _log10(total) + _log10(risk)
-    N = n * _log2_10 - 1
+    N = 2 * _log2(numStrings)
   }
-  return N
+  return N + log2Risk - 1
 }
 
-const bitsWithRiskPower = (total, rPower) => {
+const bits = (total, risk) => {
   if (total == 0) { return 0 }
+  return _totalOf(total, _log2(risk))
+}
 
-  let N = 0
-  if (total < 10001) {
-    N = _log2(total) + _log2(total-1) + (_log2_10 * rPower) - 1
-  }
-  else {
-    const n = 2 * _log10(total) + rPower
-    N = n * _log2_10 - 1
-  }
-  return N
+const bitsWithRiskPower = (total, rPower) => {
+  let log2Risk = _log2_10 * rPower
+  return _totalOf(total, log2Risk)
 }
 
 const bitsWithPowers = (tPower, rPower) => {
@@ -47,10 +42,8 @@ const bitsWithPowers = (tPower, rPower) => {
     return bitsWithRiskPower(Math.pow(10, tPower), rPower)
   }
   else {
-    const n = 2 * tPower + rPower
-    N = n * _log2_10 - 1
+    return (2 * tPower + rPower) * _log2_10 - 1
   }
-  return N
 }
 
 const string = (entropyBits, charSet) => {

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ var CharSet = (function() {`
`10`	`10`	`throw new Error('EntropyString only supports CharSets with a power of 2 characters')`
`11`	`11`	`}`
`12`	`12`	`const bitsPerByte = 8`
`13`		`-`
	`13`	`+`
`14`	`14`	`const privProps = {`
`15`	`15`	`chars: chars,`
`16`	`16`	`bitsPerChar: bitsPerChar,`
`@@ -19,7 +19,7 @@ var CharSet = (function() {`
`19`	`19`	`}`
`20`	`20`	`propMap.set(this, privProps)`
`21`	`21`	`}`
`22`		`-`
	`22`	`+`
`23`	`23`	`CharSet.prototype.getChars = function() {`
`24`	`24`	`return propMap.get(this).chars`
`25`	`25`	`}`
`@@ -55,14 +55,18 @@ var CharSet = (function() {`
`55`	`55`
`56`	`56`	`const ndxFn = (bitsPerChar) => {`
`57`	`57`	`let bitsPerByte = 8`
`58`		`-`
	`58`	`+`
	`59`	`+ // If bitsPerBytes is a multiple of bitsPerChar, we can slice off an integer number`
	`60`	`+ // of chars per byte.`
`59`	`61`	`if (lcm(bitsPerChar, bitsPerByte) === bitsPerByte) {`
`60`	`62`	`return function(chunk, slice, bytes) {`
`61`	`63`	`let lShift = bitsPerChar`
`62`	`64`	`let rShift = bitsPerByte - bitsPerChar`
`63`	`65`	`return ((bytes[chunk]<<(lShift*slice))&0xff)>>rShift`
`64`	`66`	`}`
`65`	`67`	`}`
	`68`	`+ // Otherwise, while slicing off bits per char, we will possibly straddle a couple`
	`69`	`+ // of bytes, so a bit more work is involved`
`66`	`70`	`else {`
`67`	`71`	`return function(chunk, slice, bytes) {`
`68`	`72`	`let slicesPerChunk = lcm(bitsPerChar, bitsPerByte) / bitsPerByte`
`@@ -80,7 +84,7 @@ var CharSet = (function() {`
`80`	`84`	`ndx += bytes[bNum+rOffset]>>rShiftIt`
`81`	`85`	`}`
`82`	`86`	`return ndx`
`83`		`- }`
	`87`	`+ }`
`84`	`88`	`}`
`85`	`89`	`}`
`86`	`90`	`return CharSet`