Numeric.SpecFunctions:invIncompleteGamma from math-functions-0.1.5.2, B

Average Error: 18.0 → 0.3

Time: 8.9s

Precision: binary64

Cost: 14084

Math

\[1 - \log \left(1 - \frac{x - y}{1 - y}\right) \]

↓

\[\begin{array}{l} \mathbf{if}\;y \leq -580000:\\ \;\;\;\;1 + \left(\left(\frac{1 - x}{y \cdot \left(x + -1\right)} - \log \left(\frac{-1}{y}\right)\right) - \mathsf{log1p}\left(-x\right)\right)\\ \mathbf{elif}\;y \leq 5000000000000:\\ \;\;\;\;1 - \mathsf{log1p}\left(\frac{y - x}{1 - y}\right)\\ \mathbf{else}:\\ \;\;\;\;1 - \log \left(\frac{x}{y}\right)\\ \end{array} \]

FPCore

(FPCore (x y) :precision binary64 (- 1.0 (log (- 1.0 (/ (- x y) (- 1.0 y))))))

↓

(FPCore (x y)
 :precision binary64
 (if (<= y -580000.0)
   (+
    1.0
    (- (- (/ (- 1.0 x) (* y (+ x -1.0))) (log (/ -1.0 y))) (log1p (- x))))
   (if (<= y 5000000000000.0)
     (- 1.0 (log1p (/ (- y x) (- 1.0 y))))
     (- 1.0 (log (/ x y))))))

C

double code(double x, double y) {
	return 1.0 - log((1.0 - ((x - y) / (1.0 - y))));
}

↓

double code(double x, double y) {
	double tmp;
	if (y <= -580000.0) {
		tmp = 1.0 + ((((1.0 - x) / (y * (x + -1.0))) - log((-1.0 / y))) - log1p(-x));
	} else if (y <= 5000000000000.0) {
		tmp = 1.0 - log1p(((y - x) / (1.0 - y)));
	} else {
		tmp = 1.0 - log((x / y));
	}
	return tmp;
}

Java

public static double code(double x, double y) {
	return 1.0 - Math.log((1.0 - ((x - y) / (1.0 - y))));
}

↓

public static double code(double x, double y) {
	double tmp;
	if (y <= -580000.0) {
		tmp = 1.0 + ((((1.0 - x) / (y * (x + -1.0))) - Math.log((-1.0 / y))) - Math.log1p(-x));
	} else if (y <= 5000000000000.0) {
		tmp = 1.0 - Math.log1p(((y - x) / (1.0 - y)));
	} else {
		tmp = 1.0 - Math.log((x / y));
	}
	return tmp;
}

Python

def code(x, y):
	return 1.0 - math.log((1.0 - ((x - y) / (1.0 - y))))

↓

def code(x, y):
	tmp = 0
	if y <= -580000.0:
		tmp = 1.0 + ((((1.0 - x) / (y * (x + -1.0))) - math.log((-1.0 / y))) - math.log1p(-x))
	elif y <= 5000000000000.0:
		tmp = 1.0 - math.log1p(((y - x) / (1.0 - y)))
	else:
		tmp = 1.0 - math.log((x / y))
	return tmp

Julia

function code(x, y)
	return Float64(1.0 - log(Float64(1.0 - Float64(Float64(x - y) / Float64(1.0 - y)))))
end

↓

function code(x, y)
	tmp = 0.0
	if (y <= -580000.0)
		tmp = Float64(1.0 + Float64(Float64(Float64(Float64(1.0 - x) / Float64(y * Float64(x + -1.0))) - log(Float64(-1.0 / y))) - log1p(Float64(-x))));
	elseif (y <= 5000000000000.0)
		tmp = Float64(1.0 - log1p(Float64(Float64(y - x) / Float64(1.0 - y))));
	else
		tmp = Float64(1.0 - log(Float64(x / y)));
	end
	return tmp
end

Wolfram

code[x_, y_] := N[(1.0 - N[Log[N[(1.0 - N[(N[(x - y), $MachinePrecision] / N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

↓

code[x_, y_] := If[LessEqual[y, -580000.0], N[(1.0 + N[(N[(N[(N[(1.0 - x), $MachinePrecision] / N[(y * N[(x + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[Log[N[(-1.0 / y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - N[Log[1 + (-x)], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5000000000000.0], N[(1.0 - N[Log[1 + N[(N[(y - x), $MachinePrecision] / N[(1.0 - y), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(1.0 - N[Log[N[(x / y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]

Target

Original	18.0
Target	0.1
Herbie	0.3

\[\begin{array}{l} \mathbf{if}\;y < -81284752.61947241:\\ \;\;\;\;1 - \log \left(\frac{x}{y \cdot y} - \left(\frac{1}{y} - \frac{x}{y}\right)\right)\\ \mathbf{elif}\;y < 3.0094271212461764 \cdot 10^{+25}:\\ \;\;\;\;\log \left(\frac{e^{1}}{1 - \frac{x - y}{1 - y}}\right)\\ \mathbf{else}:\\ \;\;\;\;1 - \log \left(\frac{x}{y \cdot y} - \left(\frac{1}{y} - \frac{x}{y}\right)\right)\\ \end{array} \]

Derivation

1. Split input into 3 regimes

2. if y < -5.8e5

   1. Initial program 52.1

      \[1 - \log \left(1 - \frac{x - y}{1 - y}\right) \]

   2. Simplified 52.1

      \[\leadsto \color{blue}{1 - \mathsf{log1p}\left(\frac{y - x}{1 - y}\right)} \]
      Proof
      (-.f64 1 (log1p.f64 (/.f64 (-.f64 y x) (-.f64 1 y)))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (log1p.f64 (Rewrite=> div-sub_binary64 (-.f64 (/.f64 y (-.f64 1 y)) (/.f64 x (-.f64 1 y)))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (log1p.f64 (Rewrite=> sub-neg_binary64 (+.f64 (/.f64 y (-.f64 1 y)) (neg.f64 (/.f64 x (-.f64 1 y))))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (log1p.f64 (Rewrite=> +-commutative_binary64 (+.f64 (neg.f64 (/.f64 x (-.f64 1 y))) (/.f64 y (-.f64 1 y)))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (log1p.f64 (+.f64 (neg.f64 (/.f64 x (-.f64 1 y))) (Rewrite<= remove-double-neg_binary64 (neg.f64 (neg.f64 (/.f64 y (-.f64 1 y)))))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (log1p.f64 (Rewrite<= distribute-neg-in_binary64 (neg.f64 (+.f64 (/.f64 x (-.f64 1 y)) (neg.f64 (/.f64 y (-.f64 1 y)))))))): 10 points increase in error, 0 points decrease in error
      (-.f64 1 (log1p.f64 (neg.f64 (Rewrite<= sub-neg_binary64 (-.f64 (/.f64 x (-.f64 1 y)) (/.f64 y (-.f64 1 y))))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (log1p.f64 (neg.f64 (Rewrite<= div-sub_binary64 (/.f64 (-.f64 x y) (-.f64 1 y)))))): 0 points increase in error, 10 points decrease in error
      (-.f64 1 (Rewrite<= log1p-def_binary64 (log.f64 (+.f64 1 (neg.f64 (/.f64 (-.f64 x y) (-.f64 1 y))))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (log.f64 (Rewrite<= sub-neg_binary64 (-.f64 1 (/.f64 (-.f64 x y) (-.f64 1 y)))))): 10 points increase in error, 0 points decrease in error

   3. Taylor expanded in y around -inf 0.3

      \[\leadsto 1 - \color{blue}{\left(\log \left(-1 \cdot \left(x - 1\right)\right) + \left(\log \left(\frac{-1}{y}\right) + -1 \cdot \frac{\frac{1}{x - 1} - \frac{x}{x - 1}}{y}\right)\right)} \]

   4. Simplified 0.3

      \[\leadsto 1 - \color{blue}{\left(\mathsf{log1p}\left(-x\right) + \left(\log \left(\frac{-1}{y}\right) - \frac{1 - x}{y \cdot \left(-1 + x\right)}\right)\right)} \]
      Proof
      (-.f64 1 (+.f64 (log1p.f64 (neg.f64 x)) (-.f64 (log.f64 (/.f64 -1 y)) (/.f64 (-.f64 1 x) (*.f64 y (+.f64 -1 x)))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (+.f64 (log1p.f64 (Rewrite<= mul-1-neg_binary64 (*.f64 -1 x))) (-.f64 (log.f64 (/.f64 -1 y)) (/.f64 (-.f64 1 x) (*.f64 y (+.f64 -1 x)))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (+.f64 (Rewrite<= log1p-def_binary64 (log.f64 (+.f64 1 (*.f64 -1 x)))) (-.f64 (log.f64 (/.f64 -1 y)) (/.f64 (-.f64 1 x) (*.f64 y (+.f64 -1 x)))))): 0 points increase in error, 15 points decrease in error
      (-.f64 1 (+.f64 (log.f64 (Rewrite=> +-commutative_binary64 (+.f64 (*.f64 -1 x) 1))) (-.f64 (log.f64 (/.f64 -1 y)) (/.f64 (-.f64 1 x) (*.f64 y (+.f64 -1 x)))))): 15 points increase in error, 0 points decrease in error
      (-.f64 1 (+.f64 (log.f64 (+.f64 (*.f64 -1 x) (Rewrite<= metadata-eval (*.f64 -1 -1)))) (-.f64 (log.f64 (/.f64 -1 y)) (/.f64 (-.f64 1 x) (*.f64 y (+.f64 -1 x)))))): 0 points increase in error, 15 points decrease in error
      (-.f64 1 (+.f64 (log.f64 (Rewrite<= distribute-lft-in_binary64 (*.f64 -1 (+.f64 x -1)))) (-.f64 (log.f64 (/.f64 -1 y)) (/.f64 (-.f64 1 x) (*.f64 y (+.f64 -1 x)))))): 0 points increase in error, 15 points decrease in error
      (-.f64 1 (+.f64 (log.f64 (*.f64 -1 (+.f64 x (Rewrite<= metadata-eval (neg.f64 1))))) (-.f64 (log.f64 (/.f64 -1 y)) (/.f64 (-.f64 1 x) (*.f64 y (+.f64 -1 x)))))): 15 points increase in error, 0 points decrease in error
      (-.f64 1 (+.f64 (log.f64 (*.f64 -1 (Rewrite<= sub-neg_binary64 (-.f64 x 1)))) (-.f64 (log.f64 (/.f64 -1 y)) (/.f64 (-.f64 1 x) (*.f64 y (+.f64 -1 x)))))): 0 points increase in error, 15 points decrease in error
      (-.f64 1 (+.f64 (log.f64 (*.f64 -1 (-.f64 x 1))) (-.f64 (log.f64 (/.f64 -1 y)) (/.f64 (-.f64 1 x) (*.f64 y (Rewrite<= +-commutative_binary64 (+.f64 x -1))))))): 15 points increase in error, 0 points decrease in error
      (-.f64 1 (+.f64 (log.f64 (*.f64 -1 (-.f64 x 1))) (-.f64 (log.f64 (/.f64 -1 y)) (/.f64 (-.f64 1 x) (*.f64 y (+.f64 x (Rewrite<= metadata-eval (neg.f64 1)))))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (+.f64 (log.f64 (*.f64 -1 (-.f64 x 1))) (-.f64 (log.f64 (/.f64 -1 y)) (/.f64 (-.f64 1 x) (*.f64 y (Rewrite<= sub-neg_binary64 (-.f64 x 1))))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (+.f64 (log.f64 (*.f64 -1 (-.f64 x 1))) (-.f64 (log.f64 (/.f64 -1 y)) (Rewrite<= associate-/l/_binary64 (/.f64 (/.f64 (-.f64 1 x) (-.f64 x 1)) y))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (+.f64 (log.f64 (*.f64 -1 (-.f64 x 1))) (-.f64 (log.f64 (/.f64 -1 y)) (/.f64 (Rewrite=> div-sub_binary64 (-.f64 (/.f64 1 (-.f64 x 1)) (/.f64 x (-.f64 x 1)))) y)))): 0 points increase in error, 15 points decrease in error
      (-.f64 1 (+.f64 (log.f64 (*.f64 -1 (-.f64 x 1))) (Rewrite<= unsub-neg_binary64 (+.f64 (log.f64 (/.f64 -1 y)) (neg.f64 (/.f64 (-.f64 (/.f64 1 (-.f64 x 1)) (/.f64 x (-.f64 x 1))) y)))))): 15 points increase in error, 0 points decrease in error
      (-.f64 1 (+.f64 (log.f64 (*.f64 -1 (-.f64 x 1))) (+.f64 (log.f64 (/.f64 -1 y)) (Rewrite<= mul-1-neg_binary64 (*.f64 -1 (/.f64 (-.f64 (/.f64 1 (-.f64 x 1)) (/.f64 x (-.f64 x 1))) y)))))): 0 points increase in error, 15 points decrease in error

   if -5.8e5 < y < 5e12

   1. Initial program 0.1

      \[1 - \log \left(1 - \frac{x - y}{1 - y}\right) \]

   2. Simplified 0.0

      \[\leadsto \color{blue}{1 - \mathsf{log1p}\left(\frac{y - x}{1 - y}\right)} \]
      Proof
      (-.f64 1 (log1p.f64 (/.f64 (-.f64 y x) (-.f64 1 y)))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (log1p.f64 (Rewrite=> div-sub_binary64 (-.f64 (/.f64 y (-.f64 1 y)) (/.f64 x (-.f64 1 y)))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (log1p.f64 (Rewrite=> sub-neg_binary64 (+.f64 (/.f64 y (-.f64 1 y)) (neg.f64 (/.f64 x (-.f64 1 y))))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (log1p.f64 (Rewrite=> +-commutative_binary64 (+.f64 (neg.f64 (/.f64 x (-.f64 1 y))) (/.f64 y (-.f64 1 y)))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (log1p.f64 (+.f64 (neg.f64 (/.f64 x (-.f64 1 y))) (Rewrite<= remove-double-neg_binary64 (neg.f64 (neg.f64 (/.f64 y (-.f64 1 y)))))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (log1p.f64 (Rewrite<= distribute-neg-in_binary64 (neg.f64 (+.f64 (/.f64 x (-.f64 1 y)) (neg.f64 (/.f64 y (-.f64 1 y)))))))): 10 points increase in error, 0 points decrease in error
      (-.f64 1 (log1p.f64 (neg.f64 (Rewrite<= sub-neg_binary64 (-.f64 (/.f64 x (-.f64 1 y)) (/.f64 y (-.f64 1 y))))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (log1p.f64 (neg.f64 (Rewrite<= div-sub_binary64 (/.f64 (-.f64 x y) (-.f64 1 y)))))): 0 points increase in error, 10 points decrease in error
      (-.f64 1 (Rewrite<= log1p-def_binary64 (log.f64 (+.f64 1 (neg.f64 (/.f64 (-.f64 x y) (-.f64 1 y))))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (log.f64 (Rewrite<= sub-neg_binary64 (-.f64 1 (/.f64 (-.f64 x y) (-.f64 1 y)))))): 10 points increase in error, 0 points decrease in error

   if 5e12 < y

   1. Initial program 32.9

      \[1 - \log \left(1 - \frac{x - y}{1 - y}\right) \]

   2. Simplified 32.9

      \[\leadsto \color{blue}{1 - \mathsf{log1p}\left(\frac{y - x}{1 - y}\right)} \]
      Proof
      (-.f64 1 (log1p.f64 (/.f64 (-.f64 y x) (-.f64 1 y)))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (log1p.f64 (Rewrite=> div-sub_binary64 (-.f64 (/.f64 y (-.f64 1 y)) (/.f64 x (-.f64 1 y)))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (log1p.f64 (Rewrite=> sub-neg_binary64 (+.f64 (/.f64 y (-.f64 1 y)) (neg.f64 (/.f64 x (-.f64 1 y))))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (log1p.f64 (Rewrite=> +-commutative_binary64 (+.f64 (neg.f64 (/.f64 x (-.f64 1 y))) (/.f64 y (-.f64 1 y)))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (log1p.f64 (+.f64 (neg.f64 (/.f64 x (-.f64 1 y))) (Rewrite<= remove-double-neg_binary64 (neg.f64 (neg.f64 (/.f64 y (-.f64 1 y)))))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (log1p.f64 (Rewrite<= distribute-neg-in_binary64 (neg.f64 (+.f64 (/.f64 x (-.f64 1 y)) (neg.f64 (/.f64 y (-.f64 1 y)))))))): 10 points increase in error, 0 points decrease in error
      (-.f64 1 (log1p.f64 (neg.f64 (Rewrite<= sub-neg_binary64 (-.f64 (/.f64 x (-.f64 1 y)) (/.f64 y (-.f64 1 y))))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (log1p.f64 (neg.f64 (Rewrite<= div-sub_binary64 (/.f64 (-.f64 x y) (-.f64 1 y)))))): 0 points increase in error, 10 points decrease in error
      (-.f64 1 (Rewrite<= log1p-def_binary64 (log.f64 (+.f64 1 (neg.f64 (/.f64 (-.f64 x y) (-.f64 1 y))))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (log.f64 (Rewrite<= sub-neg_binary64 (-.f64 1 (/.f64 (-.f64 x y) (-.f64 1 y)))))): 10 points increase in error, 0 points decrease in error

   3. Taylor expanded in y around inf 0.9

      \[\leadsto 1 - \color{blue}{\left(\log \left(\frac{1}{y}\right) + \log \left(x - 1\right)\right)} \]

   4. Simplified 0.9

      \[\leadsto 1 - \color{blue}{\left(\log \left(-1 + x\right) - \log y\right)} \]
      Proof
      (-.f64 1 (+.f64 (log1p.f64 (neg.f64 x)) (-.f64 (log.f64 (/.f64 -1 y)) (/.f64 (-.f64 1 x) (*.f64 y (+.f64 -1 x)))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (+.f64 (log1p.f64 (Rewrite<= mul-1-neg_binary64 (*.f64 -1 x))) (-.f64 (log.f64 (/.f64 -1 y)) (/.f64 (-.f64 1 x) (*.f64 y (+.f64 -1 x)))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (+.f64 (Rewrite<= log1p-def_binary64 (log.f64 (+.f64 1 (*.f64 -1 x)))) (-.f64 (log.f64 (/.f64 -1 y)) (/.f64 (-.f64 1 x) (*.f64 y (+.f64 -1 x)))))): 0 points increase in error, 15 points decrease in error
      (-.f64 1 (+.f64 (log.f64 (Rewrite=> +-commutative_binary64 (+.f64 (*.f64 -1 x) 1))) (-.f64 (log.f64 (/.f64 -1 y)) (/.f64 (-.f64 1 x) (*.f64 y (+.f64 -1 x)))))): 15 points increase in error, 0 points decrease in error
      (-.f64 1 (+.f64 (log.f64 (+.f64 (*.f64 -1 x) (Rewrite<= metadata-eval (*.f64 -1 -1)))) (-.f64 (log.f64 (/.f64 -1 y)) (/.f64 (-.f64 1 x) (*.f64 y (+.f64 -1 x)))))): 0 points increase in error, 15 points decrease in error
      (-.f64 1 (+.f64 (log.f64 (Rewrite<= distribute-lft-in_binary64 (*.f64 -1 (+.f64 x -1)))) (-.f64 (log.f64 (/.f64 -1 y)) (/.f64 (-.f64 1 x) (*.f64 y (+.f64 -1 x)))))): 0 points increase in error, 15 points decrease in error
      (-.f64 1 (+.f64 (log.f64 (*.f64 -1 (+.f64 x (Rewrite<= metadata-eval (neg.f64 1))))) (-.f64 (log.f64 (/.f64 -1 y)) (/.f64 (-.f64 1 x) (*.f64 y (+.f64 -1 x)))))): 15 points increase in error, 0 points decrease in error
      (-.f64 1 (+.f64 (log.f64 (*.f64 -1 (Rewrite<= sub-neg_binary64 (-.f64 x 1)))) (-.f64 (log.f64 (/.f64 -1 y)) (/.f64 (-.f64 1 x) (*.f64 y (+.f64 -1 x)))))): 0 points increase in error, 15 points decrease in error
      (-.f64 1 (+.f64 (log.f64 (*.f64 -1 (-.f64 x 1))) (-.f64 (log.f64 (/.f64 -1 y)) (/.f64 (-.f64 1 x) (*.f64 y (Rewrite<= +-commutative_binary64 (+.f64 x -1))))))): 15 points increase in error, 0 points decrease in error
      (-.f64 1 (+.f64 (log.f64 (*.f64 -1 (-.f64 x 1))) (-.f64 (log.f64 (/.f64 -1 y)) (/.f64 (-.f64 1 x) (*.f64 y (+.f64 x (Rewrite<= metadata-eval (neg.f64 1)))))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (+.f64 (log.f64 (*.f64 -1 (-.f64 x 1))) (-.f64 (log.f64 (/.f64 -1 y)) (/.f64 (-.f64 1 x) (*.f64 y (Rewrite<= sub-neg_binary64 (-.f64 x 1))))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (+.f64 (log.f64 (*.f64 -1 (-.f64 x 1))) (-.f64 (log.f64 (/.f64 -1 y)) (Rewrite<= associate-/l/_binary64 (/.f64 (/.f64 (-.f64 1 x) (-.f64 x 1)) y))))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (+.f64 (log.f64 (*.f64 -1 (-.f64 x 1))) (-.f64 (log.f64 (/.f64 -1 y)) (/.f64 (Rewrite=> div-sub_binary64 (-.f64 (/.f64 1 (-.f64 x 1)) (/.f64 x (-.f64 x 1)))) y)))): 0 points increase in error, 15 points decrease in error
      (-.f64 1 (+.f64 (log.f64 (*.f64 -1 (-.f64 x 1))) (Rewrite<= unsub-neg_binary64 (+.f64 (log.f64 (/.f64 -1 y)) (neg.f64 (/.f64 (-.f64 (/.f64 1 (-.f64 x 1)) (/.f64 x (-.f64 x 1))) y)))))): 15 points increase in error, 0 points decrease in error
      (-.f64 1 (+.f64 (log.f64 (*.f64 -1 (-.f64 x 1))) (+.f64 (log.f64 (/.f64 -1 y)) (Rewrite<= mul-1-neg_binary64 (*.f64 -1 (/.f64 (-.f64 (/.f64 1 (-.f64 x 1)) (/.f64 x (-.f64 x 1))) y)))))): 0 points increase in error, 15 points decrease in error

   5. Taylor expanded in y around 0 0.9

      \[\leadsto 1 - \color{blue}{\left(\log \left(x - 1\right) - \log y\right)} \]

   6. Simplified 0.0

      \[\leadsto 1 - \color{blue}{\log \left(\frac{-1 + x}{y}\right)} \]
      Proof
      (-.f64 1 (log.f64 (/.f64 (+.f64 -1 x) y))): 0 points increase in error, 0 points decrease in error
      (-.f64 1 (Rewrite=> log-div_binary64 (-.f64 (log.f64 (+.f64 -1 x)) (log.f64 y)))): 0 points increase in error, 5 points decrease in error
      (-.f64 1 (-.f64 (log.f64 (Rewrite=> +-commutative_binary64 (+.f64 x -1))) (log.f64 y))): 5 points increase in error, 0 points decrease in error
      (-.f64 1 (-.f64 (log.f64 (+.f64 x (Rewrite<= metadata-eval (neg.f64 1)))) (log.f64 y))): 1 points increase in error, 0 points decrease in error
      (-.f64 1 (-.f64 (log.f64 (Rewrite<= sub-neg_binary64 (-.f64 x 1))) (log.f64 y))): 0 points increase in error, 1 points decrease in error

   7. Taylor expanded in x around inf 1.5

      \[\leadsto 1 - \log \color{blue}{\left(\frac{x}{y}\right)} \]
3. Recombined 3 regimes into one program.

4. Final simplification 0.3

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -580000:\\ \;\;\;\;1 + \left(\left(\frac{1 - x}{y \cdot \left(x + -1\right)} - \log \left(\frac{-1}{y}\right)\right) - \mathsf{log1p}\left(-x\right)\right)\\ \mathbf{elif}\;y \leq 5000000000000:\\ \;\;\;\;1 - \mathsf{log1p}\left(\frac{y - x}{1 - y}\right)\\ \mathbf{else}:\\ \;\;\;\;1 - \log \left(\frac{x}{y}\right)\\ \end{array} \]

Alternatives

Alternative 1
Error	0.1
Cost	7620

\[\begin{array}{l} \mathbf{if}\;\frac{x - y}{1 - y} \leq 0.998:\\ \;\;\;\;1 - \mathsf{log1p}\left(\left(y - x\right) \cdot \frac{1}{1 - y}\right)\\ \mathbf{else}:\\ \;\;\;\;1 + \log \left(\frac{y}{x + -1}\right)\\ \end{array} \]

Alternative 2
Error	0.3
Cost	7240

\[\begin{array}{l} \mathbf{if}\;y \leq -1700000000:\\ \;\;\;\;1 + \log \left(\frac{y}{x + -1}\right)\\ \mathbf{elif}\;y \leq 5000000000000:\\ \;\;\;\;1 - \mathsf{log1p}\left(\frac{y - x}{1 - y}\right)\\ \mathbf{else}:\\ \;\;\;\;1 - \log \left(\frac{x}{y}\right)\\ \end{array} \]

Alternative 3
Error	6.6
Cost	7048

\[\begin{array}{l} \mathbf{if}\;y \leq -9.6:\\ \;\;\;\;1 + \log \left(-y\right)\\ \mathbf{elif}\;y \leq 1:\\ \;\;\;\;1 - \left(y + \mathsf{log1p}\left(-x\right)\right)\\ \mathbf{else}:\\ \;\;\;\;1 - \log \left(\frac{x}{y}\right)\\ \end{array} \]

Alternative 4
Error	0.9
Cost	7048

\[\begin{array}{l} \mathbf{if}\;y \leq -1.8:\\ \;\;\;\;1 + \log \left(\frac{y}{x + -1}\right)\\ \mathbf{elif}\;y \leq 1:\\ \;\;\;\;1 - \left(y + \mathsf{log1p}\left(-x\right)\right)\\ \mathbf{else}:\\ \;\;\;\;1 - \log \left(\frac{x}{y}\right)\\ \end{array} \]

Alternative 5
Error	6.9
Cost	6984

\[\begin{array}{l} \mathbf{if}\;y \leq -10:\\ \;\;\;\;1 + \log \left(-y\right)\\ \mathbf{elif}\;y \leq 1:\\ \;\;\;\;1 - \mathsf{log1p}\left(-x\right)\\ \mathbf{else}:\\ \;\;\;\;1 - \log \left(\frac{x}{y}\right)\\ \end{array} \]

Alternative 6
Error	26.3
Cost	6788

\[\begin{array}{l} \mathbf{if}\;y \leq -1.5:\\ \;\;\;\;1 + \log \left(-y\right)\\ \mathbf{else}:\\ \;\;\;\;1 + \left(\left(y \cdot y\right) \cdot -0.5 - y\right)\\ \end{array} \]

Alternative 7
Error	13.2
Cost	6788

\[\begin{array}{l} \mathbf{if}\;y \leq -11.8:\\ \;\;\;\;1 + \log \left(-y\right)\\ \mathbf{else}:\\ \;\;\;\;1 - \mathsf{log1p}\left(-x\right)\\ \end{array} \]

Alternative 8
Error	36.4
Cost	64

\[1 \]

Reproduce

herbie shell --seed 2022343 
(FPCore (x y)
  :name "Numeric.SpecFunctions:invIncompleteGamma from math-functions-0.1.5.2, B"
  :precision binary64

  :herbie-target
  (if (< y -81284752.61947241) (- 1.0 (log (- (/ x (* y y)) (- (/ 1.0 y) (/ x y))))) (if (< y 3.0094271212461764e+25) (log (/ (exp 1.0) (- 1.0 (/ (- x y) (- 1.0 y))))) (- 1.0 (log (- (/ x (* y y)) (- (/ 1.0 y) (/ x y)))))))

  (- 1.0 (log (- 1.0 (/ (- x y) (- 1.0 y))))))