Fix typos, edit example to better relate to readme, and provide link to example

Author: robertleeplummerjr

README.md

@@ -133,6 +133,7 @@ width=2,height=2,depth=3                  width=4,height=4,depth=2
 ```
 
 ## What does this log mean?
+If you prefer code to learn take a look at the [included example](example.js)
 1. Suppose we had a (contrived) block of CPU code we'd like to run on the GPU:
 ```js
 const filters = [
@@ -227,7 +228,10 @@ width=2,height=2                    width=4,height=4
                                     [ ][ ][*][*]
 ```
 
-3. Now we have enough logic to visibly see how to build out our algorythm that will work on the GPU.  For `filters`@`x=0,y=0` we can see we need the values from `weights`@`x=0,y=0`,`x=1,y=0`,`x=0,y=1`, and `x=1,y=1`. Then to get `filters`@`x=1,y=0`, we seem to increment by two on `weights`.  If we were to write a loop that emilates this behaviour, it'd look something like this:
+3. Now we have enough logic to visibly see how to build out our algorythm that will work on the GPU.
+For `filters`@`x=0,y=0` we can see we need the values from `weights`@`x=0,y=0`,`x=1,y=0`,`x=0,y=1`, and `x=1,y=1`.
+Then to get `filters`@`x=1,y=0`, we seem to increment by two on `weights`.
+If we were to write a loop that emulates this behaviour, it'd look something like this:
 
 ```js
 const filterHeight = 2;
@@ -257,7 +261,8 @@ for (let filterY = 0; filterY < filterHeight; filterY++) {
 console.log(filters); // -> [ [ 14, 22 ], [ 46, 54 ] ]
 ```
 
-4. On the GPU we are writing from a kernel, which acts like the `filters` loop already, so we can ommit that and pretend that the function will run in its own "fragment" (like iteration of the inner most loops for building the value).  If that function was just simple Javascript that we imagined might work on a GPU kernel, it'd looks something like this:
+4. On the GPU we are writing from a kernel, which acts like the `filters` loop already, so we can omit that and pretend that the function will run in its own "fragment" (like iteration of the inner most loops for building the value).
+If that function was just simple Javascript that we imagined might work on a GPU kernel, it'd looks something like this:
 
 ```js
 function filterKernel(filters, filterX, filterY, filterWidth, filterHeight, weights) {

example.js

@@ -9,11 +9,27 @@ const weights = [
 ];
 
 const targetValue = step1CPU();
-assert.deepStrictEqual(step2GPUStyleLoops(), targetValue);
-assert.deepStrictEqual(step3GPUStyleKernel(), targetValue);
-assert.deepStrictEqual(step4GPUKernel(), targetValue);
+assert.deepStrictEqual(step2CPUWithMatrixLog(), targetValue);
+assert.deepStrictEqual(step3GPUStyleLoops(), targetValue);
+assert.deepStrictEqual(step4GPUStyleKernel(), targetValue);
+assert.deepStrictEqual(step5GPUKernel(), targetValue);
 
 function step1CPU() {
+  const filters = [
+    [0,0],
+    [0,0]
+  ];
+  for (let y = 0; y < 4; y++) {
+    let filterY = y < 2 ? 0 : 1;
+    for (let x = 0; x < 4; x++) {
+      let filterX = x < 2 ? 0 : 1;
+      filters[filterY][filterX] += weights[y][x];
+    }
+  }
+  return filters;
+}
+
+function step2CPUWithMatrixLog() {
   const filters = [
     [0,0],
     [0,0]
@@ -50,7 +66,7 @@ function step1CPU() {
   return filters;
 }
 
-function step2GPUStyleLoops() {
+function step3GPUStyleLoops() {
   const filters = [
     [0,0],
     [0,0]
@@ -82,7 +98,7 @@ function step2GPUStyleLoops() {
   return filters;
 }
 
-function step3GPUStyleKernel() {
+function step4GPUStyleKernel() {
   const filters = [
     [0,0],
     [0,0]
@@ -113,7 +129,7 @@ function step3GPUStyleKernel() {
   return filters;
 }
 
-function step4GPUKernel() {
+function step5GPUKernel() {
   const filters = [
     [0,0],
     [0,0]

package.json

@@ -1,6 +1,6 @@
 {
   "name": "matrix-log.js",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "A matrix log dependency utility. Useful for converting and testing algorithm behavior of CPU code to GPU code.",
   "main": "index.js",
   "scripts": {