refactoring

Author: Kjerand Pedersen

src/array.js

@@ -4,14 +4,16 @@ export function createArray1d(values, columns, initValue) {
   }
   if (columns < 1) throw Error('Columns not a number!');
   const arr = new Array(columns);
-
-  for (let c = 0; c < arr.length; c++) {
-    if (values && c < values.length) {
+  let c = 0;
+  if (values) {
+    const itr = Math.min(values.length, columns);
+    for (; c < itr; c++) {
       arr[c] = values[c];
-    } else {
-      arr[c] = initValue;
     }
   }
+  for (; c < columns; c++) {
+    arr[c] = initValue;
+  }
   return arr;
 }
 
@@ -26,47 +28,67 @@ export function createArray2d(values, columns, rows, initValue) {
   if (columns < 1) throw Error('Columns not a number!');
   rows = rows || 1;
   const arr = new Array(rows);
+  const len = rows * columns;
   let i = 0;
-  for (let r = 0; r < arr.length; r++) {
-    arr[r] = new Array(columns);
-    for (let c = 0; c < arr[r].length; c++) {
-      if (values && i < values.length) {
-        arr[r][c] = values[i];
-      } else {
-        arr[r][c] = initValue;
+  let r = -1;
+  if (values) {
+    const itr = Math.min(len, values.length);
+    for (; i < itr; i++) {
+      const c = i % columns;
+      if (c === 0) {
+        r++;
+        arr[r] = new Array(columns);
       }
-      i++;
+      arr[r][c] = values[i];
     }
   }
-  return arr;
-}
-
-export function assignTo2d(arr, cb) {
-  for (let r = 0; r < arr.length; r++) {
-    for (let c = 0; c < arr[r].length; c++) {
-      arr[r][c] = cb(arr[r][c], c, r);
+  for (; i < len; i++) {
+    const c = i % columns;
+    if (c === 0) {
+      r++;
+      arr[r] = new Array(columns);
     }
+    arr[r][c] = initValue;
   }
-}
 
-export function assignTo1d(arr, cb) {
-  for (let c = 0; c < arr.length; c++) {
-    arr[c] = cb(arr[c], c);
-  }
+  // for (let r = 0; r < arr.length; r++) {
+  //   arr[r] = new Array(columns);
+  //   for (let c = 0; c < columns; c++) {
+  //     arr[r][c] = values[i++];
+  //   }
+  //   for (let c = i; c < columns; c++) {
+  //     arr[r][c] = initValue;
+  //   }
+  // }
+  return arr;
 }
 
-export function copyTo2d(arr, values) {
-  let i = 0;
-  for (let r = 0; r < arr.length; r++) {
-    for (let c = 0; c < arr[0].length && i < values.length; c++) {
-      arr[r][c] = values[i++];
+export function assignTo(arr, cb) {
+  if (Array.isArray(arr[0])) {
+    for (let r = 0; r < arr.length; r++) {
+      for (let c = 0; c < arr[r].length; c++) {
+        arr[r][c] = cb(arr[r][c], c, r);
+      }
+    }
+  } else {
+    for (let c = 0; c < arr.length; c++) {
+      arr[c] = cb(arr[c], c);
     }
   }
 }
 
-export function copyTo1d(arr, values) {
-  for (let c = 0; c < arr.length && c < values.length; c++) {
-    arr[c] = values[c];
+export function copyTo(arr, values) {
+  if (Array.isArray(arr[0])) {
+    let i = 0;
+    for (let r = 0; r < arr.length; r++) {
+      for (let c = 0; c < arr[0].length && i < values.length; c++) {
+        arr[r][c] = values[i++];
+      }
+    }
+  } else {
+    for (let c = 0; c < arr.length && c < values.length; c++) {
+      arr[c] = values[c];
+    }
   }
 }
 
@@ -117,13 +139,13 @@ export function removeFrom(arr, i = 0, j = 0) {
   }
 }
 
-export function clone2d(arr) {
-  return arr.map(row => row.slice());
+export function clone(arr) {
+  return Array.isArray(arr[0]) ? arr.map(row => row.slice()) : arr.slice();
 }
 
-export const rows = arr => arr.length;
+export const nrows = arr => arr.length;
 
-export const cols = arr => arr && arr[0].length;
+export const ncols = arr => arr && arr[0].length;
 
 export const flatten = (inpArr) => {
   const arr = new Array(inpArr.length * inpArr[0].length);

src/math/determinant.js

@@ -1,14 +1,14 @@
-import { cols, clone2d, removeFrom } from '../array';
+import { ncols, clone, removeFrom } from '../array';
 
 export default op => function determinant(m) {
   if (m.length === 1) return m[0][0];
 
   let d = op.zero();
-  const ncols = cols(m);
-  for (let c = 0; c < ncols; c++) {
+  const cols = ncols(m);
+  for (let c = 0; c < cols; c++) {
     const v = m[0][c];
     if (op.isZero(v)) continue;
-    const sm = clone2d(m);
+    const sm = clone(m);
     removeFrom(sm, c + 1, 1);
     let cofactor = determinant(sm, op);
 

src/math/index.js

@@ -4,7 +4,7 @@
  */
 
 // import factory from './factory';
-import factory from '../optimalisations/factory';
+import factory from '../optimisations/factory';
 
 const op = factory();
 export default op;

src/matrix.js

@@ -3,16 +3,16 @@ import {
   determinant2d,
   determinant3d,
   determinant4d,
-} from './optimalisations/matrix';
+} from './optimisations/determinant';
 import {
   createArray2d,
-  assignTo2d,
-  copyTo2d,
+  assignTo,
+  copyTo,
   transpose,
   subArrayFrom,
   removeFrom,
   flatten,
-  clone2d,
+  clone,
 } from './array';
 import { argumentsToList } from './utils';
 import op from './math';
@@ -27,7 +27,7 @@ export class Matrix {
       if (Array.isArray(values[0]) && !cols) {
         cols = values[0].length;
         rows = values.length;
-        this._values = clone2d(values);
+        this._values = clone(values);
       } else {
         this._values = createArray2d(argumentsToList(values, false), cols, rows, 0);
       }
@@ -48,7 +48,7 @@ export class Matrix {
       throw Error('Vectors must be of the same dimension!');
     }
     const m = createArray2d(null, vect.length, l);
-    assignTo2d(m, (foo, c, r) => vect[c].get(r));
+    assignTo(m, (foo, c, r) => vect[c].get(r));
     return new Matrix(m);
   }
 
@@ -61,9 +61,9 @@ export class Matrix {
       [values] = values;
     }
     if (values.length === 1 && op.isDefined(values[0])) {
-      assignTo2d(this._values, () => values[0]);
+      assignTo(this._values, () => values[0]);
     } else {
-      copyTo2d(this._values, argumentsToList(values));
+      copyTo(this._values, argumentsToList(values));
     }
     return this;
   }
@@ -112,7 +112,7 @@ export class Matrix {
   }
 
   clamp(min = 0, max = 1) {
-    assignTo2d(this._values, v => op.clamp(v, min, max));
+    assignTo(this._values, v => op.clamp(v, min, max));
     return this;
   }
 
@@ -126,7 +126,7 @@ export class Matrix {
     args.forEach((m) => {
       if (this.rows !== m.rows || this.cols !== m.cols)
         throw Error('Matrices must be of same size!');
-      assignTo2d(this._values, (v, c, r) => op.add(v, m._values[r][c]));
+      assignTo(this._values, (v, c, r) => op.add(v, m._values[r][c]));
     });
     return this;
   }
@@ -135,7 +135,7 @@ export class Matrix {
     args.forEach((m) => {
       if (this.rows !== m.rows || this.cols !== m.cols)
         throw Error('Matrices must be of same size!');
-      assignTo2d(this._values, (v, c, r) => op.subtract(v, m._values[r][c]));
+      assignTo(this._values, (v, c, r) => op.subtract(v, m._values[r][c]));
     });
     return this;
   }
@@ -179,13 +179,13 @@ export class Matrix {
 
   scale(factor) {
     if (Number.isFinite(factor)) {
-      assignTo2d(this._values, v => op.multiply(v, factor));
+      assignTo(this._values, v => op.multiply(v, factor));
     }
     return this;
   }
 
   negate() {
-    assignTo2d(this._values, v => op.negate(v));
+    assignTo(this._values, v => op.negate(v));
     return this;
   }