make slog more precise by making it binary search

related issue: #108

break_eternity.cjs.js

@@ -2107,10 +2107,43 @@ var Decimal = /*#__PURE__*/function () {
       return result;
     } //Super-logarithm, one of tetration's inverses, tells you what size power tower you'd have to tetrate base to to get number. By definition, will never be higher than 1.8e308 in break_eternity.js, since a power tower 1.8e308 numbers tall is the largest representable number.
     // https://en.wikipedia.org/wiki/Super-logarithm
+    // NEW: Accept a number of iterations, and use binary search to, after making an initial guess, hone in on the true value, assuming tetration as the ground truth.
 
   }, {
     key: "slog",
     value: function slog() {
+      var base = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 10;
+      var iterations = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 43;
+      var step_size = 0.001;
+      var has_changed_directions_once = false;
+      var previously_rose = false;
+      var result = this.slog_internal(base).toNumber();
+
+      for (var i = 1; i < iterations; ++i) {
+        var new_decimal = new Decimal(base).tetrate(result);
+        var currently_rose = new_decimal.gt(this);
+
+        if (iterations > 1) {
+          if (previously_rose != currently_rose) {
+            has_changed_directions_once = true;
+          }
+        }
+
+        previously_rose = currently_rose;
+
+        if (has_changed_directions_once) {
+          step_size /= 2;
+        }
+
+        step_size = Math.abs(step_size) * (currently_rose ? -1 : 1);
+        result += step_size;
+      }
+
+      return Decimal.fromNumber(result);
+    }
+  }, {
+    key: "slog_internal",
+    value: function slog_internal() {
       var base = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 10;
       base = D(base); //special cases:
       //slog base 0 or lower is NaN

break_eternity.esm.js

@@ -2105,10 +2105,43 @@ var Decimal = /*#__PURE__*/function () {
       return result;
     } //Super-logarithm, one of tetration's inverses, tells you what size power tower you'd have to tetrate base to to get number. By definition, will never be higher than 1.8e308 in break_eternity.js, since a power tower 1.8e308 numbers tall is the largest representable number.
     // https://en.wikipedia.org/wiki/Super-logarithm
+    // NEW: Accept a number of iterations, and use binary search to, after making an initial guess, hone in on the true value, assuming tetration as the ground truth.
 
   }, {
     key: "slog",
     value: function slog() {
+      var base = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 10;
+      var iterations = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 43;
+      var step_size = 0.001;
+      var has_changed_directions_once = false;
+      var previously_rose = false;
+      var result = this.slog_internal(base).toNumber();
+
+      for (var i = 1; i < iterations; ++i) {
+        var new_decimal = new Decimal(base).tetrate(result);
+        var currently_rose = new_decimal.gt(this);
+
+        if (iterations > 1) {
+          if (previously_rose != currently_rose) {
+            has_changed_directions_once = true;
+          }
+        }
+
+        previously_rose = currently_rose;
+
+        if (has_changed_directions_once) {
+          step_size /= 2;
+        }
+
+        step_size = Math.abs(step_size) * (currently_rose ? -1 : 1);
+        result += step_size;
+      }
+
+      return Decimal.fromNumber(result);
+    }
+  }, {
+    key: "slog_internal",
+    value: function slog_internal() {
       var base = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 10;
       base = D(base); //special cases:
       //slog base 0 or lower is NaN

break_eternity.js

@@ -2111,10 +2111,43 @@
         return result;
       } //Super-logarithm, one of tetration's inverses, tells you what size power tower you'd have to tetrate base to to get number. By definition, will never be higher than 1.8e308 in break_eternity.js, since a power tower 1.8e308 numbers tall is the largest representable number.
       // https://en.wikipedia.org/wiki/Super-logarithm
+      // NEW: Accept a number of iterations, and use binary search to, after making an initial guess, hone in on the true value, assuming tetration as the ground truth.
 
     }, {
       key: "slog",
       value: function slog() {
+        var base = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 10;
+        var iterations = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 43;
+        var step_size = 0.001;
+        var has_changed_directions_once = false;
+        var previously_rose = false;
+        var result = this.slog_internal(base).toNumber();
+
+        for (var i = 1; i < iterations; ++i) {
+          var new_decimal = new Decimal(base).tetrate(result);
+          var currently_rose = new_decimal.gt(this);
+
+          if (iterations > 1) {
+            if (previously_rose != currently_rose) {
+              has_changed_directions_once = true;
+            }
+          }
+
+          previously_rose = currently_rose;
+
+          if (has_changed_directions_once) {
+            step_size /= 2;
+          }
+
+          step_size = Math.abs(step_size) * (currently_rose ? -1 : 1);
+          result += step_size;
+        }
+
+        return Decimal.fromNumber(result);
+      }
+    }, {
+      key: "slog_internal",
+      value: function slog_internal() {
         var base = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 10;
         base = D(base); //special cases:
         //slog base 0 or lower is NaN

index.d.ts

@@ -267,7 +267,8 @@ export default class Decimal {
     tetrate(height?: number, payload?: DecimalSource): Decimal;
     iteratedexp(height?: number, payload?: Decimal): Decimal;
     iteratedlog(base?: DecimalSource, times?: number): Decimal;
-    slog(base?: DecimalSource): Decimal;
+    slog(base?: DecimalSource, iterations?: number): Decimal;
+    slog_internal(base?: DecimalSource): Decimal;
     static slog_critical(base: number, height: number): number;
     static tetrate_critical(base: number, height: number): number;
     static critical_section(base: number, height: number, grid: number[][]): number;

src/index.ts

@@ -2456,7 +2456,35 @@ export default class Decimal {
 
   //Super-logarithm, one of tetration's inverses, tells you what size power tower you'd have to tetrate base to to get number. By definition, will never be higher than 1.8e308 in break_eternity.js, since a power tower 1.8e308 numbers tall is the largest representable number.
   // https://en.wikipedia.org/wiki/Super-logarithm
-  public slog(base: DecimalSource = 10): Decimal {
+  // NEW: Accept a number of iterations, and use binary search to, after making an initial guess, hone in on the true value, assuming tetration as the ground truth.
+  public slog(base: DecimalSource = 10, iterations = 43): Decimal {
+    let step_size = 0.001;
+    let has_changed_directions_once = false;
+    let previously_rose = false;
+    let result = this.slog_internal(base).toNumber();
+    for (var i = 1; i < iterations; ++i)
+    {
+      let new_decimal = new Decimal(base).tetrate(result);
+      let currently_rose = new_decimal.gt(this);
+      if (iterations > 1)
+      {
+        if (previously_rose != currently_rose)
+        {
+          has_changed_directions_once = true;
+        }
+      }
+      previously_rose = currently_rose;
+      if (has_changed_directions_once)
+      {
+        step_size /= 2;
+      }
+      step_size = Math.abs(step_size) * (currently_rose ? -1 : 1);
+      result += step_size;
+    }
+    return Decimal.fromNumber(result);
+  }
+
+  public slog_internal(base: DecimalSource = 10): Decimal {
     base = D(base);
 
     //special cases: