Changeset 26310

Timestamp:

06/09/21 13:46:44 (4 years ago)

Author:

jdquinn

Message:

CHG: Incorporated other functions from Dan; added more functionality to ones/zeros; pending minor cleanup

Location:

issm/trunk-jpl/src/m

Files:

• classes/hydrologyshreve.m (modified) (1 diff)
• miscellaneous/MatlabFuncs.js (modified) (14 diffs)

issm/trunk-jpl/src/m/classes/hydrologyshreve.m

@@ -37 +37 @@
 
                         %Early return
-                        if ~ismember('HydrologyShreveAnalysis',analyses) |  (strcmp(solution,'TransientSolution') & md.transient.ishydrology==0), return; end
+                        if ~ismember('HydrologyShreveAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.transient.ishydrology==0), return; end
 
                         md = checkfield(md,'fieldname','hydrology.spcwatercolumn','Inf',1,'timeseries',1);

issm/trunk-jpl/src/m/miscellaneous/MatlabFuncs.js

@@ -10 +10 @@
 - We cannot implement the following MATLAB built-in functions by name as their
 names are reserved keywords in JavaScript,
-        class
+    class
 
 TODO:
 - Implement,
-        sort
-        unique
+    sort
+    unique
 
 Sources:
@@ -36 +36 @@
  */
 function any(A) {//{{{
-        for (let i = 0; i < A.length; ++i) {
-                if (A[i] !== 0) {
-                        return true;
-                }
-        }
-        return false;
+    for (let i = 0; i < A.length; ++i) {
+        if (A[i] !== 0) {
+            return true;
+        }
+    }
+    return false;
 } //}}}
 
@@ -61 +61 @@
  */
 function diff(X) {//{{{
-        let diffs = [];
-        for (let i = 0; i < X.length - 1; ++i) {
-                diffs[i] = X[i + 1] - X[i];
-        }
-        return diffs;
+    let diffs = [];
+    for (let i = 0; i < (X.length - 1); ++i) {
+        diffs[i] = X[i + 1] - X[i];
+    }
+    return diffs;
 } //}}}
 
@@ -82 +82 @@
  */
 function disp(X) {//{{{
-        console.log(X);
+    console.log(X);
 } //}}}
 
@@ -100 +100 @@
  */
 function error(msg) {//{{{
-        throw new Error(msg);
+    throw new Error(msg);
 } //}}}
 
@@ -117 +117 @@
  */
 function find(X, n, direction) {//{{{
-        if (typeof(X[0]) == 'number') {
-                let indices = [];
-                for (let i = 0; i < X.length; ++i) {
-                        if (X[i] != 0) {
-                                indices.push(i);
-                        }
-                }
-                return indices;
-        } else { //TODO: If 2d array, assume return rows & cols - try to find a way to not always return rows/cols
-                let rowindices = [];
-                let colindices = [];
-                for (let i = 0; i < X.length; ++i) {
-                        for (let j = 0; j < X[i].length; ++j) {
-                                if (X[i][j] != 0) {
-                                        rowindices.push(i);
-                                        colindices.push(j);
-                                }
-                        }
-                }
-                return [rowindices, colindices];
-        }
+    if (typeof(X[0]) == 'number') {
+        let indices = [];
+        for (let i = 0; i < X.length; ++i) {
+            if (X[i] != 0) {
+                indices.push(i);
+            }
+        }
+        return indices;
+    } else { //TODO: If 2d array, assume return rows & cols - try to find a way to not always return rows/cols
+        let rowindices = [];
+        let colindices = [];
+        for (let i = 0; i < X.length; ++i) {
+            for (let j = 0; j < X[i].length; ++j) {
+                if (X[i][j] != 0) {
+                    rowindices.push(i);
+                    colindices.push(j);
+                }
+            }
+        }
+        return [rowindices, colindices];
+    }
 } //}}}
 
@@ -152 +152 @@
  */
 function isempty(A) {//{{{
-        //NOTE: Expanded for clarity/debugging. Can reduce later.
-        if (A === undefined) {
-                return 1; //TODO: Fix this: for now, treat undefined as empty
-        } else {
-                return A.length == 0;
-        }
+    //NOTE: Expanded for clarity/debugging. Can reduce later.
+    if (A === undefined) {
+        return 1; //TODO: Fix this: for now, treat undefined as empty
+    } else {
+        return A.length == 0;
+    }
 } //}}}
 
@@ -175 +175 @@
  */
 function ismember(A, B) {//{{{
-        let b = B;
-        if (typeof(B) == 'number' || typeof(B) == 'string') {
-                b = [B];
-        }
-        let indices = zeros(A.length);
-        for (let i = 0; i < A.length; ++i) {
-                for (let j = 0; j < b.length; ++j) {
-                        if (A[i] === b[j]) {
-                                indices[i] = 1;
-                        }
-                }
-        }
-        if (indices.length) {
-                return indices;
-        } else {
-                return 0;
-        }
+    let b = B;
+    if (typeof(B) == 'number' || typeof(B) == 'string') {
+        b = [B];
+    }
+    let indices = zeros(A.length);
+    for (let i = 0; i < A.length; ++i) {
+        for (let j = 0; j < b.length; ++j) {
+            if (A[i] === b[j]) {
+                indices[i] = 1;
+            }
+        }
+    }
+    if (indices.length) {
+        return indices;
+    } else {
+        return 0;
+    }
 } //}}}
 
@@ -211 +211 @@
  */
 function isnan(A) {//{{{
-        if (A.constructor !== Array) {
-                error('isnan: argument must be an array')
-        }
-        is_nan = [];
-        for (let i = 0; i < A.length; ++i) {
-                if (Number.isNaN(A[i])) {
-                        is_nan.push(1);
-                } else {
-                        is_nan.push(0);
-                }
-        }
-        return is_nan;
+    if (A.constructor !== Array) {
+        error('isnan: argument must be an array')
+    }
+    is_nan = [];
+    for (let i = 0; i < A.length; ++i) {
+        if (Number.isNaN(A[i])) {
+            is_nan.push(1);
+        } else {
+            is_nan.push(0);
+        }
+    }
+    return is_nan;
 } //}}}/*
 
@@ -240 +240 @@
  */
 function length(A) {//{{{
-        return A.length;
+    return A.length;
 } //}}}/*
 
@@ -259 +259 @@
  */
 function max(A) {//{{{
-        return Math.max.apply(null, A);
+    return Math.max.apply(null, A);
 } //}}}/*
 
@@ -278 +278 @@
  */
 function min(A) {//{{{
-        return Math.min.apply(null, A);
+    return Math.min.apply(null, A);
 } //}}}/*
 
 /**
- * FUNCTION sum - Sum of elements of an array
- *
- * Replicates behavior of MATLAB's 'sum' function
- *
- * Usage:
- *     S = sum(A)
- *
- * Sources:
- * - https://www.mathworks.com/help/matlab/ref/sum.html
- *
- * TODO:
- * - Implement support for multidimensional arrays
- * - Implement 'nanflag' parameter
- */
-function sum(A) {//{{{
-        return ArraySum(A);
-} //}}}/*
-
-/**
  * FUNCTION ones - Create array of all ones
  *
- * Replicates behavior of MATLAB's 'ones' function
+ * Replicates behavior of MATLAB's 'zeros' function
+ * 
+ * Usage:
+ *     X = ones
+ *     X = ones(n)
+ *     X = ones(sz1,...,szN)
+ *     X = ones(sz)
  *
  * Sources:
  * - https://www.mathworks.com/help/matlab/ref/ones.html
  *
- * NOTE:
- * - Current behavior is to initialize and return a 1D array of length 'size'
- *
- * TODO:
- * - Implement actual behavior of MATLAB's 'ones' function
- */
-function ones(size) {//{{{
-        return NewArrayFill(size, 1);
+ * TODO:
+ * - Create lower-level function to handle both ones and zeros functions as 
+ * they are essentially the same
+ * - Implement functionality for more than 2 dimensions
+ */
+function ones() {//{{{
+    nargs = arguments.length;
+    if (nargs == 0) {
+        return 1;
+    } else if (nargs == 1) {
+        let arg = arguments[0];
+        if (typeof(arg) == 'number') {
+            return NewArrayFill(arg, 1);
+        } else if (arg.constructor == Array) {
+            return ones(...arg); // spread array of sizes
+        } else {
+            error('ones: functionality for greater than 2 dimensions is not currently implemented')
+        }
+    } else if (nargs == 2) {
+        return NewArrayFill2D(arguments[0], arguments[1], 1);
+    } else {
+        error('ones: functionality for greater than 2 dimensions is not currently implemented')
+    }
 } //}}}
 
@@ -337 +339 @@
  */
 function size(A, dim) {//{{{
-        let nargs = arguments.length;
-        if (nargs == 0) {
-                error('size: at least one argument is required');
-        } else if (nargs == 1) {
-                if (typeof(A) == 'number') { // scalar numbers are of size [1, 1]
-                        return [1, 1];
-                } else if (A.constructor != Array) {
-                        error('size: A argument must be a number or an Array');
-                }
-                if (typeof(A) == 'undefined' || isNaN(A)) {
-                        return [0];
-                } else if (A.length && A[0].constructor == Array) {
-                        return [A.length, A[0].length];
-                } else {
-                        return [A.length];
-                }
-        } else if (nargs == 2) {
-                if (typeof(dim) != 'number' || dim < 0 || dim > 1) {
-                        error('size: dim argument must be a number between 0 and 1, inclusive');
-                }
-                if (dim == 0) {
-                        if (typeof(A) == 'number') { // scalar numbers are of size [1, 1]
-                                return 1;
-                        } else {
-                                return A.length;
-                        }
-                } else {
-                        if (typeof(A) == 'number') { // scalar numbers are of size [1, 1]
-                                return 1;
-                        } else if (typeof(A) == 'undefined' || isNaN(A)) {
-                                return 0;
-                        } else if (A[0].constructor != Array) {
-                                error('size: A[0] is not an Array');
-                        }
-                        return A[0].length;
-                }
-        } else {
-                error('size: functionality for more than 2 arguments is not currently implemented');
-        }
+    let nargs = arguments.length;
+    if (nargs == 0) {
+        error('size: at least one argument is required');
+    } else if (nargs == 1) {
+        if (typeof(A) == 'number') { // scalar numbers are of size [1, 1]
+            return [1, 1];
+        } else if (A.constructor != Array) {
+            error('size: A argument must be a number or an Array');
+        }
+        if (typeof(A) == 'undefined' || isNaN(A)) {
+            return [0];
+        } else if (A.length && A[0].constructor == Array) {
+            return [A.length, A[0].length];
+        } else {
+            return [A.length];
+        }
+    } else if (nargs == 2) {
+        if (typeof(dim) != 'number' || dim < 0 || dim > 1) {
+            error('size: dim argument must be a number between 0 and 1, inclusive');
+        }
+        if (dim == 0) {
+            if (typeof(A) == 'number') { // scalar numbers are of size [1, 1]
+                return 1;
+            } else {
+                return A.length;
+            }
+        } else {
+            if (typeof(A) == 'number') { // scalar numbers are of size [1, 1]
+                return 1;
+            } else if (typeof(A) == 'undefined' || isNaN(A)) {
+                return 0;
+            } else if (A[0].constructor != Array) {
+                error('size: A[0] is not an Array');
+            }
+            return A[0].length;
+        }
+    } else {
+        error('size: functionality for more than 2 arguments is not currently implemented');
+    }
 } //}}}
 
@@ -387 +389 @@
  */
 function strcmpi(s1, s2) {//{{{
-        return s1.toLowerCase() == s2.toLowerCase();
-} //}}}
-
-/**
- * FUNCTION sum - Sum of array elements
+    return s1.toLowerCase() == s2.toLowerCase();
+} //}}}
+
+/**
+ * FUNCTION sum - Sum of elements of an array
  *
  * Replicates behavior of MATLAB's 'sum' function
+ *
+ * Usage:
+ *     S = sum(A)
+ *
+ * Sources:
+ * - https://www.mathworks.com/help/matlab/ref/sum.html
+ *
+ * TODO:
+ * - Implement support for multidimensional arrays
+ * - Implement 'nanflag' parameter
+ */
+function sum(A) {//{{{
+    return ArraySum(A);
+} //}}}
+
+/**
+ * FUNCTION zeros - Create array of all zeros
+ *
+ * Replicates behavior of MATLAB's 'zeros' function
  * 
- * Sum(A) returns the sum of the elements of A along the first array dimension 
- * whose size does not equal 1.
- * - If A is a 1D array, then sum(A) returns the sum of the elements
- *
- * Usage:
- *     S = sum(A)
- * 
- * Sources:
- * - https://www.mathworks.com/help/matlab/ref/sum.html
- *
- * NOTE:
- * - Not all functionality is implemented
- */
-function sum(A) {//{{{
-        return A.reduce((x, y) => x + y);
-} //}}}
-
-/**
- * FUNCTION zeros - Create array of all zeros
- *
- * Replicates behavior of MATLAB's 'zeros' function
+ * Usage:
+ *     X = zeros
+ *     X = zeros(n)
+ *     X = zeros(sz1,...,szN)
+ *     X = zeros(sz)
  *
  * Sources:
  * - https://www.mathworks.com/help/matlab/ref/zeros.html
  *
- * NOTE:
- * - Current behavior is to initialize and return a 1D array of length 'size'
- *
- * TODO:
- * - Implement actual behavior of MATLAB's 'ones' function
- */
-function zeros(size, size2) {//{{{
-        if (size2 !== undefined) {
-                return NewArrayFill2D(size, size2, 0);
-        } else {
-                return NewArrayFill(size, 0);
-        }
-} //}}}
+ * TODO:
+ * - Create lower-level function to handle both ones and zeros functions as 
+ * they are essentially the same
+ * - Implement functionality for more than 2 dimensions
+ */
+function zeros() {//{{{
+    nargs = arguments.length;
+    if (nargs == 0) {
+        return 0;
+    } else if (nargs == 1) {
+        let arg = arguments[0];
+        if (typeof(arg) == 'number') {
+            return NewArrayFill(arg, 0);
+        } else if (arg.constructor == Array) {
+            return zeros(...arg); // spread array of sizes
+        } else {
+            error('zeros: functionality for greater than 2 dimensions is not currently implemented')
+        }
+    } else if (nargs == 2) {
+        return NewArrayFill2D(arguments[0], arguments[1], 0);
+    } else {
+        error('zeros: functionality for greater than 2 dimensions is not currently implemented')
+    }
+} //}}}
+
+/**
+ * FUNCTIONS sin, cos, tan, asin, acos, atan2 - trig functions that work with radians
+ *
+ * Replicates behavior of MATLAB's trig functions
+ *
+ * Sources:
+ * - https://www.mathworks.com/help/matlab/trigonometry.html
+ *
+ */
+function sin(X) {//{{{
+    let result = NewArrayFill(size, X.length);
+    for (let i = 0; i < X.length; ++i) {
+        result[i] = Math.sin(X[i]);
+    }
+    return result;
+} //}}}
+
+function cos(X) {//{{{
+    let result = NewArrayFill(size, X.length);
+    for (let i = 0; i < X.length; ++i) {
+        result[i] = Math.cos(X[i]);
+    }
+    return result;
+} //}}}
+
+function tan(X) {//{{{
+    let result = NewArrayFill(size, X.length);
+    for (let i = 0; i < X.length; ++i) {
+        result[i] = Math.tan(X[i]);
+    }
+    return result;
+} //}}}
+
+function asin(X) {//{{{
+    let result = NewArrayFill(size, X.length);
+    for (let i = 0; i < X.length; ++i) {
+        result[i] = Math.asin(X[i]);
+    }
+    return result;
+} //}}}
+
+function acos(X) {//{{{
+    let result = NewArrayFill(size, X.length);
+    for (let i = 0; i < X.length; ++i) {
+        result[i] = Math.acos(X[i]);
+    }
+    return result;
+} //}}}
+
+// TODO: Test that the arguments do not need to be reversed, as they are in MATLAB and Python
+function atan2(X, Y) {//{{{
+    let result = NewArrayFill(size, X.length);
+    for (let i = 0; i < X.length; ++i) {
+        result[i] = Math.atan2(X[i], Y[i]);
+    }
+    return result;
+} //}}}
+
+/**
+ * FUNCTIONS sind, cosd, tand, asind, acosd, atan2d - trig functions that work with degrees
+ *
+ * Replicates behavior of MATLAB's trig functions
+ *
+ * Sources:
+ * - https://www.mathworks.com/help/matlab/trigonometry.html
+ *
+ */
+function sind(X) {//{{{
+    let result = NewArrayFill(size, X.length);
+    for (let i = 0; i < X.length; ++i) {
+        result[i] = Math.sin(X[i] * DEG2RAD);
+    }
+    return result;
+} //}}}
+
+function cosd(X) {//{{{
+    let result = NewArrayFill(size, X.length);
+    for (let i = 0; i < X.length; ++i) {
+        result[i] = Math.cos(X[i] * DEG2RAD);
+    }
+    return result;
+} //}}}
+
+function tand(X) {//{{{
+    let result = NewArrayFill(size, X.length);
+    for (let i = 0; i < X.length; ++i) {
+        result[i] = Math.tan(X[i] * DEG2RAD);
+    }
+    return result;
+} //}}}
+
+function asind(X) {//{{{
+    let result = NewArrayFill(size, X.length);
+    for (let i = 0; i < X.length; ++i) {
+        result[i] = RAD2DEG * Math.asin(X[i]);
+    }
+    return result;
+} //}}}
+
+function acosd(X) {//{{{
+    let result = NewArrayFill(size, X.length);
+    for (let i = 0; i < X.length; ++i) {
+        result[i] = RAD2DEG * Math.acos(X[i]);
+    }
+    return result;
+} //}}}
+
+// TODO: Test that the arguments do not need to be reversed, as they are in MATLAB and Python
+function atan2d(X, Y) {//{{{
+    let result = NewArrayFill(size, X.length);
+    for (let i = 0; i < X.length; ++i) {
+        result[i] = RAD2DEG * Math.atan2(X[i], Y[i]);
+    }
+    return result;
+} //}}}