Merge branch 'hotfix/moduleupdate' into develop

Author: Gmousse

README.md

@@ -233,6 +233,12 @@ const df2 = df.withColumn('column4', (row) => row.get('column2') * 2)
 df.fakemodule.test(8)
 ```
 
+If you want to change default modules (modules enabled in each DataFrame instance, such as Matrix and Stat) you can define them by a static method:
+
+```javascript
+DataFrame.setDefaultModules(fakeModule, Matrix);
+```
+
 If you want to create your own module, take a look at the Statisticical module (integrated by default) `./src/modules/stat.js` as example.
 
 A simple example of a module structure:
@@ -254,8 +260,7 @@ class fakeModule {
 
 * [Matrix](./doc/MODULES_API.md#Matrix)
     * [new Matrix(dataframe)](./doc/MODULES_API.md#new_Matrix_new)
-    * [.hasSameStruct(df)](./doc/MODULES_API.md#Matrix+hasSameStruct) ⇒ <code>Boolean</code>
-    * [.hasSameTransposedStruct(df)](./doc/MODULES_API.md#Matrix+hasSameTransposedStruct) ⇒ <code>Boolean</code>
+    * [.isCommutative(dfDim)](./doc/MODULES_API.md#Matrix+isCommutative) ⇒ <code>Boolean</code>
     * [.add(df)](./doc/MODULES_API.md#Matrix+add) ⇒ <code>DataFrame</code>
     * [.product(number)](./doc/MODULES_API.md#Matrix+product) ⇒ <code>DataFrame</code>
     * [.dot(df)](./doc/MODULES_API.md#Matrix+dot) ⇒ <code>DataFrame</code>

doc/MODULES_API.md

@@ -18,8 +18,7 @@ Matrix module for DataFrame, providing basic mathematical matrix computations.
 
 * [Matrix](#Matrix)
     * [new Matrix(df)](#new_Matrix_new)
-    * [.hasSameStruct(df)](#Matrix+hasSameStruct) ⇒ <code>Boolean</code>
-    * [.hasSameTransposedStruct(df)](#Matrix+hasSameTransposedStruct) ⇒ <code>Boolean</code>
+    * [.isCommutative(dfDim)](#Matrix+isCommutative) ⇒ <code>Boolean</code>
     * [.add(df)](#Matrix+add) ⇒ <code>DataFrame</code>
     * [.product(number)](#Matrix+product) ⇒ <code>DataFrame</code>
     * [.dot(df)](#Matrix+dot) ⇒ <code>DataFrame</code>
@@ -34,34 +33,22 @@ Start the Matrix module.
 | --- | --- | --- |
 | df | <code>DataFrame</code> | An instance of DataFrame. |
 
-<a name="Matrix+hasSameStruct"></a>
+<a name="Matrix+isCommutative"></a>
 
-### matrix.hasSameStruct(df) ⇒ <code>Boolean</code>
+### matrix.isCommutative(dfDim) ⇒ <code>Boolean</code>
 Check if two DataFrames are commutative, if both have the same dimensions.
 
 **Kind**: instance method of <code>[Matrix](#Matrix)</code>  
 **Returns**: <code>Boolean</code> - True if they are commutative, else false.  
 
 | Param | Type | Description |
 | --- | --- | --- |
-| df | <code>DataFrame</code> | The second DataFrame to check. |
-
-<a name="Matrix+hasSameTransposedStruct"></a>
-
-### matrix.hasSameTransposedStruct(df) ⇒ <code>Boolean</code>
-Check if two DataFrames have the same dimensions while the second is transposed. Required for dot().
-
-**Kind**: instance method of <code>[Matrix](#Matrix)</code>  
-**Returns**: <code>Boolean</code> - True if they can be multiplied, else false.  
-
-| Param | Type | Description |
-| --- | --- | --- |
-| df | <code>DataFrame</code> | The second DataFrame to check. |
+| dfDim | <code>Array</code> | The second DataFrame dim to check. |
 
 <a name="Matrix+add"></a>
 
 ### matrix.add(df) ⇒ <code>DataFrame</code>
-Provide an elements pairwise addition of two DataFrames having the same dimensions. See .hasSameStruct().
+Provide an elements pairwise addition of two DataFrames having the same dimensions.
 
 **Kind**: instance method of <code>[Matrix](#Matrix)</code>  
 **Returns**: <code>DataFrame</code> - A new DataFrame resulting to the addition two DataFrames.  
@@ -85,7 +72,7 @@ Provide a scalar product between a number and a DataFrame.
 <a name="Matrix+dot"></a>
 
 ### matrix.dot(df) ⇒ <code>DataFrame</code>
-Multiply one DataFrame n x p and a second p x n. See .hasSameTransposedStruct().
+Multiply one DataFrame n x p and a second p x n.
 
 **Kind**: instance method of <code>[Matrix](#Matrix)</code>  
 **Returns**: <code>DataFrame</code> - A new n x n DataFrame resulting to the product of two DataFrame.  

lib/modules/matrix.js

@@ -45,31 +45,19 @@ var Matrix = function () {
 
     /**
      * Check if two DataFrames are commutative, if both have the same dimensions.
-     * @param {DataFrame} df The second DataFrame to check.
+     * @param {Array} dfDim The second DataFrame dim to check.
      * @returns {Boolean} True if they are commutative, else false.
      */
 
 
     (0, _createClass3.default)(Matrix, [{
-        key: 'hasSameStruct',
-        value: function hasSameStruct(df) {
-            return (0, _reusables.arrayEqual)(this.df.dim(), df.dim(), true);
+        key: 'isCommutative',
+        value: function isCommutative(dfDim) {
+            return (0, _reusables.arrayEqual)(this.df.dim(), dfDim, true);
         }
 
         /**
-         * Check if two DataFrames have the same dimensions while the second is transposed. Required for dot().
-         * @param {DataFrame} df The second DataFrame to check.
-         * @returns {Boolean} True if they can be multiplied, else false.
-         */
-
-    }, {
-        key: 'hasSameTransposedStruct',
-        value: function hasSameTransposedStruct(df) {
-            return (0, _reusables.arrayEqual)(this.df.dim(), df.dim().reverse(), true);
-        }
-
-        /**
-         * Provide an elements pairwise addition of two DataFrames having the same dimensions. See .hasSameStruct().
+         * Provide an elements pairwise addition of two DataFrames having the same dimensions.
          * @param {DataFrame} df The second DataFrame to add.
          * @returns {DataFrame} A new DataFrame resulting to the addition two DataFrames.
          */
@@ -79,7 +67,7 @@ var Matrix = function () {
         value: function add(df) {
             var _this = this;
 
-            if (!this.hasSameStruct(df)) {
+            if (!this.isCommutative(df.dim())) {
                 throw new _errors.WrongMatrixStructureError(this.df.dim(), df.dim());
             }
             var columns = [].concat((0, _toConsumableArray3.default)(Array(this.df.dim()[1]).keys()));
@@ -109,7 +97,7 @@ var Matrix = function () {
         }
 
         /**
-         * Multiply one DataFrame n x p and a second p x n. See .hasSameTransposedStruct().
+         * Multiply one DataFrame n x p and a second p x n.
          * @param {DataFrame} df The second DataFrame to multiply.
          * @returns {DataFrame} A new n x n DataFrame resulting to the product of two DataFrame.
          */
@@ -119,7 +107,7 @@ var Matrix = function () {
         value: function dot(df) {
             var _this2 = this;
 
-            if (!this.hasSameTransposedStruct(df)) {
+            if (!this.isCommutative(df.dim().reverse())) {
                 throw new _errors.WrongMatrixStructureError(this.df.dim(), df.dim().reverse());
             }
             var transposedDF = df.transpose();

src/modules/matrix.js

@@ -16,29 +16,20 @@ class Matrix {
 
     /**
      * Check if two DataFrames are commutative, if both have the same dimensions.
-     * @param {DataFrame} df The second DataFrame to check.
+     * @param {Array} dfDim The second DataFrame dim to check.
      * @returns {Boolean} True if they are commutative, else false.
      */
-    hasSameStruct(df) {
-        return arrayEqual(this.df.dim(), df.dim(), true);
+    isCommutative(dfDim) {
+        return arrayEqual(this.df.dim(), dfDim, true);
     }
 
     /**
-     * Check if two DataFrames have the same dimensions while the second is transposed. Required for dot().
-     * @param {DataFrame} df The second DataFrame to check.
-     * @returns {Boolean} True if they can be multiplied, else false.
-     */
-    hasSameTransposedStruct(df) {
-        return arrayEqual(this.df.dim(), df.dim().reverse(), true);
-    }
-
-    /**
-     * Provide an elements pairwise addition of two DataFrames having the same dimensions. See .hasSameStruct().
+     * Provide an elements pairwise addition of two DataFrames having the same dimensions.
      * @param {DataFrame} df The second DataFrame to add.
      * @returns {DataFrame} A new DataFrame resulting to the addition two DataFrames.
      */
     add(df) {
-        if (!this.hasSameStruct(df)) {
+        if (!this.isCommutative(df.dim())) {
             throw new WrongMatrixStructureError(this.df.dim(), df.dim());
         }
         const columns = [...Array(this.df.dim()[1]).keys()];
@@ -62,12 +53,12 @@ class Matrix {
     }
 
     /**
-     * Multiply one DataFrame n x p and a second p x n. See .hasSameTransposedStruct().
+     * Multiply one DataFrame n x p and a second p x n.
      * @param {DataFrame} df The second DataFrame to multiply.
      * @returns {DataFrame} A new n x n DataFrame resulting to the product of two DataFrame.
      */
     dot(df) {
-        if (!this.hasSameTransposedStruct(df)) {
+        if (!this.isCommutative(df.dim().reverse())) {
             throw new WrongMatrixStructureError(this.df.dim(), df.dim().reverse());
         }
         const transposedDF = df.transpose();