exponential-number 1.0.0 → 1.2.0

package/src/class/exponent-number.class.ts

@@ -0,0 +1,229 @@
+import {
+  minusDifferentExponentLevelNumber,
+  minusEqualExponentLevelNumber,
+  plusDifferentExponentLevelNumber,
+  plusEqualExponentLevelNumber,
+} from '../utils/util-math.utils';
+import { DECIMAL_DIGITS, VALUE_EXPONENT_DIFFERENCE_LIMIT, VALUE_EXPONENT_LIMIT } from '../const';
+
+export class ExponentNumber {
+  exponentFactor = 0;
+  value = 0;
+
+  constructor(exponentFactor = 0, value = 0) {
+    this.exponentFactor = exponentFactor;
+    this.value = value;
+
+    this.normalize();
+  }
+
+  copy(): ExponentNumber {
+    return new ExponentNumber(this.exponentFactor, this.value);
+  }
+
+  normalize(): void {
+    while (Math.log10(this.value) >= VALUE_EXPONENT_LIMIT) {
+      this.exponentFactor += 1;
+      this.value = Math.log10(this.value);
+    }
+
+    while (this.exponentFactor >= 1 && this.value < VALUE_EXPONENT_LIMIT) {
+      this.exponentFactor -= 1;
+      this.value = Math.pow(10, this.value);
+    }
+
+    while (this.exponentFactor < 0 && this.value > 0) {
+      this.exponentFactor += 1;
+      this.value = Math.max(Math.log10(this.value), 0);
+    }
+
+    if (this.value === Math.pow(10, -VALUE_EXPONENT_DIFFERENCE_LIMIT)) {
+      this.resetValue();
+    }
+  }
+
+  applyNewValues(newNumber: ExponentNumber): void {
+    this.exponentFactor = newNumber.exponentFactor;
+    this.value = newNumber.value;
+  }
+
+  resetValue(): void {
+    this.exponentFactor = 0;
+    this.value = 0;
+  }
+
+  toString(): string {
+    const cutNumber = Number(this.value.toPrecision(DECIMAL_DIGITS));
+
+    let numberText = cutNumber.toString();
+
+    if (Math.log10(cutNumber) >= VALUE_EXPONENT_DIFFERENCE_LIMIT) {
+      const numberExp = Math.floor(Math.log10(cutNumber));
+      const firstNumbers = cutNumber
+        .toString()
+        .replace('.', '')
+        .split('e')[0]
+        .slice(0, DECIMAL_DIGITS);
+      const firstPart = `${firstNumbers[0]}.${firstNumbers.slice(1)}`;
+      numberText = `${Number(firstPart)}e${numberExp}`;
+    }
+
+    return `${'e'.repeat(this.exponentFactor)}${numberText}`;
+  }
+
+  plus(otherNumber: ExponentNumber): ExponentNumber {
+    if (this.exponentFactor === otherNumber.exponentFactor) {
+      if (this.exponentFactor > 1) {
+        return this;
+      }
+
+      this.applyNewValues(plusEqualExponentLevelNumber(this, otherNumber));
+    } else {
+      if (this.exponentFactor <= 1 && otherNumber.exponentFactor <= 1) {
+        this.applyNewValues(plusDifferentExponentLevelNumber(this, otherNumber));
+      } else {
+        const biggerNumber = this.exponentFactor > otherNumber.exponentFactor ? this : otherNumber;
+        this.applyNewValues(biggerNumber);
+      }
+    }
+
+    this.normalize();
+
+    return this;
+  }
+
+  minus(otherNumber: ExponentNumber): ExponentNumber {
+    if (this.exponentFactor === otherNumber.exponentFactor) {
+      if (this.exponentFactor > 1) {
+        if (otherNumber.value >= this.value) {
+          this.resetValue();
+        }
+
+        return this;
+      }
+
+      console.log(this, otherNumber);
+      if (this.value === otherNumber.value) {
+        this.resetValue();
+
+        return this;
+      }
+
+      this.applyNewValues(minusEqualExponentLevelNumber(this, otherNumber));
+    } else {
+      if (this.exponentFactor <= 1 && otherNumber.exponentFactor <= 1) {
+        this.applyNewValues(minusDifferentExponentLevelNumber(this, otherNumber));
+      } else {
+        if (otherNumber.exponentFactor >= this.exponentFactor) {
+          this.resetValue();
+        }
+      }
+    }
+
+    this.normalize();
+
+    return this;
+  }
+
+  multiply(otherNumber: ExponentNumber): ExponentNumber {
+    const result = new ExponentNumber(this.exponentFactor, Math.log10(this.value));
+
+    result.plus(new ExponentNumber(otherNumber.exponentFactor, Math.log10(otherNumber.value)));
+
+    this.exponentFactor = result.exponentFactor + 1;
+    this.value = result.value;
+
+    this.normalize();
+
+    return this;
+  }
+
+  divide(otherNumber: ExponentNumber): ExponentNumber {
+    if (this.exponentFactor === 0 && this.value === 0) {
+      return this;
+    }
+
+    const result = new ExponentNumber(this.exponentFactor, Math.log10(this.value));
+
+    result.minus(new ExponentNumber(otherNumber.exponentFactor, Math.log10(otherNumber.value)));
+
+    console.log(result);
+    this.exponentFactor = result.exponentFactor + 1;
+    this.value = result.value;
+
+    this.normalize();
+
+    return this;
+  }
+
+  power(otherNumber: ExponentNumber): ExponentNumber {
+    const result = new ExponentNumber(this.exponentFactor, Math.log10(this.value));
+
+    result.multiply(otherNumber);
+
+    this.exponentFactor = result.exponentFactor + 1;
+    this.value = result.value;
+
+    this.normalize();
+
+    return this;
+  }
+
+  root(otherNumber: ExponentNumber): ExponentNumber {
+    const result = new ExponentNumber(this.exponentFactor, Math.log10(this.value));
+
+    if (
+      result.exponentFactor >= 1 &&
+      (otherNumber.exponentFactor > result.exponentFactor ||
+        (otherNumber.exponentFactor === result.exponentFactor && otherNumber.value > result.value))
+    ) {
+      this.resetValue();
+
+      return this;
+    }
+
+    result.divide(otherNumber);
+
+    console.log(result);
+    this.exponentFactor = result.exponentFactor + 1;
+    this.value = result.value;
+
+    this.normalize();
+
+    return this;
+  }
+
+  sqrt(): ExponentNumber {
+    return this.root(new ExponentNumber(0, 2));
+  }
+
+  log(base: ExponentNumber): ExponentNumber {
+    const result = new ExponentNumber(this.exponentFactor, Math.log10(this.value));
+    result.divide(new ExponentNumber(base.exponentFactor, Math.log10(base.value)));
+
+    this.applyNewValues(result);
+
+    this.normalize();
+
+    return this;
+  }
+
+  log10(): ExponentNumber {
+    return new ExponentNumber(this.exponentFactor - 1, this.value);
+  }
+
+  isMoreThanValue(otherNumber: ExponentNumber): boolean {
+    return (
+      this.exponentFactor > otherNumber.exponentFactor ||
+      (this.exponentFactor === otherNumber.exponentFactor && this.value > otherNumber.value)
+    );
+  }
+
+  isEqual(otherNumber: ExponentNumber): boolean {
+    return otherNumber.exponentFactor === this.exponentFactor && otherNumber.value === this.value;
+  }
+
+  isMoreThanOrEqualValue(otherNumber: ExponentNumber): boolean {
+    return this.isMoreThanValue(otherNumber) || this.isEqual(otherNumber);
+  }
+}

package/src/const.ts

@@ -0,0 +1,3 @@
+export const VALUE_EXPONENT_LIMIT = 100;
+export const VALUE_EXPONENT_DIFFERENCE_LIMIT = 12;
+export const DECIMAL_DIGITS = 5;

package/src/index.ts

@@ -1,3 +1 @@
-export function sum(a: number, b: number): number {
-  return a + b + 1;
-}
+export * from './class/exponent-number.class';

package/src/utils/util-math.utils.ts

@@ -0,0 +1,118 @@
+import { ExponentNumber } from '../class/exponent-number.class';
+import { VALUE_EXPONENT_DIFFERENCE_LIMIT } from '../const';
+
+export function plusEqualExponentLevelNumber(
+  first: ExponentNumber,
+  second: ExponentNumber,
+): ExponentNumber {
+  if (first.exponentFactor !== second.exponentFactor) {
+    throw new Error('Expected exponentFactor to be equal');
+  }
+
+  if (second.exponentFactor > 1) {
+    throw new Error('Expected exponentFactor to be lower or equal than 1');
+  }
+
+  if (second.exponentFactor === 1) {
+    if (Math.abs(first.value - second.value) > VALUE_EXPONENT_DIFFERENCE_LIMIT) {
+      return first.value - second.value > 0 ? first.copy() : second.copy();
+    }
+
+    const biggerValue = Math.max(first.value, second.value);
+    const smallerValue = Math.min(first.value, second.value);
+
+    return new ExponentNumber(
+      1,
+      biggerValue + Math.log10(1 + Math.pow(10, smallerValue - biggerValue)),
+    );
+  }
+
+  return new ExponentNumber(0, first.value + second.value);
+}
+
+export function plusDifferentExponentLevelNumber(
+  first: ExponentNumber,
+  second: ExponentNumber,
+): ExponentNumber {
+  if (first.exponentFactor === second.exponentFactor) {
+    throw new Error('Expected exponentFactor to be different');
+  }
+
+  if (first.exponentFactor > 1 || second.exponentFactor > 1) {
+    throw new Error('Expected exponentFactor to be lower or equal than 1');
+  }
+
+  const biggerValue = first.exponentFactor > second.exponentFactor ? first : second;
+  const smallerValue = first.exponentFactor > second.exponentFactor ? second : first;
+
+  const smallValueExponent = Math.log10(smallerValue.value);
+  const exponentDifference = biggerValue.value - smallValueExponent;
+
+  if (exponentDifference > VALUE_EXPONENT_DIFFERENCE_LIMIT) {
+    return biggerValue.copy();
+  }
+
+  return new ExponentNumber(
+    1,
+    biggerValue.value + Math.log10(1 + 1 / Math.pow(10, exponentDifference)),
+  );
+}
+
+export function minusEqualExponentLevelNumber(
+  first: ExponentNumber,
+  second: ExponentNumber,
+): ExponentNumber {
+  if (first.exponentFactor !== second.exponentFactor) {
+    throw new Error('Expected exponentFactor to be equal');
+  }
+
+  if (second.exponentFactor > 1) {
+    throw new Error('Expected exponentFactor to be lower or equal than 1');
+  }
+
+  if (second.exponentFactor === 1) {
+    if (second.value >= first.value) {
+      return new ExponentNumber(0, 0);
+    }
+
+    if (first.value - second.value > VALUE_EXPONENT_DIFFERENCE_LIMIT) {
+      return first.value - second.value < 0 ? first.copy() : second.copy();
+    }
+
+    return new ExponentNumber(
+      1,
+      first.value + Math.log10(1 - Math.pow(10, second.value - first.value)),
+    );
+  }
+
+  return new ExponentNumber(
+    0,
+    Math.max(first.value - second.value, -VALUE_EXPONENT_DIFFERENCE_LIMIT),
+  );
+}
+
+export function minusDifferentExponentLevelNumber(
+  first: ExponentNumber,
+  second: ExponentNumber,
+): ExponentNumber {
+  if (first.exponentFactor === second.exponentFactor) {
+    throw new Error('Expected exponentFactor to be different');
+  }
+
+  if (first.exponentFactor > 1 || second.exponentFactor > 1) {
+    throw new Error('Expected exponentFactor to be lower or equal than 1');
+  }
+
+  if (second.exponentFactor > first.exponentFactor) {
+    return new ExponentNumber(0, 0);
+  }
+
+  const smallValueExponent = Math.log10(second.value);
+  const exponentDifference = first.value - smallValueExponent;
+
+  if (exponentDifference > VALUE_EXPONENT_DIFFERENCE_LIMIT) {
+    return first.copy();
+  }
+
+  return new ExponentNumber(1, first.value + Math.log10(1 - 1 / Math.pow(10, exponentDifference)));
+}