@2112-lab/central-plant 0.1.4 → 0.1.6

package/dist/esm/src/data/numerics.js

@@ -1 +1,518 @@
-import{createClass as r,classCallCheck as n,defineProperty as t,toConsumableArray as e}from"../../_virtual/_rollupPluginBabelHelpers.js";var o=function(){return r(function r(){var o=this;n(this,r),t(this,"vector",{add:function(r,n){return r.map(function(r,t){return r+(n[t]||0)})},subtract:function(r,n){return r.map(function(r,t){return r-(n[t]||0)})},scale:function(r,n){return r.map(function(r){return r*n})},dot:function(r,n){return r.reduce(function(r,t,e){return r+t*(n[e]||0)},0)},cross:function(r,n){return[r[1]*n[2]-r[2]*n[1],r[2]*n[0]-r[0]*n[2],r[0]*n[1]-r[1]*n[0]]},magnitude:function(r){return Math.sqrt(r.reduce(function(r,n){return r+n*n},0))},normalize:function(r){var n=o.vector.magnitude(r);return n>0?r.map(function(r){return r/n}):r.slice()},distance:function(r,n){return o.vector.magnitude(o.vector.subtract(r,n))},lerp:function(r,n,t){return r.map(function(r,e){return r+t*((n[e]||0)-r)})}}),t(this,"matrix",{identity:function(r){for(var n=Array(r).fill().map(function(){return Array(r).fill(0)}),t=0;t<r;t++)n[t][t]=1;return n},multiply:function(r,n){for(var t=r.length,e=n[0].length,o=Array(t).fill().map(function(){return Array(e).fill(0)}),u=0;u<t;u++)for(var i=0;i<e;i++)for(var a=0;a<r[0].length;a++)o[u][i]+=r[u][a]*n[a][i];return o},multiplyVector:function(r,n){return r.map(function(r){return r.reduce(function(r,t,e){return r+t*(n[e]||0)},0)})},determinant:function(r){var n=r.length;if(2===n)return r[0][0]*r[1][1]-r[0][1]*r[1][0];if(3===n)return r[0][0]*(r[1][1]*r[2][2]-r[1][2]*r[2][1])-r[0][1]*(r[1][0]*r[2][2]-r[1][2]*r[2][0])+r[0][2]*(r[1][0]*r[2][1]-r[1][1]*r[2][0]);throw new Error("Determinant calculation only supported for 2x2 and 3x3 matrices")},transpose:function(r){return r[0].map(function(n,t){return r.map(function(r){return r[t]})})}}),t(this,"analysis",{newtonRaphson:function(r,n,t){for(var e=t,u=0;u<o.maxIterations;){var i=r(e),a=n(e);if(Math.abs(a)<o.precision)throw new Error("Derivative too small, cannot continue");var c=e-i/a;if(Math.abs(c-e)<o.convergenceThreshold)return{root:c,iterations:u+1,converged:!0,error:Math.abs(r(c))};e=c,u++}return{root:e,iterations:u,converged:!1,error:Math.abs(r(e))}},bisection:function(r,n,t){if(r(n)*r(t)>=0)throw new Error("Function must have opposite signs at bounds");for(var e=n,u=t,i=0;i<o.maxIterations;){var a=(e+u)/2,c=r(a);if(Math.abs(c)<o.convergenceThreshold||Math.abs(u-e)<o.convergenceThreshold)return{root:a,iterations:i+1,converged:!0,error:Math.abs(c)};r(e)*c<0?u=a:e=a,i++}return{root:(e+u)/2,iterations:i,converged:!1,error:Math.abs(r((e+u)/2))}},simpson:function(r,n,t){var e=arguments.length>3&&void 0!==arguments[3]?arguments[3]:100;e%2!=0&&e++;for(var o=(t-n)/e,u=r(n)+r(t),i=1;i<e;i++){u+=(i%2==0?2:4)*r(n+i*o)}return o/3*u},derivative:function(r,n){var t=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1e-8;return(r(n+t)-r(n-t))/(2*t)}}),t(this,"stats",{mean:function(r){return r.reduce(function(r,n){return r+n},0)/r.length},median:function(r){var n=e(r).sort(function(r,n){return r-n}),t=Math.floor(n.length/2);return n.length%2==0?(n[t-1]+n[t])/2:n[t]},stdDev:function(r){var n=o.stats.mean(r),t=r.reduce(function(r,t){return r+Math.pow(t-n,2)},0)/r.length;return Math.sqrt(t)},correlation:function(r,n){for(var t=Math.min(r.length,n.length),e=o.stats.mean(r.slice(0,t)),u=o.stats.mean(n.slice(0,t)),i=0,a=0,c=0,f=0;f<t;f++){var s=r[f]-e,v=n[f]-u;i+=s*v,a+=s*s,c+=v*v}var h=Math.sqrt(a*c);return 0!==h?i/h:0},linearRegression:function(r,n){for(var t=Math.min(r.length,n.length),e=o.stats.mean(r.slice(0,t)),u=o.stats.mean(n.slice(0,t)),i=0,a=0,c=0;c<t;c++){var f=r[c]-e;i+=f*(n[c]-u),a+=f*f}for(var s=0!==a?i/a:0,v=u-s*e,h=0,l=0,d=0;d<t;d++){var p=s*r[d]+v;h+=Math.pow(n[d]-p,2),l+=Math.pow(n[d]-u,2)}return{slope:s,intercept:v,rSquared:0!==l?1-h/l:0,predict:function(r){return s*r+v}}}}),t(this,"utils",{clamp:function(r,n,t){return Math.max(n,Math.min(t,r))},map:function(r,n,t,e,o){return e+(r-n)*(o-e)/(t-n)},approxEqual:function(r,n){var t=arguments.length>2&&void 0!==arguments[2]?arguments[2]:o.precision;return Math.abs(r-n)<t},round:function(r){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,t=Math.pow(10,n);return Math.round(r*t)/t},range:function(r,n){for(var t=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1,e=[],o=r;o<=n;o+=t)e.push(o);return e},linspace:function(r,n,t){var e=(n-r)/(t-1);return Array.from({length:t},function(n,t){return r+t*e})}}),this.precision=1e-10,this.maxIterations=1e3,this.convergenceThreshold=1e-6},[{key:"setPrecision",value:function(r){this.precision=r}},{key:"setMaxIterations",value:function(r){this.maxIterations=r}},{key:"setConvergenceThreshold",value:function(r){this.convergenceThreshold=r}}])}();export{o as Numerics};
+import { createClass as _createClass, classCallCheck as _classCallCheck, defineProperty as _defineProperty, toConsumableArray as _toConsumableArray } from '../../_virtual/_rollupPluginBabelHelpers.js';
+
+/**
+ * Numerics
+ * Handles numerical computations, calculations, and data processing
+ */
+
+var Numerics = /*#__PURE__*/function () {
+  function Numerics() {
+    var _this = this;
+    _classCallCheck(this, Numerics);
+    /**
+     * Vector operations
+     */
+    _defineProperty(this, "vector", {
+      /**
+       * Add two vectors
+       * @param {Array} a - First vector
+       * @param {Array} b - Second vector
+       * @returns {Array} Result vector
+       */
+      add: function add(a, b) {
+        return a.map(function (val, i) {
+          return val + (b[i] || 0);
+        });
+      },
+      /**
+       * Subtract two vectors
+       * @param {Array} a - First vector
+       * @param {Array} b - Second vector
+       * @returns {Array} Result vector
+       */
+      subtract: function subtract(a, b) {
+        return a.map(function (val, i) {
+          return val - (b[i] || 0);
+        });
+      },
+      /**
+       * Multiply vector by scalar
+       * @param {Array} vector - Input vector
+       * @param {number} scalar - Scalar value
+       * @returns {Array} Result vector
+       */
+      scale: function scale(vector, scalar) {
+        return vector.map(function (val) {
+          return val * scalar;
+        });
+      },
+      /**
+       * Calculate dot product
+       * @param {Array} a - First vector
+       * @param {Array} b - Second vector
+       * @returns {number} Dot product
+       */
+      dot: function dot(a, b) {
+        return a.reduce(function (sum, val, i) {
+          return sum + val * (b[i] || 0);
+        }, 0);
+      },
+      /**
+       * Calculate cross product (3D only)
+       * @param {Array} a - First vector [x, y, z]
+       * @param {Array} b - Second vector [x, y, z]
+       * @returns {Array} Cross product vector
+       */
+      cross: function cross(a, b) {
+        return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+      },
+      /**
+       * Calculate vector magnitude
+       * @param {Array} vector - Input vector
+       * @returns {number} Magnitude
+       */
+      magnitude: function magnitude(vector) {
+        return Math.sqrt(vector.reduce(function (sum, val) {
+          return sum + val * val;
+        }, 0));
+      },
+      /**
+       * Normalize vector
+       * @param {Array} vector - Input vector
+       * @returns {Array} Normalized vector
+       */
+      normalize: function normalize(vector) {
+        var mag = _this.vector.magnitude(vector);
+        return mag > 0 ? vector.map(function (val) {
+          return val / mag;
+        }) : vector.slice();
+      },
+      /**
+       * Calculate distance between two points
+       * @param {Array} a - First point
+       * @param {Array} b - Second point
+       * @returns {number} Distance
+       */
+      distance: function distance(a, b) {
+        return _this.vector.magnitude(_this.vector.subtract(a, b));
+      },
+      /**
+       * Linear interpolation between two vectors
+       * @param {Array} a - Start vector
+       * @param {Array} b - End vector
+       * @param {number} t - Interpolation factor (0-1)
+       * @returns {Array} Interpolated vector
+       */
+      lerp: function lerp(a, b, t) {
+        return a.map(function (val, i) {
+          return val + t * ((b[i] || 0) - val);
+        });
+      }
+    });
+    /**
+     * Matrix operations
+     */
+    _defineProperty(this, "matrix", {
+      /**
+       * Create identity matrix
+       * @param {number} size - Matrix size (n x n)
+       * @returns {Array} Identity matrix
+       */
+      identity: function identity(size) {
+        var matrix = Array(size).fill().map(function () {
+          return Array(size).fill(0);
+        });
+        for (var i = 0; i < size; i++) {
+          matrix[i][i] = 1;
+        }
+        return matrix;
+      },
+      /**
+       * Multiply two matrices
+       * @param {Array} a - First matrix
+       * @param {Array} b - Second matrix
+       * @returns {Array} Result matrix
+       */
+      multiply: function multiply(a, b) {
+        var rows = a.length;
+        var cols = b[0].length;
+        var result = Array(rows).fill().map(function () {
+          return Array(cols).fill(0);
+        });
+        for (var i = 0; i < rows; i++) {
+          for (var j = 0; j < cols; j++) {
+            for (var k = 0; k < a[0].length; k++) {
+              result[i][j] += a[i][k] * b[k][j];
+            }
+          }
+        }
+        return result;
+      },
+      /**
+       * Matrix-vector multiplication
+       * @param {Array} matrix - Input matrix
+       * @param {Array} vector - Input vector
+       * @returns {Array} Result vector
+       */
+      multiplyVector: function multiplyVector(matrix, vector) {
+        return matrix.map(function (row) {
+          return row.reduce(function (sum, val, i) {
+            return sum + val * (vector[i] || 0);
+          }, 0);
+        });
+      },
+      /**
+       * Calculate matrix determinant (2x2 and 3x3)
+       * @param {Array} matrix - Input matrix
+       * @returns {number} Determinant
+       */
+      determinant: function determinant(matrix) {
+        var size = matrix.length;
+        if (size === 2) {
+          return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
+        } else if (size === 3) {
+          return matrix[0][0] * (matrix[1][1] * matrix[2][2] - matrix[1][2] * matrix[2][1]) - matrix[0][1] * (matrix[1][0] * matrix[2][2] - matrix[1][2] * matrix[2][0]) + matrix[0][2] * (matrix[1][0] * matrix[2][1] - matrix[1][1] * matrix[2][0]);
+        }
+        throw new Error('Determinant calculation only supported for 2x2 and 3x3 matrices');
+      },
+      /**
+       * Matrix transpose
+       * @param {Array} matrix - Input matrix
+       * @returns {Array} Transposed matrix
+       */
+      transpose: function transpose(matrix) {
+        return matrix[0].map(function (_, i) {
+          return matrix.map(function (row) {
+            return row[i];
+          });
+        });
+      }
+    });
+    /**
+     * Numerical analysis functions
+     */
+    _defineProperty(this, "analysis", {
+      /**
+       * Newton-Raphson method for root finding
+       * @param {Function} f - Function
+       * @param {Function} df - Derivative of function
+       * @param {number} x0 - Initial guess
+       * @returns {Object} Result with root and convergence info
+       */
+      newtonRaphson: function newtonRaphson(f, df, x0) {
+        var x = x0;
+        var iterations = 0;
+        while (iterations < _this.maxIterations) {
+          var fx = f(x);
+          var dfx = df(x);
+          if (Math.abs(dfx) < _this.precision) {
+            throw new Error('Derivative too small, cannot continue');
+          }
+          var newX = x - fx / dfx;
+          if (Math.abs(newX - x) < _this.convergenceThreshold) {
+            return {
+              root: newX,
+              iterations: iterations + 1,
+              converged: true,
+              error: Math.abs(f(newX))
+            };
+          }
+          x = newX;
+          iterations++;
+        }
+        return {
+          root: x,
+          iterations: iterations,
+          converged: false,
+          error: Math.abs(f(x))
+        };
+      },
+      /**
+       * Bisection method for root finding
+       * @param {Function} f - Function
+       * @param {number} a - Left bound
+       * @param {number} b - Right bound
+       * @returns {Object} Result with root and convergence info
+       */
+      bisection: function bisection(f, a, b) {
+        if (f(a) * f(b) >= 0) {
+          throw new Error('Function must have opposite signs at bounds');
+        }
+        var left = a;
+        var right = b;
+        var iterations = 0;
+        while (iterations < _this.maxIterations) {
+          var mid = (left + right) / 2;
+          var fMid = f(mid);
+          if (Math.abs(fMid) < _this.convergenceThreshold || Math.abs(right - left) < _this.convergenceThreshold) {
+            return {
+              root: mid,
+              iterations: iterations + 1,
+              converged: true,
+              error: Math.abs(fMid)
+            };
+          }
+          if (f(left) * fMid < 0) {
+            right = mid;
+          } else {
+            left = mid;
+          }
+          iterations++;
+        }
+        return {
+          root: (left + right) / 2,
+          iterations: iterations,
+          converged: false,
+          error: Math.abs(f((left + right) / 2))
+        };
+      },
+      /**
+       * Numerical integration using Simpson's rule
+       * @param {Function} f - Function to integrate
+       * @param {number} a - Lower bound
+       * @param {number} b - Upper bound
+       * @param {number} n - Number of intervals (must be even)
+       * @returns {number} Integral approximation
+       */
+      simpson: function simpson(f, a, b) {
+        var n = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 100;
+        if (n % 2 !== 0) n++; // Ensure even number of intervals
+
+        var h = (b - a) / n;
+        var sum = f(a) + f(b);
+        for (var i = 1; i < n; i++) {
+          var x = a + i * h;
+          var coefficient = i % 2 === 0 ? 2 : 4;
+          sum += coefficient * f(x);
+        }
+        return h / 3 * sum;
+      },
+      /**
+       * Numerical differentiation
+       * @param {Function} f - Function to differentiate
+       * @param {number} x - Point of differentiation
+       * @param {number} h - Step size
+       * @returns {number} Derivative approximation
+       */
+      derivative: function derivative(f, x) {
+        var h = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1e-8;
+        return (f(x + h) - f(x - h)) / (2 * h);
+      }
+    });
+    /**
+     * Statistical functions
+     */
+    _defineProperty(this, "stats", {
+      /**
+       * Calculate mean
+       * @param {Array} data - Input data
+       * @returns {number} Mean value
+       */
+      mean: function mean(data) {
+        return data.reduce(function (sum, val) {
+          return sum + val;
+        }, 0) / data.length;
+      },
+      /**
+       * Calculate median
+       * @param {Array} data - Input data
+       * @returns {number} Median value
+       */
+      median: function median(data) {
+        var sorted = _toConsumableArray(data).sort(function (a, b) {
+          return a - b;
+        });
+        var mid = Math.floor(sorted.length / 2);
+        return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+      },
+      /**
+       * Calculate standard deviation
+       * @param {Array} data - Input data
+       * @returns {number} Standard deviation
+       */
+      stdDev: function stdDev(data) {
+        var mean = _this.stats.mean(data);
+        var variance = data.reduce(function (sum, val) {
+          return sum + Math.pow(val - mean, 2);
+        }, 0) / data.length;
+        return Math.sqrt(variance);
+      },
+      /**
+       * Calculate correlation coefficient
+       * @param {Array} x - First dataset
+       * @param {Array} y - Second dataset
+       * @returns {number} Correlation coefficient
+       */
+      correlation: function correlation(x, y) {
+        var n = Math.min(x.length, y.length);
+        var meanX = _this.stats.mean(x.slice(0, n));
+        var meanY = _this.stats.mean(y.slice(0, n));
+        var numerator = 0;
+        var sumXSq = 0;
+        var sumYSq = 0;
+        for (var i = 0; i < n; i++) {
+          var diffX = x[i] - meanX;
+          var diffY = y[i] - meanY;
+          numerator += diffX * diffY;
+          sumXSq += diffX * diffX;
+          sumYSq += diffY * diffY;
+        }
+        var denominator = Math.sqrt(sumXSq * sumYSq);
+        return denominator !== 0 ? numerator / denominator : 0;
+      },
+      /**
+       * Linear regression
+       * @param {Array} x - Independent variable
+       * @param {Array} y - Dependent variable
+       * @returns {Object} Regression parameters
+       */
+      linearRegression: function linearRegression(x, y) {
+        var n = Math.min(x.length, y.length);
+        var meanX = _this.stats.mean(x.slice(0, n));
+        var meanY = _this.stats.mean(y.slice(0, n));
+        var numerator = 0;
+        var denominator = 0;
+        for (var i = 0; i < n; i++) {
+          var diffX = x[i] - meanX;
+          numerator += diffX * (y[i] - meanY);
+          denominator += diffX * diffX;
+        }
+        var slope = denominator !== 0 ? numerator / denominator : 0;
+        var intercept = meanY - slope * meanX;
+
+        // Calculate R-squared
+        var ssRes = 0;
+        var ssTot = 0;
+        for (var _i = 0; _i < n; _i++) {
+          var predicted = slope * x[_i] + intercept;
+          ssRes += Math.pow(y[_i] - predicted, 2);
+          ssTot += Math.pow(y[_i] - meanY, 2);
+        }
+        var rSquared = ssTot !== 0 ? 1 - ssRes / ssTot : 0;
+        return {
+          slope: slope,
+          intercept: intercept,
+          rSquared: rSquared,
+          predict: function predict(xVal) {
+            return slope * xVal + intercept;
+          }
+        };
+      }
+    });
+    /**
+     * Utility functions
+     */
+    _defineProperty(this, "utils", {
+      /**
+       * Clamp value between min and max
+       * @param {number} value - Input value
+       * @param {number} min - Minimum value
+       * @param {number} max - Maximum value
+       * @returns {number} Clamped value
+       */
+      clamp: function clamp(value, min, max) {
+        return Math.max(min, Math.min(max, value));
+      },
+      /**
+       * Map value from one range to another
+       * @param {number} value - Input value
+       * @param {number} inMin - Input range minimum
+       * @param {number} inMax - Input range maximum
+       * @param {number} outMin - Output range minimum
+       * @param {number} outMax - Output range maximum
+       * @returns {number} Mapped value
+       */
+      map: function map(value, inMin, inMax, outMin, outMax) {
+        return outMin + (value - inMin) * (outMax - outMin) / (inMax - inMin);
+      },
+      /**
+       * Check if two numbers are approximately equal
+       * @param {number} a - First number
+       * @param {number} b - Second number
+       * @param {number} epsilon - Tolerance
+       * @returns {boolean} Whether numbers are approximately equal
+       */
+      approxEqual: function approxEqual(a, b) {
+        var epsilon = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _this.precision;
+        return Math.abs(a - b) < epsilon;
+      },
+      /**
+       * Round to specified decimal places
+       * @param {number} value - Input value
+       * @param {number} decimals - Number of decimal places
+       * @returns {number} Rounded value
+       */
+      round: function round(value) {
+        var decimals = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+        var factor = Math.pow(10, decimals);
+        return Math.round(value * factor) / factor;
+      },
+      /**
+       * Generate array of numbers
+       * @param {number} start - Start value
+       * @param {number} end - End value
+       * @param {number} step - Step size
+       * @returns {Array} Array of numbers
+       */
+      range: function range(start, end) {
+        var step = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+        var result = [];
+        for (var i = start; i <= end; i += step) {
+          result.push(i);
+        }
+        return result;
+      },
+      /**
+       * Generate linearly spaced array
+       * @param {number} start - Start value
+       * @param {number} end - End value
+       * @param {number} count - Number of points
+       * @returns {Array} Linearly spaced array
+       */
+      linspace: function linspace(start, end, count) {
+        var step = (end - start) / (count - 1);
+        return Array.from({
+          length: count
+        }, function (_, i) {
+          return start + i * step;
+        });
+      }
+    });
+    this.precision = 1e-10;
+    this.maxIterations = 1000;
+    this.convergenceThreshold = 1e-6;
+  }
+  return _createClass(Numerics, [{
+    key: "setPrecision",
+    value:
+    /**
+     * Set numerical precision
+     * @param {number} precision - New precision value
+     */
+    function setPrecision(precision) {
+      this.precision = precision;
+    }
+
+    /**
+     * Set maximum iterations for iterative methods
+     * @param {number} maxIterations - Maximum iterations
+     */
+  }, {
+    key: "setMaxIterations",
+    value: function setMaxIterations(maxIterations) {
+      this.maxIterations = maxIterations;
+    }
+
+    /**
+     * Set convergence threshold
+     * @param {number} threshold - Convergence threshold
+     */
+  }, {
+    key: "setConvergenceThreshold",
+    value: function setConvergenceThreshold(threshold) {
+      this.convergenceThreshold = threshold;
+    }
+  }]);
+}();
+
+export { Numerics };