(- (/ x0 (- 1 x1)) x0)

Percentage Accurate: 88.4% → 100.0%

Time: 5.0s

Alternatives: 6

Speedup: 1.0×

Specification

\[x0 = 1.855 \land x1 = 0.000209 \lor x0 = 2.985 \land x1 = 0.0186\]

Math

\[\begin{array}{l} \\ \frac{x0}{1 - x1} - x0 \end{array} \]

FPCore

(FPCore (x0 x1) :precision binary64 (- (/ x0 (- 1.0 x1)) x0))

C

double code(double x0, double x1) {
	return (x0 / (1.0 - x1)) - x0;
}

Fortran

real(8) function code(x0, x1)
    real(8), intent (in) :: x0
    real(8), intent (in) :: x1
    code = (x0 / (1.0d0 - x1)) - x0
end function

Java

public static double code(double x0, double x1) {
	return (x0 / (1.0 - x1)) - x0;
}

Python

def code(x0, x1):
	return (x0 / (1.0 - x1)) - x0

Julia

function code(x0, x1)
	return Float64(Float64(x0 / Float64(1.0 - x1)) - x0)
end

MATLAB

function tmp = code(x0, x1)
	tmp = (x0 / (1.0 - x1)) - x0;
end

Wolfram

code[x0_, x1_] := N[(N[(x0 / N[(1.0 - x1), $MachinePrecision]), $MachinePrecision] - x0), $MachinePrecision]

Initial Program: 88.4% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{x0}{1 - x1} - x0 \end{array} \]

FPCore

(FPCore (x0 x1) :precision binary64 (- (/ x0 (- 1.0 x1)) x0))

C

double code(double x0, double x1) {
	return (x0 / (1.0 - x1)) - x0;
}

Fortran

real(8) function code(x0, x1)
    real(8), intent (in) :: x0
    real(8), intent (in) :: x1
    code = (x0 / (1.0d0 - x1)) - x0
end function

Java

public static double code(double x0, double x1) {
	return (x0 / (1.0 - x1)) - x0;
}

Python

def code(x0, x1):
	return (x0 / (1.0 - x1)) - x0

Julia

function code(x0, x1)
	return Float64(Float64(x0 / Float64(1.0 - x1)) - x0)
end

MATLAB

function tmp = code(x0, x1)
	tmp = (x0 / (1.0 - x1)) - x0;
end

Wolfram

code[x0_, x1_] := N[(N[(x0 / N[(1.0 - x1), $MachinePrecision]), $MachinePrecision] - x0), $MachinePrecision]

Alternative 1: 100.0% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ x1 \cdot \left(x0 + x1 \cdot \left(x0 + x1 \cdot \frac{x0}{1 - x1}\right)\right) \end{array} \]

FPCore

(FPCore (x0 x1)
 :precision binary64
 (* x1 (+ x0 (* x1 (+ x0 (* x1 (/ x0 (- 1.0 x1))))))))

C

double code(double x0, double x1) {
	return x1 * (x0 + (x1 * (x0 + (x1 * (x0 / (1.0 - x1))))));
}

Fortran

real(8) function code(x0, x1)
    real(8), intent (in) :: x0
    real(8), intent (in) :: x1
    code = x1 * (x0 + (x1 * (x0 + (x1 * (x0 / (1.0d0 - x1))))))
end function

Java

public static double code(double x0, double x1) {
	return x1 * (x0 + (x1 * (x0 + (x1 * (x0 / (1.0 - x1))))));
}

Python

def code(x0, x1):
	return x1 * (x0 + (x1 * (x0 + (x1 * (x0 / (1.0 - x1))))))

Julia

function code(x0, x1)
	return Float64(x1 * Float64(x0 + Float64(x1 * Float64(x0 + Float64(x1 * Float64(x0 / Float64(1.0 - x1)))))))
end

MATLAB

function tmp = code(x0, x1)
	tmp = x1 * (x0 + (x1 * (x0 + (x1 * (x0 / (1.0 - x1))))));
end

Wolfram

code[x0_, x1_] := N[(x1 * N[(x0 + N[(x1 * N[(x0 + N[(x1 * N[(x0 / N[(1.0 - x1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 88.9%

   \[\frac{x0}{1 - x1} - x0 \]
2. Add Preprocessing

3. Taylor expanded in x0 around 0 89.4%

   \[\leadsto \color{blue}{x0 \cdot \left(\frac{1}{1 - x1} - 1\right)} \]

4. Taylor expanded in x1 around 0 73.2%

   \[\leadsto \color{blue}{x1 \cdot \left(x0 + x1 \cdot \left(x0 + x1 \cdot \left(x0 + x0 \cdot x1\right)\right)\right)} \]

6. Applied egg-rr 100.0%

   \[\leadsto x1 \cdot \left(x0 + x1 \cdot \left(x0 + x1 \cdot \color{blue}{\frac{x0}{-\left(-1 + x1\right)}}\right)\right) \]
7. Step-by-step derivation

   1. distribute-neg-in 100.0%

      \[\leadsto x1 \cdot \left(x0 + x1 \cdot \left(x0 + x1 \cdot \frac{x0}{\color{blue}{\left(--1\right) + \left(-x1\right)}}\right)\right) \]

   2. metadata-eval 100.0%

      \[\leadsto x1 \cdot \left(x0 + x1 \cdot \left(x0 + x1 \cdot \frac{x0}{\color{blue}{1} + \left(-x1\right)}\right)\right) \]

   3. sub-neg 100.0%

      \[\leadsto x1 \cdot \left(x0 + x1 \cdot \left(x0 + x1 \cdot \frac{x0}{\color{blue}{1 - x1}}\right)\right) \]

8. Simplified 100.0%

   \[\leadsto x1 \cdot \left(x0 + x1 \cdot \left(x0 + x1 \cdot \color{blue}{\frac{x0}{1 - x1}}\right)\right) \]
9. Add Preprocessing

Alternative 2: 94.4% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;1 - x1 \leq 0.99:\\ \;\;\;\;\frac{x0}{1 - x1} - x0\\ \mathbf{else}:\\ \;\;\;\;x1 \cdot \left(x0 + x1 \cdot \left(x0 + x1 \cdot \left(x0 + x1 \cdot x0\right)\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x0 x1)
 :precision binary64
 (if (<= (- 1.0 x1) 0.99)
   (- (/ x0 (- 1.0 x1)) x0)
   (* x1 (+ x0 (* x1 (+ x0 (* x1 (+ x0 (* x1 x0)))))))))

C

double code(double x0, double x1) {
	double tmp;
	if ((1.0 - x1) <= 0.99) {
		tmp = (x0 / (1.0 - x1)) - x0;
	} else {
		tmp = x1 * (x0 + (x1 * (x0 + (x1 * (x0 + (x1 * x0))))));
	}
	return tmp;
}

Fortran

real(8) function code(x0, x1)
    real(8), intent (in) :: x0
    real(8), intent (in) :: x1
    real(8) :: tmp
    if ((1.0d0 - x1) <= 0.99d0) then
        tmp = (x0 / (1.0d0 - x1)) - x0
    else
        tmp = x1 * (x0 + (x1 * (x0 + (x1 * (x0 + (x1 * x0))))))
    end if
    code = tmp
end function

Java

public static double code(double x0, double x1) {
	double tmp;
	if ((1.0 - x1) <= 0.99) {
		tmp = (x0 / (1.0 - x1)) - x0;
	} else {
		tmp = x1 * (x0 + (x1 * (x0 + (x1 * (x0 + (x1 * x0))))));
	}
	return tmp;
}

Python

def code(x0, x1):
	tmp = 0
	if (1.0 - x1) <= 0.99:
		tmp = (x0 / (1.0 - x1)) - x0
	else:
		tmp = x1 * (x0 + (x1 * (x0 + (x1 * (x0 + (x1 * x0))))))
	return tmp

Julia

function code(x0, x1)
	tmp = 0.0
	if (Float64(1.0 - x1) <= 0.99)
		tmp = Float64(Float64(x0 / Float64(1.0 - x1)) - x0);
	else
		tmp = Float64(x1 * Float64(x0 + Float64(x1 * Float64(x0 + Float64(x1 * Float64(x0 + Float64(x1 * x0)))))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x0, x1)
	tmp = 0.0;
	if ((1.0 - x1) <= 0.99)
		tmp = (x0 / (1.0 - x1)) - x0;
	else
		tmp = x1 * (x0 + (x1 * (x0 + (x1 * (x0 + (x1 * x0))))));
	end
	tmp_2 = tmp;
end

Wolfram

code[x0_, x1_] := If[LessEqual[N[(1.0 - x1), $MachinePrecision], 0.99], N[(N[(x0 / N[(1.0 - x1), $MachinePrecision]), $MachinePrecision] - x0), $MachinePrecision], N[(x1 * N[(x0 + N[(x1 * N[(x0 + N[(x1 * N[(x0 + N[(x1 * x0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if (-.f64 #s(literal 1 binary64) x1) < 0.98999999999999999

   1. Initial program 94.4%

      \[\frac{x0}{1 - x1} - x0 \]
   2. Add Preprocessing

   if 0.98999999999999999 < (-.f64 #s(literal 1 binary64) x1)

   1. Initial program 82.6%

      \[\frac{x0}{1 - x1} - x0 \]
   2. Add Preprocessing

   3. Taylor expanded in x0 around 0 84.0%

      \[\leadsto \color{blue}{x0 \cdot \left(\frac{1}{1 - x1} - 1\right)} \]

   4. Taylor expanded in x1 around 0 94.4%

      \[\leadsto \color{blue}{x1 \cdot \left(x0 + x1 \cdot \left(x0 + x1 \cdot \left(x0 + x0 \cdot x1\right)\right)\right)} \]
3. Recombined 2 regimes into one program.

4. Final simplification 94.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;1 - x1 \leq 0.99:\\ \;\;\;\;\frac{x0}{1 - x1} - x0\\ \mathbf{else}:\\ \;\;\;\;x1 \cdot \left(x0 + x1 \cdot \left(x0 + x1 \cdot \left(x0 + x1 \cdot x0\right)\right)\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 89.1% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ x0 \cdot \left(\frac{1}{1 - x1} + -1\right) \end{array} \]

FPCore

(FPCore (x0 x1) :precision binary64 (* x0 (+ (/ 1.0 (- 1.0 x1)) -1.0)))

C

double code(double x0, double x1) {
	return x0 * ((1.0 / (1.0 - x1)) + -1.0);
}

Fortran

real(8) function code(x0, x1)
    real(8), intent (in) :: x0
    real(8), intent (in) :: x1
    code = x0 * ((1.0d0 / (1.0d0 - x1)) + (-1.0d0))
end function

Java

public static double code(double x0, double x1) {
	return x0 * ((1.0 / (1.0 - x1)) + -1.0);
}

Python

def code(x0, x1):
	return x0 * ((1.0 / (1.0 - x1)) + -1.0)

Julia

function code(x0, x1)
	return Float64(x0 * Float64(Float64(1.0 / Float64(1.0 - x1)) + -1.0))
end

MATLAB

function tmp = code(x0, x1)
	tmp = x0 * ((1.0 / (1.0 - x1)) + -1.0);
end

Wolfram

code[x0_, x1_] := N[(x0 * N[(N[(1.0 / N[(1.0 - x1), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 88.9%

   \[\frac{x0}{1 - x1} - x0 \]
2. Add Preprocessing

3. Taylor expanded in x0 around 0 89.4%

   \[\leadsto \color{blue}{x0 \cdot \left(\frac{1}{1 - x1} - 1\right)} \]

4. Final simplification 89.4%

   \[\leadsto x0 \cdot \left(\frac{1}{1 - x1} + -1\right) \]
5. Add Preprocessing

Alternative 4: 88.4% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{x0}{1 - x1} - x0 \end{array} \]

FPCore

(FPCore (x0 x1) :precision binary64 (- (/ x0 (- 1.0 x1)) x0))

C

double code(double x0, double x1) {
	return (x0 / (1.0 - x1)) - x0;
}

Fortran

real(8) function code(x0, x1)
    real(8), intent (in) :: x0
    real(8), intent (in) :: x1
    code = (x0 / (1.0d0 - x1)) - x0
end function

Java

public static double code(double x0, double x1) {
	return (x0 / (1.0 - x1)) - x0;
}

Python

def code(x0, x1):
	return (x0 / (1.0 - x1)) - x0

Julia

function code(x0, x1)
	return Float64(Float64(x0 / Float64(1.0 - x1)) - x0)
end

MATLAB

function tmp = code(x0, x1)
	tmp = (x0 / (1.0 - x1)) - x0;
end

Wolfram

code[x0_, x1_] := N[(N[(x0 / N[(1.0 - x1), $MachinePrecision]), $MachinePrecision] - x0), $MachinePrecision]

Derivation

1. Initial program 88.9%

   \[\frac{x0}{1 - x1} - x0 \]
2. Add Preprocessing
3. Add Preprocessing

Alternative 5: 32.4% accurate, 2.3× speedup

Math

\[\begin{array}{l} \\ x1 \cdot x0 \end{array} \]

FPCore

(FPCore (x0 x1) :precision binary64 (* x1 x0))

C

double code(double x0, double x1) {
	return x1 * x0;
}

Fortran

real(8) function code(x0, x1)
    real(8), intent (in) :: x0
    real(8), intent (in) :: x1
    code = x1 * x0
end function

Java

public static double code(double x0, double x1) {
	return x1 * x0;
}

Python

def code(x0, x1):
	return x1 * x0

Julia

function code(x0, x1)
	return Float64(x1 * x0)
end

MATLAB

function tmp = code(x0, x1)
	tmp = x1 * x0;
end

Wolfram

code[x0_, x1_] := N[(x1 * x0), $MachinePrecision]

Derivation

1. Initial program 88.9%

   \[\frac{x0}{1 - x1} - x0 \]
2. Add Preprocessing

3. Taylor expanded in x1 around 0 32.1%

   \[\leadsto \color{blue}{x0 \cdot x1} \]

4. Final simplification 32.1%

   \[\leadsto x1 \cdot x0 \]
5. Add Preprocessing

Alternative 6: 3.1% accurate, 7.0× speedup

Math

\[\begin{array}{l} \\ 0 \end{array} \]

FPCore

(FPCore (x0 x1) :precision binary64 0.0)

C

double code(double x0, double x1) {
	return 0.0;
}

Fortran

real(8) function code(x0, x1)
    real(8), intent (in) :: x0
    real(8), intent (in) :: x1
    code = 0.0d0
end function

Java

public static double code(double x0, double x1) {
	return 0.0;
}

Python

def code(x0, x1):
	return 0.0

Julia

function code(x0, x1)
	return 0.0
end

MATLAB

function tmp = code(x0, x1)
	tmp = 0.0;
end

Wolfram

code[x0_, x1_] := 0.0

Derivation

1. Initial program 88.9%

   \[\frac{x0}{1 - x1} - x0 \]
2. Add Preprocessing
3. Step-by-step derivation

   1. sub-neg 88.9%

      \[\leadsto \color{blue}{\frac{x0}{1 - x1} + \left(-x0\right)} \]

   2. +-commutative 88.9%

      \[\leadsto \color{blue}{\left(-x0\right) + \frac{x0}{1 - x1}} \]

   3. add-sqr-sqrt 88.9%

      \[\leadsto \left(-\color{blue}{\sqrt{x0} \cdot \sqrt{x0}}\right) + \frac{x0}{1 - x1} \]

   4. distribute-rgt-neg-in 88.9%

      \[\leadsto \color{blue}{\sqrt{x0} \cdot \left(-\sqrt{x0}\right)} + \frac{x0}{1 - x1} \]

   5. fma-define 91.5%

      \[\leadsto \color{blue}{\mathsf{fma}\left(\sqrt{x0}, -\sqrt{x0}, \frac{x0}{1 - x1}\right)} \]

4. Applied egg-rr 91.5%

   \[\leadsto \color{blue}{\mathsf{fma}\left(\sqrt{x0}, -\sqrt{x0}, \frac{x0}{1 - x1}\right)} \]

5. Taylor expanded in x1 around 0 3.1%

   \[\leadsto \color{blue}{x0 + -1 \cdot x0} \]
6. Step-by-step derivation

   1. distribute-rgt1-in 3.1%

      \[\leadsto \color{blue}{\left(-1 + 1\right) \cdot x0} \]

   2. metadata-eval 3.1%

      \[\leadsto \color{blue}{0} \cdot x0 \]

   3. mul0-lft 3.1%

      \[\leadsto \color{blue}{0} \]

7. Simplified 3.1%

   \[\leadsto \color{blue}{0} \]
8. Add Preprocessing

Developer Target 1: 100.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{x0 \cdot x1}{1 - x1} \end{array} \]

FPCore

(FPCore (x0 x1) :precision binary64 (/ (* x0 x1) (- 1.0 x1)))

C

double code(double x0, double x1) {
	return (x0 * x1) / (1.0 - x1);
}

Fortran

real(8) function code(x0, x1)
    real(8), intent (in) :: x0
    real(8), intent (in) :: x1
    code = (x0 * x1) / (1.0d0 - x1)
end function

Java

public static double code(double x0, double x1) {
	return (x0 * x1) / (1.0 - x1);
}

Python

def code(x0, x1):
	return (x0 * x1) / (1.0 - x1)

Julia

function code(x0, x1)
	return Float64(Float64(x0 * x1) / Float64(1.0 - x1))
end

MATLAB

function tmp = code(x0, x1)
	tmp = (x0 * x1) / (1.0 - x1);
end

Wolfram

code[x0_, x1_] := N[(N[(x0 * x1), $MachinePrecision] / N[(1.0 - x1), $MachinePrecision]), $MachinePrecision]

Reproduce

herbie shell --seed 2024169 
(FPCore (x0 x1)
  :name "(- (/ x0 (- 1 x1)) x0)"
  :precision binary64
  :pre (or (and (== x0 1.855) (== x1 0.000209)) (and (== x0 2.985) (== x1 0.0186)))

  :alt
  (! :herbie-platform default (/ (* x0 x1) (- 1 x1)))

  (- (/ x0 (- 1.0 x1)) x0))