@fluixi/utils 1.0.0-alpha.83 → 1.0.0-alpha.84

package/dist/lib/maths/fn/complex.mjs

@@ -1 +1,247 @@
-var g=2*Math.PI;function n(e){return Math.abs(e)<1e-10}function p(e,r){return Math.abs(e-r)<1e-10}function t(e){return{real:n(e.real)?0:e.real,imag:n(e.imag)?0:e.imag}}function l(e,r){if(typeof e!="number"||!Number.isFinite(e))throw new Error(`${r} must be a finite number, got ${e}`)}function m(e,r="Complex number"){if(!e||typeof e!="object")throw new Error(`${r} must be an object`);l(e.real,`${r}.real`),l(e.imag,`${r}.imag`)}function i(e,r=0){return l(e,"real"),l(r,"imag"),t({real:e,imag:r})}function M(e,r){return m(e,"First complex number"),m(r,"Second complex number"),p(e.real,r.real)&&p(e.imag,r.imag)}function c(e,r){return m(e,"First complex number"),m(r,"Second complex number"),t({real:e.real+r.real,imag:e.imag+r.imag})}function d(e,r){return m(e,"First complex number"),m(r,"Second complex number"),t({real:e.real-r.real,imag:e.imag-r.imag})}function f(e,r){return m(e,"First complex number"),m(r,"Second complex number"),t({real:e.real*r.real-e.imag*r.imag,imag:e.real*r.imag+e.imag*r.real})}function w(e,r){m(e,"Numerator complex number"),m(r,"Denominator complex number");let o=r.real*r.real+r.imag*r.imag;if(n(o))throw new Error("Cannot divide by zero or near-zero complex number");return t({real:(e.real*r.real+e.imag*r.imag)/o,imag:(e.imag*r.real-e.real*r.imag)/o})}function C(e){m(e);let r=Math.sqrt(e.real*e.real+e.imag*e.imag);return n(r)?0:r}function E(e){return m(e),t({real:e.real,imag:-e.imag})}function s(e){return m(e),n(e.real)&&n(e.imag)?0:Math.atan2(e.imag,e.real)}function h(e){return m(e),{magnitude:C(e),angle:s(e)}}function b(e,r){if(l(e,"magnitude"),l(r,"angle"),e<-1e-10)throw new Error("Magnitude must be non-negative");let o=r%g;o>Math.PI&&(o-=g),o<=-Math.PI&&(o+=g);let a=Math.max(0,e);return t({real:a*Math.cos(o),imag:a*Math.sin(o)})}function P(e){if(m(e),n(e.real)&&n(e.imag)){let N=i(0,0);return[N,N]}let r=C(e),o=s(e),a=Math.sqrt(r),u=o/2,x=u+Math.PI;return[b(a,u),b(a,x)]}function I(e,r){if(m(e),l(r,"exponent"),n(r))return i(1,0);if(p(r,1))return i(e.real,e.imag);if(p(r,2))return f(e,e);if(n(e.real)&&n(e.imag)){if(r>0)return i(0,0);if(r<0)throw new Error("Cannot raise zero to a negative power")}let o=h(e),a=Math.pow(o.magnitude,r),u=a<-1e-10?Math.abs(a):Math.max(0,a),x=o.angle*r;return b(u,x)}function z(e){m(e);let r=C(e);if(n(r))throw new Error("Cannot take logarithm of zero or near-zero complex number");let o=s(e);return t({real:Math.log(r),imag:o})}function S(e){m(e);let r=Math.exp(e.real);return t({real:r*Math.cos(e.imag),imag:r*Math.sin(e.imag)})}function y(e){return m(e),t({real:Math.sin(e.real)*Math.cosh(e.imag),imag:Math.cos(e.real)*Math.sinh(e.imag)})}function v(e){return m(e),t({real:Math.cos(e.real)*Math.cosh(e.imag),imag:-Math.sin(e.real)*Math.sinh(e.imag)})}function O(e){return m(e),n(e.real)&&n(e.imag)}function q(e){return m(e),e.real}function F(e){return m(e),e.imag}function L(e){return m(e),t({real:-e.real,imag:-e.imag})}function $(e){m(e);let r=e.real*e.real+e.imag*e.imag;if(n(r))throw new Error("Cannot calculate reciprocal of zero or near-zero complex number");return t({real:e.real/r,imag:-e.imag/r})}export{c as addComplex,s as argumentComplex,M as complexEquals,E as conjugateComplex,v as cosComplex,i as createComplex,w as divideComplex,S as expComplex,b as fromPolarComplex,F as getImag,q as getReal,O as isZeroComplex,z as lnComplex,C as magnitudeComplex,f as multiplyComplex,L as negateComplex,I as powerComplex,$ as reciprocalComplex,y as sinComplex,P as sqrtComplex,d as subtractComplex,h as toPolarComplex};
+// src/lib/maths/fn/complex.ts
+var EPSILON = 1e-10;
+var TWO_PI = 2 * Math.PI;
+function isApproximatelyZero(value) {
+  return Math.abs(value) < EPSILON;
+}
+function approximatelyEqual(a, b) {
+  return Math.abs(a - b) < EPSILON;
+}
+function normalizeComplex(c) {
+  return {
+    real: isApproximatelyZero(c.real) ? 0 : c.real,
+    imag: isApproximatelyZero(c.imag) ? 0 : c.imag
+  };
+}
+function validateNumber(value, name) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`${name} must be a finite number, got ${value}`);
+  }
+}
+function validateComplexNumber(c, name = "Complex number") {
+  if (!c || typeof c !== "object") {
+    throw new Error(`${name} must be an object`);
+  }
+  validateNumber(c.real, `${name}.real`);
+  validateNumber(c.imag, `${name}.imag`);
+}
+function createComplex(real, imag = 0) {
+  validateNumber(real, "real");
+  validateNumber(imag, "imag");
+  return normalizeComplex({ real, imag });
+}
+function complexEquals(a, b) {
+  validateComplexNumber(a, "First complex number");
+  validateComplexNumber(b, "Second complex number");
+  return approximatelyEqual(a.real, b.real) && approximatelyEqual(a.imag, b.imag);
+}
+function addComplex(a, b) {
+  validateComplexNumber(a, "First complex number");
+  validateComplexNumber(b, "Second complex number");
+  return normalizeComplex({
+    real: a.real + b.real,
+    imag: a.imag + b.imag
+  });
+}
+function subtractComplex(a, b) {
+  validateComplexNumber(a, "First complex number");
+  validateComplexNumber(b, "Second complex number");
+  return normalizeComplex({
+    real: a.real - b.real,
+    imag: a.imag - b.imag
+  });
+}
+function multiplyComplex(a, b) {
+  validateComplexNumber(a, "First complex number");
+  validateComplexNumber(b, "Second complex number");
+  return normalizeComplex({
+    real: a.real * b.real - a.imag * b.imag,
+    imag: a.real * b.imag + a.imag * b.real
+  });
+}
+function divideComplex(a, b) {
+  validateComplexNumber(a, "Numerator complex number");
+  validateComplexNumber(b, "Denominator complex number");
+  const denominator = b.real * b.real + b.imag * b.imag;
+  if (isApproximatelyZero(denominator)) {
+    throw new Error("Cannot divide by zero or near-zero complex number");
+  }
+  return normalizeComplex({
+    real: (a.real * b.real + a.imag * b.imag) / denominator,
+    imag: (a.imag * b.real - a.real * b.imag) / denominator
+  });
+}
+function magnitudeComplex(c) {
+  validateComplexNumber(c);
+  const magnitude = Math.sqrt(c.real * c.real + c.imag * c.imag);
+  return isApproximatelyZero(magnitude) ? 0 : magnitude;
+}
+function conjugateComplex(c) {
+  validateComplexNumber(c);
+  return normalizeComplex({
+    real: c.real,
+    imag: -c.imag
+  });
+}
+function argumentComplex(c) {
+  validateComplexNumber(c);
+  if (isApproximatelyZero(c.real) && isApproximatelyZero(c.imag)) {
+    return 0;
+  }
+  return Math.atan2(c.imag, c.real);
+}
+function toPolarComplex(c) {
+  validateComplexNumber(c);
+  return {
+    magnitude: magnitudeComplex(c),
+    angle: argumentComplex(c)
+  };
+}
+function fromPolarComplex(magnitude, angle) {
+  validateNumber(magnitude, "magnitude");
+  validateNumber(angle, "angle");
+  if (magnitude < -EPSILON) {
+    throw new Error("Magnitude must be non-negative");
+  }
+  let normalizedAngle = angle % TWO_PI;
+  if (normalizedAngle > Math.PI) normalizedAngle -= TWO_PI;
+  if (normalizedAngle <= -Math.PI) normalizedAngle += TWO_PI;
+  const mag = Math.max(0, magnitude);
+  return normalizeComplex({
+    real: mag * Math.cos(normalizedAngle),
+    imag: mag * Math.sin(normalizedAngle)
+  });
+}
+function sqrtComplex(c) {
+  validateComplexNumber(c);
+  if (isApproximatelyZero(c.real) && isApproximatelyZero(c.imag)) {
+    const zero = createComplex(0, 0);
+    return [zero, zero];
+  }
+  const magnitude = magnitudeComplex(c);
+  const angle = argumentComplex(c);
+  const rootMagnitude = Math.sqrt(magnitude);
+  const rootAngle1 = angle / 2;
+  const rootAngle2 = rootAngle1 + Math.PI;
+  return [
+    fromPolarComplex(rootMagnitude, rootAngle1),
+    fromPolarComplex(rootMagnitude, rootAngle2)
+  ];
+}
+function powerComplex(c, exponent) {
+  validateComplexNumber(c);
+  validateNumber(exponent, "exponent");
+  if (isApproximatelyZero(exponent)) {
+    return createComplex(1, 0);
+  }
+  if (approximatelyEqual(exponent, 1)) {
+    return createComplex(c.real, c.imag);
+  }
+  if (approximatelyEqual(exponent, 2)) {
+    return multiplyComplex(c, c);
+  }
+  if (isApproximatelyZero(c.real) && isApproximatelyZero(c.imag)) {
+    if (exponent > 0) {
+      return createComplex(0, 0);
+    } else if (exponent < 0) {
+      throw new Error("Cannot raise zero to a negative power");
+    }
+  }
+  const polar = toPolarComplex(c);
+  const magnitude = Math.pow(polar.magnitude, exponent);
+  const safeMagnitude = magnitude < -EPSILON ? Math.abs(magnitude) : Math.max(0, magnitude);
+  const angle = polar.angle * exponent;
+  return fromPolarComplex(safeMagnitude, angle);
+}
+function lnComplex(c) {
+  validateComplexNumber(c);
+  const magnitude = magnitudeComplex(c);
+  if (isApproximatelyZero(magnitude)) {
+    throw new Error(
+      "Cannot take logarithm of zero or near-zero complex number"
+    );
+  }
+  const angle = argumentComplex(c);
+  return normalizeComplex({
+    real: Math.log(magnitude),
+    imag: angle
+  });
+}
+function expComplex(c) {
+  validateComplexNumber(c);
+  const expReal = Math.exp(c.real);
+  return normalizeComplex({
+    real: expReal * Math.cos(c.imag),
+    imag: expReal * Math.sin(c.imag)
+  });
+}
+function sinComplex(c) {
+  validateComplexNumber(c);
+  return normalizeComplex({
+    real: Math.sin(c.real) * Math.cosh(c.imag),
+    imag: Math.cos(c.real) * Math.sinh(c.imag)
+  });
+}
+function cosComplex(c) {
+  validateComplexNumber(c);
+  return normalizeComplex({
+    real: Math.cos(c.real) * Math.cosh(c.imag),
+    imag: -Math.sin(c.real) * Math.sinh(c.imag)
+  });
+}
+function isZeroComplex(c) {
+  validateComplexNumber(c);
+  return isApproximatelyZero(c.real) && isApproximatelyZero(c.imag);
+}
+function getReal(c) {
+  validateComplexNumber(c);
+  return c.real;
+}
+function getImag(c) {
+  validateComplexNumber(c);
+  return c.imag;
+}
+function negateComplex(c) {
+  validateComplexNumber(c);
+  return normalizeComplex({
+    real: -c.real,
+    imag: -c.imag
+  });
+}
+function reciprocalComplex(c) {
+  validateComplexNumber(c);
+  const denominator = c.real * c.real + c.imag * c.imag;
+  if (isApproximatelyZero(denominator)) {
+    throw new Error(
+      "Cannot calculate reciprocal of zero or near-zero complex number"
+    );
+  }
+  return normalizeComplex({
+    real: c.real / denominator,
+    imag: -c.imag / denominator
+  });
+}
+export {
+  addComplex,
+  argumentComplex,
+  complexEquals,
+  conjugateComplex,
+  cosComplex,
+  createComplex,
+  divideComplex,
+  expComplex,
+  fromPolarComplex,
+  getImag,
+  getReal,
+  isZeroComplex,
+  lnComplex,
+  magnitudeComplex,
+  multiplyComplex,
+  negateComplex,
+  powerComplex,
+  reciprocalComplex,
+  sinComplex,
+  sqrtComplex,
+  subtractComplex,
+  toPolarComplex
+};