Result for sqrt(1+x)-1

Specification

\[10^{-12} \leq x \land x \leq 1000000000000\]

\[\sqrt{1 + x} - 1 \]

(FPCore (x)
  :precision binary64
  (- (sqrt (+ 1.0 x)) 1.0))

double code(double x) {
	return sqrt((1.0 + x)) - 1.0;
}

real(8) function code(x)
    real(8), intent (in) :: x
    code = sqrt((1.0d0 + x)) - 1.0d0
end function

public static double code(double x) {
	return Math.sqrt((1.0 + x)) - 1.0;
}

def code(x):
	return math.sqrt((1.0 + x)) - 1.0

function code(x)
	return Float64(sqrt(Float64(1.0 + x)) - 1.0)
end

function tmp = code(x)
	tmp = sqrt((1.0 + x)) - 1.0;
end

code[x_] := N[(N[Sqrt[N[(1.0 + x), $MachinePrecision]], $MachinePrecision] - 1.0), $MachinePrecision]

\sqrt{1 + x} - 1

Initial Program: 85.1% accurate, 1.0× speedup?

\[\sqrt{1 + x} - 1 \]

(FPCore (x)
  :precision binary64
  (- (sqrt (+ 1.0 x)) 1.0))

double code(double x) {
	return sqrt((1.0 + x)) - 1.0;
}

real(8) function code(x)
    real(8), intent (in) :: x
    code = sqrt((1.0d0 + x)) - 1.0d0
end function

public static double code(double x) {
	return Math.sqrt((1.0 + x)) - 1.0;
}

def code(x):
	return math.sqrt((1.0 + x)) - 1.0

function code(x)
	return Float64(sqrt(Float64(1.0 + x)) - 1.0)
end

function tmp = code(x)
	tmp = sqrt((1.0 + x)) - 1.0;
end

code[x_] := N[(N[Sqrt[N[(1.0 + x), $MachinePrecision]], $MachinePrecision] - 1.0), $MachinePrecision]

\sqrt{1 + x} - 1

Alternative 1: 99.3% accurate, 0.5× speedup?

\[\frac{x}{\mathsf{fma}\left(\frac{\sqrt{x - -1}}{x}, x, 1\right)} \]

(FPCore (x)
  :precision binary64
  (/ x (fma (/ (sqrt (- x -1.0)) x) x 1.0)))

double code(double x) {
	return x / fma((sqrt((x - -1.0)) / x), x, 1.0);
}

function code(x)
	return Float64(x / fma(Float64(sqrt(Float64(x - -1.0)) / x), x, 1.0))
end

code[x_] := N[(x / N[(N[(N[Sqrt[N[(x - -1.0), $MachinePrecision]], $MachinePrecision] / x), $MachinePrecision] * x + 1.0), $MachinePrecision]), $MachinePrecision]

\frac{x}{\mathsf{fma}\left(\frac{\sqrt{x - -1}}{x}, x, 1\right)}

Derivation

Initial program 85.1%
\[\sqrt{1 + x} - 1 \]
Applied rewrites85.6%
\[\leadsto \color{blue}{\frac{\left(x - -1\right) - 1 \cdot 1}{\sqrt{x - -1} + 1}} \]
Step-by-step derivation
1. lift--.f64N/A
  \[\leadsto \frac{\color{blue}{\left(x - -1\right) - 1 \cdot 1}}{\sqrt{x - -1} + 1} \]
2. lift--.f64N/A
  \[\leadsto \frac{\color{blue}{\left(x - -1\right)} - 1 \cdot 1}{\sqrt{x - -1} + 1} \]
3. lift-*.f64N/A
  \[\leadsto \frac{\left(x - -1\right) - \color{blue}{1 \cdot 1}}{\sqrt{x - -1} + 1} \]
4. metadata-evalN/A
  \[\leadsto \frac{\left(x - -1\right) - \color{blue}{1}}{\sqrt{x - -1} + 1} \]
5. associate--l-N/A
  \[\leadsto \frac{\color{blue}{x - \left(-1 + 1\right)}}{\sqrt{x - -1} + 1} \]
6. metadata-evalN/A
  \[\leadsto \frac{x - \color{blue}{0}}{\sqrt{x - -1} + 1} \]
7. --rgt-identity99.3%
  \[\leadsto \frac{\color{blue}{x}}{\sqrt{x - -1} + 1} \]
8. lift-+.f64N/A
  \[\leadsto \frac{x}{\color{blue}{\sqrt{x - -1} + 1}} \]
9. add-flipN/A
  \[\leadsto \frac{x}{\color{blue}{\sqrt{x - -1} - \left(\mathsf{neg}\left(1\right)\right)}} \]
10. metadata-evalN/A
  \[\leadsto \frac{x}{\sqrt{x - -1} - \color{blue}{-1}} \]
11. lower--.f6499.3%
  \[\leadsto \frac{x}{\color{blue}{\sqrt{x - -1} - -1}} \]
Applied rewrites99.3%
\[\leadsto \color{blue}{\frac{x}{\sqrt{x - -1} - -1}} \]
Step-by-step derivation
1. lift-/.f64N/A
  \[\leadsto \color{blue}{\frac{x}{\sqrt{x - -1} - -1}} \]
2. div-flip-revN/A
  \[\leadsto \color{blue}{\frac{1}{\frac{\sqrt{x - -1} - -1}{x}}} \]
3. lift--.f64N/A
  \[\leadsto \frac{1}{\frac{\color{blue}{\sqrt{x - -1} - -1}}{x}} \]
4. div-subN/A
  \[\leadsto \frac{1}{\color{blue}{\frac{\sqrt{x - -1}}{x} - \frac{-1}{x}}} \]
5. sub-to-fractionN/A
  \[\leadsto \frac{1}{\color{blue}{\frac{\frac{\sqrt{x - -1}}{x} \cdot x - -1}{x}}} \]
6. div-flip-revN/A
  \[\leadsto \color{blue}{\frac{x}{\frac{\sqrt{x - -1}}{x} \cdot x - -1}} \]
7. lower-/.f64N/A
  \[\leadsto \color{blue}{\frac{x}{\frac{\sqrt{x - -1}}{x} \cdot x - -1}} \]
8. metadata-evalN/A
  \[\leadsto \frac{x}{\frac{\sqrt{x - -1}}{x} \cdot x - \color{blue}{\left(\mathsf{neg}\left(1\right)\right)}} \]
9. add-flip-revN/A
  \[\leadsto \frac{x}{\color{blue}{\frac{\sqrt{x - -1}}{x} \cdot x + 1}} \]
10. lower-fma.f64N/A
  \[\leadsto \frac{x}{\color{blue}{\mathsf{fma}\left(\frac{\sqrt{x - -1}}{x}, x, 1\right)}} \]
11. lower-/.f6499.2%
  \[\leadsto \frac{x}{\mathsf{fma}\left(\color{blue}{\frac{\sqrt{x - -1}}{x}}, x, 1\right)} \]
Applied rewrites99.2%
\[\leadsto \color{blue}{\frac{x}{\mathsf{fma}\left(\frac{\sqrt{x - -1}}{x}, x, 1\right)}} \]
Add Preprocessing

Alternative 2: 99.3% accurate, 0.5× speedup?

\[\frac{x \cdot x}{\mathsf{fma}\left(\sqrt{x - -1}, x, x\right)} \]

(FPCore (x)
  :precision binary64
  (/ (* x x) (fma (sqrt (- x -1.0)) x x)))

double code(double x) {
	return (x * x) / fma(sqrt((x - -1.0)), x, x);
}

function code(x)
	return Float64(Float64(x * x) / fma(sqrt(Float64(x - -1.0)), x, x))
end

code[x_] := N[(N[(x * x), $MachinePrecision] / N[(N[Sqrt[N[(x - -1.0), $MachinePrecision]], $MachinePrecision] * x + x), $MachinePrecision]), $MachinePrecision]

\frac{x \cdot x}{\mathsf{fma}\left(\sqrt{x - -1}, x, x\right)}

Derivation

Initial program 85.1%
\[\sqrt{1 + x} - 1 \]
Applied rewrites85.6%
\[\leadsto \color{blue}{\frac{\left(x - -1\right) - 1 \cdot 1}{\sqrt{x - -1} + 1}} \]
Step-by-step derivation
1. lift--.f64N/A
  \[\leadsto \frac{\color{blue}{\left(x - -1\right) - 1 \cdot 1}}{\sqrt{x - -1} + 1} \]
2. lift--.f64N/A
  \[\leadsto \frac{\color{blue}{\left(x - -1\right)} - 1 \cdot 1}{\sqrt{x - -1} + 1} \]
3. lift-*.f64N/A
  \[\leadsto \frac{\left(x - -1\right) - \color{blue}{1 \cdot 1}}{\sqrt{x - -1} + 1} \]
4. metadata-evalN/A
  \[\leadsto \frac{\left(x - -1\right) - \color{blue}{1}}{\sqrt{x - -1} + 1} \]
5. associate--l-N/A
  \[\leadsto \frac{\color{blue}{x - \left(-1 + 1\right)}}{\sqrt{x - -1} + 1} \]
6. metadata-evalN/A
  \[\leadsto \frac{x - \color{blue}{0}}{\sqrt{x - -1} + 1} \]
7. --rgt-identity99.3%
  \[\leadsto \frac{\color{blue}{x}}{\sqrt{x - -1} + 1} \]
8. lift-+.f64N/A
  \[\leadsto \frac{x}{\color{blue}{\sqrt{x - -1} + 1}} \]
9. add-flipN/A
  \[\leadsto \frac{x}{\color{blue}{\sqrt{x - -1} - \left(\mathsf{neg}\left(1\right)\right)}} \]
10. metadata-evalN/A
  \[\leadsto \frac{x}{\sqrt{x - -1} - \color{blue}{-1}} \]
11. lower--.f6499.3%
  \[\leadsto \frac{x}{\color{blue}{\sqrt{x - -1} - -1}} \]
Applied rewrites99.3%
\[\leadsto \color{blue}{\frac{x}{\sqrt{x - -1} - -1}} \]
Step-by-step derivation
1. lift-/.f64N/A
  \[\leadsto \color{blue}{\frac{x}{\sqrt{x - -1} - -1}} \]
2. div-flip-revN/A
  \[\leadsto \color{blue}{\frac{1}{\frac{\sqrt{x - -1} - -1}{x}}} \]
3. lift--.f64N/A
  \[\leadsto \frac{1}{\frac{\color{blue}{\sqrt{x - -1} - -1}}{x}} \]
4. div-subN/A
  \[\leadsto \frac{1}{\color{blue}{\frac{\sqrt{x - -1}}{x} - \frac{-1}{x}}} \]
5. frac-subN/A
  \[\leadsto \frac{1}{\color{blue}{\frac{\sqrt{x - -1} \cdot x - x \cdot -1}{x \cdot x}}} \]
6. div-flip-revN/A
  \[\leadsto \color{blue}{\frac{x \cdot x}{\sqrt{x - -1} \cdot x - x \cdot -1}} \]
7. lower-/.f64N/A
  \[\leadsto \color{blue}{\frac{x \cdot x}{\sqrt{x - -1} \cdot x - x \cdot -1}} \]
8. lower-*.f64N/A
  \[\leadsto \frac{\color{blue}{x \cdot x}}{\sqrt{x - -1} \cdot x - x \cdot -1} \]
9. sub-flipN/A
  \[\leadsto \frac{x \cdot x}{\color{blue}{\sqrt{x - -1} \cdot x + \left(\mathsf{neg}\left(x \cdot -1\right)\right)}} \]
10. distribute-rgt-neg-outN/A
  \[\leadsto \frac{x \cdot x}{\sqrt{x - -1} \cdot x + \color{blue}{x \cdot \left(\mathsf{neg}\left(-1\right)\right)}} \]
11. metadata-evalN/A
  \[\leadsto \frac{x \cdot x}{\sqrt{x - -1} \cdot x + x \cdot \color{blue}{1}} \]
12. *-rgt-identityN/A
  \[\leadsto \frac{x \cdot x}{\sqrt{x - -1} \cdot x + \color{blue}{x}} \]
13. lower-fma.f6499.3%
  \[\leadsto \frac{x \cdot x}{\color{blue}{\mathsf{fma}\left(\sqrt{x - -1}, x, x\right)}} \]
Applied rewrites99.3%
\[\leadsto \color{blue}{\frac{x \cdot x}{\mathsf{fma}\left(\sqrt{x - -1}, x, x\right)}} \]
Add Preprocessing

Alternative 3: 99.2% accurate, 0.7× speedup?

\[\frac{x}{\sqrt{x - -1} - -1} \]

(FPCore (x)
  :precision binary64
  (/ x (- (sqrt (- x -1.0)) -1.0)))

double code(double x) {
	return x / (sqrt((x - -1.0)) - -1.0);
}

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

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

def code(x):
	return x / (math.sqrt((x - -1.0)) - -1.0)

function code(x)
	return Float64(x / Float64(sqrt(Float64(x - -1.0)) - -1.0))
end

function tmp = code(x)
	tmp = x / (sqrt((x - -1.0)) - -1.0);
end

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

\frac{x}{\sqrt{x - -1} - -1}

Derivation

Initial program 85.1%
\[\sqrt{1 + x} - 1 \]
Applied rewrites85.6%
\[\leadsto \color{blue}{\frac{\left(x - -1\right) - 1 \cdot 1}{\sqrt{x - -1} + 1}} \]
Step-by-step derivation
1. lift--.f64N/A
  \[\leadsto \frac{\color{blue}{\left(x - -1\right) - 1 \cdot 1}}{\sqrt{x - -1} + 1} \]
2. lift--.f64N/A
  \[\leadsto \frac{\color{blue}{\left(x - -1\right)} - 1 \cdot 1}{\sqrt{x - -1} + 1} \]
3. lift-*.f64N/A
  \[\leadsto \frac{\left(x - -1\right) - \color{blue}{1 \cdot 1}}{\sqrt{x - -1} + 1} \]
4. metadata-evalN/A
  \[\leadsto \frac{\left(x - -1\right) - \color{blue}{1}}{\sqrt{x - -1} + 1} \]
5. associate--l-N/A
  \[\leadsto \frac{\color{blue}{x - \left(-1 + 1\right)}}{\sqrt{x - -1} + 1} \]
6. metadata-evalN/A
  \[\leadsto \frac{x - \color{blue}{0}}{\sqrt{x - -1} + 1} \]
7. --rgt-identity99.3%
  \[\leadsto \frac{\color{blue}{x}}{\sqrt{x - -1} + 1} \]
8. lift-+.f64N/A
  \[\leadsto \frac{x}{\color{blue}{\sqrt{x - -1} + 1}} \]
9. add-flipN/A
  \[\leadsto \frac{x}{\color{blue}{\sqrt{x - -1} - \left(\mathsf{neg}\left(1\right)\right)}} \]
10. metadata-evalN/A
  \[\leadsto \frac{x}{\sqrt{x - -1} - \color{blue}{-1}} \]
11. lower--.f6499.3%
  \[\leadsto \frac{x}{\color{blue}{\sqrt{x - -1} - -1}} \]
Applied rewrites99.3%
\[\leadsto \color{blue}{\frac{x}{\sqrt{x - -1} - -1}} \]
Add Preprocessing

Alternative 4: 96.2% accurate, 0.5× speedup?

\[\begin{array}{l} \mathbf{if}\;x \leq 9.8 \cdot 10^{-6}:\\ \;\;\;\;\frac{1}{\frac{2}{x} - -0.5}\\ \mathbf{else}:\\ \;\;\;\;\sqrt{1 + x} - 1\\ \end{array} \]

(FPCore (x)
  :precision binary64
  (if (<= x 9.8e-6) (/ 1.0 (- (/ 2.0 x) -0.5)) (- (sqrt (+ 1.0 x)) 1.0)))

double code(double x) {
	double tmp;
	if (x <= 9.8e-6) {
		tmp = 1.0 / ((2.0 / x) - -0.5);
	} else {
		tmp = sqrt((1.0 + x)) - 1.0;
	}
	return tmp;
}

real(8) function code(x)
    real(8), intent (in) :: x
    real(8) :: tmp
    if (x <= 9.8d-6) then
        tmp = 1.0d0 / ((2.0d0 / x) - (-0.5d0))
    else
        tmp = sqrt((1.0d0 + x)) - 1.0d0
    end if
    code = tmp
end function

public static double code(double x) {
	double tmp;
	if (x <= 9.8e-6) {
		tmp = 1.0 / ((2.0 / x) - -0.5);
	} else {
		tmp = Math.sqrt((1.0 + x)) - 1.0;
	}
	return tmp;
}

def code(x):
	tmp = 0
	if x <= 9.8e-6:
		tmp = 1.0 / ((2.0 / x) - -0.5)
	else:
		tmp = math.sqrt((1.0 + x)) - 1.0
	return tmp

function code(x)
	tmp = 0.0
	if (x <= 9.8e-6)
		tmp = Float64(1.0 / Float64(Float64(2.0 / x) - -0.5));
	else
		tmp = Float64(sqrt(Float64(1.0 + x)) - 1.0);
	end
	return tmp
end

function tmp_2 = code(x)
	tmp = 0.0;
	if (x <= 9.8e-6)
		tmp = 1.0 / ((2.0 / x) - -0.5);
	else
		tmp = sqrt((1.0 + x)) - 1.0;
	end
	tmp_2 = tmp;
end

code[x_] := If[LessEqual[x, 9.8e-6], N[(1.0 / N[(N[(2.0 / x), $MachinePrecision] - -0.5), $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[(1.0 + x), $MachinePrecision]], $MachinePrecision] - 1.0), $MachinePrecision]]

\begin{array}{l}
\mathbf{if}\;x \leq 9.8 \cdot 10^{-6}:\\
\;\;\;\;\frac{1}{\frac{2}{x} - -0.5}\\

\mathbf{else}:\\
\;\;\;\;\sqrt{1 + x} - 1\\


\end{array}

Derivation

Split input into 2 regimes
if x < 9.7999999999999993e-6
1. Initial program 85.1%
  \[\sqrt{1 + x} - 1 \]
3. Applied rewrites85.0%
  \[\leadsto \color{blue}{\frac{1}{\frac{2}{\mathsf{fma}\left(2, \sqrt{x - -1}, -2\right)}}} \]
4. Taylor expanded in x around 0
  \[\leadsto \frac{1}{\color{blue}{\frac{2 + \frac{1}{2} \cdot x}{x}}} \]
5. Step-by-step derivation
  1. lower-/.f64N/A
    \[\leadsto \frac{1}{\frac{2 + \frac{1}{2} \cdot x}{\color{blue}{x}}} \]
  2. lower-+.f64N/A
    \[\leadsto \frac{1}{\frac{2 + \frac{1}{2} \cdot x}{x}} \]
  3. lower-*.f6445.6%
    \[\leadsto \frac{1}{\frac{2 + 0.5 \cdot x}{x}} \]
6. Applied rewrites45.6%
  \[\leadsto \frac{1}{\color{blue}{\frac{2 + 0.5 \cdot x}{x}}} \]
7. Step-by-step derivation
  1. lift-/.f64N/A
    \[\leadsto \frac{1}{\frac{2 + \frac{1}{2} \cdot x}{\color{blue}{x}}} \]
  2. lift-+.f64N/A
    \[\leadsto \frac{1}{\frac{2 + \frac{1}{2} \cdot x}{x}} \]
  3. div-addN/A
    \[\leadsto \frac{1}{\frac{2}{x} + \color{blue}{\frac{\frac{1}{2} \cdot x}{x}}} \]
  4. lift-/.f64N/A
    \[\leadsto \frac{1}{\frac{2}{x} + \frac{\color{blue}{\frac{1}{2} \cdot x}}{x}} \]
  5. add-flipN/A
    \[\leadsto \frac{1}{\frac{2}{x} - \color{blue}{\left(\mathsf{neg}\left(\frac{\frac{1}{2} \cdot x}{x}\right)\right)}} \]
  6. lower--.f64N/A
    \[\leadsto \frac{1}{\frac{2}{x} - \color{blue}{\left(\mathsf{neg}\left(\frac{\frac{1}{2} \cdot x}{x}\right)\right)}} \]
  7. lift-*.f64N/A
    \[\leadsto \frac{1}{\frac{2}{x} - \left(\mathsf{neg}\left(\frac{\frac{1}{2} \cdot x}{x}\right)\right)} \]
  8. associate-/l*N/A
    \[\leadsto \frac{1}{\frac{2}{x} - \left(\mathsf{neg}\left(\frac{1}{2} \cdot \frac{x}{x}\right)\right)} \]
  9. *-inversesN/A
    \[\leadsto \frac{1}{\frac{2}{x} - \left(\mathsf{neg}\left(\frac{1}{2} \cdot 1\right)\right)} \]
  10. metadata-evalN/A
    \[\leadsto \frac{1}{\frac{2}{x} - \left(\mathsf{neg}\left(\frac{1}{2}\right)\right)} \]
  11. metadata-eval45.6%
    \[\leadsto \frac{1}{\frac{2}{x} - -0.5} \]
8. Applied rewrites45.6%
  \[\leadsto \frac{1}{\frac{2}{x} - \color{blue}{-0.5}} \]
if 9.7999999999999993e-6 < x
1. Initial program 85.1%
  \[\sqrt{1 + x} - 1 \]
Recombined 2 regimes into one program.
Add Preprocessing

Alternative 5: 96.2% accurate, 0.6× speedup?

\[\begin{array}{l} \mathbf{if}\;x \leq 9.8 \cdot 10^{-6}:\\ \;\;\;\;\frac{x}{2 + 0.5 \cdot x}\\ \mathbf{else}:\\ \;\;\;\;\sqrt{1 + x} - 1\\ \end{array} \]

(FPCore (x)
  :precision binary64
  (if (<= x 9.8e-6) (/ x (+ 2.0 (* 0.5 x))) (- (sqrt (+ 1.0 x)) 1.0)))

double code(double x) {
	double tmp;
	if (x <= 9.8e-6) {
		tmp = x / (2.0 + (0.5 * x));
	} else {
		tmp = sqrt((1.0 + x)) - 1.0;
	}
	return tmp;
}

real(8) function code(x)
    real(8), intent (in) :: x
    real(8) :: tmp
    if (x <= 9.8d-6) then
        tmp = x / (2.0d0 + (0.5d0 * x))
    else
        tmp = sqrt((1.0d0 + x)) - 1.0d0
    end if
    code = tmp
end function

public static double code(double x) {
	double tmp;
	if (x <= 9.8e-6) {
		tmp = x / (2.0 + (0.5 * x));
	} else {
		tmp = Math.sqrt((1.0 + x)) - 1.0;
	}
	return tmp;
}

def code(x):
	tmp = 0
	if x <= 9.8e-6:
		tmp = x / (2.0 + (0.5 * x))
	else:
		tmp = math.sqrt((1.0 + x)) - 1.0
	return tmp

function code(x)
	tmp = 0.0
	if (x <= 9.8e-6)
		tmp = Float64(x / Float64(2.0 + Float64(0.5 * x)));
	else
		tmp = Float64(sqrt(Float64(1.0 + x)) - 1.0);
	end
	return tmp
end

function tmp_2 = code(x)
	tmp = 0.0;
	if (x <= 9.8e-6)
		tmp = x / (2.0 + (0.5 * x));
	else
		tmp = sqrt((1.0 + x)) - 1.0;
	end
	tmp_2 = tmp;
end

code[x_] := If[LessEqual[x, 9.8e-6], N[(x / N[(2.0 + N[(0.5 * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[(1.0 + x), $MachinePrecision]], $MachinePrecision] - 1.0), $MachinePrecision]]

\begin{array}{l}
\mathbf{if}\;x \leq 9.8 \cdot 10^{-6}:\\
\;\;\;\;\frac{x}{2 + 0.5 \cdot x}\\

\mathbf{else}:\\
\;\;\;\;\sqrt{1 + x} - 1\\


\end{array}

Derivation

Split input into 2 regimes
if x < 9.7999999999999993e-6
1. Initial program 85.1%
  \[\sqrt{1 + x} - 1 \]
3. Applied rewrites85.6%
  \[\leadsto \color{blue}{\frac{\left(x - -1\right) - 1 \cdot 1}{\sqrt{x - -1} + 1}} \]
4. Step-by-step derivation
  1. lift--.f64N/A
    \[\leadsto \frac{\color{blue}{\left(x - -1\right) - 1 \cdot 1}}{\sqrt{x - -1} + 1} \]
  2. lift--.f64N/A
    \[\leadsto \frac{\color{blue}{\left(x - -1\right)} - 1 \cdot 1}{\sqrt{x - -1} + 1} \]
  3. lift-*.f64N/A
    \[\leadsto \frac{\left(x - -1\right) - \color{blue}{1 \cdot 1}}{\sqrt{x - -1} + 1} \]
  4. metadata-evalN/A
    \[\leadsto \frac{\left(x - -1\right) - \color{blue}{1}}{\sqrt{x - -1} + 1} \]
  5. associate--l-N/A
    \[\leadsto \frac{\color{blue}{x - \left(-1 + 1\right)}}{\sqrt{x - -1} + 1} \]
  6. metadata-evalN/A
    \[\leadsto \frac{x - \color{blue}{0}}{\sqrt{x - -1} + 1} \]
  7. --rgt-identity99.3%
    \[\leadsto \frac{\color{blue}{x}}{\sqrt{x - -1} + 1} \]
  8. lift-+.f64N/A
    \[\leadsto \frac{x}{\color{blue}{\sqrt{x - -1} + 1}} \]
  9. add-flipN/A
    \[\leadsto \frac{x}{\color{blue}{\sqrt{x - -1} - \left(\mathsf{neg}\left(1\right)\right)}} \]
  10. metadata-evalN/A
    \[\leadsto \frac{x}{\sqrt{x - -1} - \color{blue}{-1}} \]
  11. lower--.f6499.3%
    \[\leadsto \frac{x}{\color{blue}{\sqrt{x - -1} - -1}} \]
5. Applied rewrites99.3%
  \[\leadsto \color{blue}{\frac{x}{\sqrt{x - -1} - -1}} \]
6. Taylor expanded in x around 0
  \[\leadsto \frac{x}{\color{blue}{2 + \frac{1}{2} \cdot x}} \]
7. Step-by-step derivation
  1. lower-+.f64N/A
    \[\leadsto \frac{x}{2 + \color{blue}{\frac{1}{2} \cdot x}} \]
  2. lower-*.f6445.6%
    \[\leadsto \frac{x}{2 + 0.5 \cdot \color{blue}{x}} \]
8. Applied rewrites45.6%
  \[\leadsto \frac{x}{\color{blue}{2 + 0.5 \cdot x}} \]
if 9.7999999999999993e-6 < x
1. Initial program 85.1%
  \[\sqrt{1 + x} - 1 \]
Recombined 2 regimes into one program.
Add Preprocessing

Alternative 6: 96.1% accurate, 0.6× speedup?

\[\begin{array}{l} \mathbf{if}\;x \leq 9.8 \cdot 10^{-6}:\\ \;\;\;\;x \cdot \left(0.5 + -0.125 \cdot x\right)\\ \mathbf{else}:\\ \;\;\;\;\sqrt{1 + x} - 1\\ \end{array} \]

(FPCore (x)
  :precision binary64
  (if (<= x 9.8e-6) (* x (+ 0.5 (* -0.125 x))) (- (sqrt (+ 1.0 x)) 1.0)))

double code(double x) {
	double tmp;
	if (x <= 9.8e-6) {
		tmp = x * (0.5 + (-0.125 * x));
	} else {
		tmp = sqrt((1.0 + x)) - 1.0;
	}
	return tmp;
}

real(8) function code(x)
    real(8), intent (in) :: x
    real(8) :: tmp
    if (x <= 9.8d-6) then
        tmp = x * (0.5d0 + ((-0.125d0) * x))
    else
        tmp = sqrt((1.0d0 + x)) - 1.0d0
    end if
    code = tmp
end function

public static double code(double x) {
	double tmp;
	if (x <= 9.8e-6) {
		tmp = x * (0.5 + (-0.125 * x));
	} else {
		tmp = Math.sqrt((1.0 + x)) - 1.0;
	}
	return tmp;
}

def code(x):
	tmp = 0
	if x <= 9.8e-6:
		tmp = x * (0.5 + (-0.125 * x))
	else:
		tmp = math.sqrt((1.0 + x)) - 1.0
	return tmp

function code(x)
	tmp = 0.0
	if (x <= 9.8e-6)
		tmp = Float64(x * Float64(0.5 + Float64(-0.125 * x)));
	else
		tmp = Float64(sqrt(Float64(1.0 + x)) - 1.0);
	end
	return tmp
end

function tmp_2 = code(x)
	tmp = 0.0;
	if (x <= 9.8e-6)
		tmp = x * (0.5 + (-0.125 * x));
	else
		tmp = sqrt((1.0 + x)) - 1.0;
	end
	tmp_2 = tmp;
end

code[x_] := If[LessEqual[x, 9.8e-6], N[(x * N[(0.5 + N[(-0.125 * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[(1.0 + x), $MachinePrecision]], $MachinePrecision] - 1.0), $MachinePrecision]]

\begin{array}{l}
\mathbf{if}\;x \leq 9.8 \cdot 10^{-6}:\\
\;\;\;\;x \cdot \left(0.5 + -0.125 \cdot x\right)\\

\mathbf{else}:\\
\;\;\;\;\sqrt{1 + x} - 1\\


\end{array}

Derivation

Split input into 2 regimes
if x < 9.7999999999999993e-6
1. Initial program 85.1%
  \[\sqrt{1 + x} - 1 \]
2. Taylor expanded in x around 0
  \[\leadsto \color{blue}{x \cdot \left(\frac{1}{2} + \frac{-1}{8} \cdot x\right)} \]
3. Step-by-step derivation
  1. lower-*.f64N/A
    \[\leadsto x \cdot \color{blue}{\left(\frac{1}{2} + \frac{-1}{8} \cdot x\right)} \]
  2. lower-+.f64N/A
    \[\leadsto x \cdot \left(\frac{1}{2} + \color{blue}{\frac{-1}{8} \cdot x}\right) \]
  3. lower-*.f6439.0%
    \[\leadsto x \cdot \left(0.5 + -0.125 \cdot \color{blue}{x}\right) \]
4. Applied rewrites39.0%
  \[\leadsto \color{blue}{x \cdot \left(0.5 + -0.125 \cdot x\right)} \]
if 9.7999999999999993e-6 < x
1. Initial program 85.1%
  \[\sqrt{1 + x} - 1 \]
Recombined 2 regimes into one program.
Add Preprocessing

Alternative 7: 88.8% accurate, 0.7× speedup?

\[\begin{array}{l} \mathbf{if}\;x \leq 1.32 \cdot 10^{-8}:\\ \;\;\;\;0.5 \cdot x\\ \mathbf{else}:\\ \;\;\;\;\sqrt{1 + x} - 1\\ \end{array} \]

(FPCore (x)
  :precision binary64
  (if (<= x 1.32e-8) (* 0.5 x) (- (sqrt (+ 1.0 x)) 1.0)))

double code(double x) {
	double tmp;
	if (x <= 1.32e-8) {
		tmp = 0.5 * x;
	} else {
		tmp = sqrt((1.0 + x)) - 1.0;
	}
	return tmp;
}

real(8) function code(x)
    real(8), intent (in) :: x
    real(8) :: tmp
    if (x <= 1.32d-8) then
        tmp = 0.5d0 * x
    else
        tmp = sqrt((1.0d0 + x)) - 1.0d0
    end if
    code = tmp
end function

public static double code(double x) {
	double tmp;
	if (x <= 1.32e-8) {
		tmp = 0.5 * x;
	} else {
		tmp = Math.sqrt((1.0 + x)) - 1.0;
	}
	return tmp;
}

def code(x):
	tmp = 0
	if x <= 1.32e-8:
		tmp = 0.5 * x
	else:
		tmp = math.sqrt((1.0 + x)) - 1.0
	return tmp

function code(x)
	tmp = 0.0
	if (x <= 1.32e-8)
		tmp = Float64(0.5 * x);
	else
		tmp = Float64(sqrt(Float64(1.0 + x)) - 1.0);
	end
	return tmp
end

function tmp_2 = code(x)
	tmp = 0.0;
	if (x <= 1.32e-8)
		tmp = 0.5 * x;
	else
		tmp = sqrt((1.0 + x)) - 1.0;
	end
	tmp_2 = tmp;
end

code[x_] := If[LessEqual[x, 1.32e-8], N[(0.5 * x), $MachinePrecision], N[(N[Sqrt[N[(1.0 + x), $MachinePrecision]], $MachinePrecision] - 1.0), $MachinePrecision]]

\begin{array}{l}
\mathbf{if}\;x \leq 1.32 \cdot 10^{-8}:\\
\;\;\;\;0.5 \cdot x\\

\mathbf{else}:\\
\;\;\;\;\sqrt{1 + x} - 1\\


\end{array}

Derivation

Split input into 2 regimes
if x < 1.3200000000000001e-8
1. Initial program 85.1%
  \[\sqrt{1 + x} - 1 \]
2. Taylor expanded in x around 0
  \[\leadsto \color{blue}{\frac{1}{2} \cdot x} \]
3. Step-by-step derivation
  1. lower-*.f6433.1%
    \[\leadsto 0.5 \cdot \color{blue}{x} \]
4. Applied rewrites33.1%
  \[\leadsto \color{blue}{0.5 \cdot x} \]
if 1.3200000000000001e-8 < x
1. Initial program 85.1%
  \[\sqrt{1 + x} - 1 \]
Recombined 2 regimes into one program.
Add Preprocessing

Alternative 8: 33.1% accurate, 2.0× speedup?

\[0.5 \cdot x \]

(FPCore (x)
  :precision binary64
  (* 0.5 x))

double code(double x) {
	return 0.5 * x;
}

real(8) function code(x)
    real(8), intent (in) :: x
    code = 0.5d0 * x
end function

public static double code(double x) {
	return 0.5 * x;
}

def code(x):
	return 0.5 * x

function code(x)
	return Float64(0.5 * x)
end

function tmp = code(x)
	tmp = 0.5 * x;
end

code[x_] := N[(0.5 * x), $MachinePrecision]

0.5 \cdot x

Derivation

Initial program 85.1%
\[\sqrt{1 + x} - 1 \]
Taylor expanded in x around 0
\[\leadsto \color{blue}{\frac{1}{2} \cdot x} \]
Step-by-step derivation
1. lower-*.f6433.1%
  \[\leadsto 0.5 \cdot \color{blue}{x} \]
Applied rewrites33.1%
\[\leadsto \color{blue}{0.5 \cdot x} \]
Add Preprocessing

sqrt(1+x)-1

Specification

Local Percentage Accuracy vs ?

Accuracy vs Speed?

Initial Program: 85.1% accurate, 1.0× speedup?

Alternative 1: 99.3% accurate, 0.5× speedup?

Alternative 2: 99.3% accurate, 0.5× speedup?

Alternative 3: 99.2% accurate, 0.7× speedup?

Alternative 4: 96.2% accurate, 0.5× speedup?

`if x < 9.7999999999999993e-6`

`if 9.7999999999999993e-6 < x`

Alternative 5: 96.2% accurate, 0.6× speedup?

`if x < 9.7999999999999993e-6`

`if 9.7999999999999993e-6 < x`

Alternative 6: 96.1% accurate, 0.6× speedup?

`if x < 9.7999999999999993e-6`

`if 9.7999999999999993e-6 < x`

Alternative 7: 88.8% accurate, 0.7× speedup?

`if x < 1.3200000000000001e-8`

`if 1.3200000000000001e-8 < x`

Alternative 8: 33.1% accurate, 2.0× speedup?

Reproduce

Specification

Local Percentage Accuracy vs ?

Accuracy vs Speed?

Initial Program: 85.1% accurate, 1.0× speedupMathFPCoreCFortranJavaPythonJuliaMATLABWolframTeX?

Alternative 1: 99.3% accurate, 0.5× speedupMathFPCoreCJuliaWolframTeX?

Alternative 2: 99.3% accurate, 0.5× speedupMathFPCoreCJuliaWolframTeX?

Alternative 3: 99.2% accurate, 0.7× speedupMathFPCoreCFortranJavaPythonJuliaMATLABWolframTeX?

Alternative 4: 96.2% accurate, 0.5× speedupMathFPCoreCFortranJavaPythonJuliaMATLABWolframTeX?

if x < 9.7999999999999993e-6

if 9.7999999999999993e-6 < x

Alternative 5: 96.2% accurate, 0.6× speedupMathFPCoreCFortranJavaPythonJuliaMATLABWolframTeX?

if x < 9.7999999999999993e-6

if 9.7999999999999993e-6 < x

Alternative 6: 96.1% accurate, 0.6× speedupMathFPCoreCFortranJavaPythonJuliaMATLABWolframTeX?

if x < 9.7999999999999993e-6

if 9.7999999999999993e-6 < x

Alternative 7: 88.8% accurate, 0.7× speedupMathFPCoreCFortranJavaPythonJuliaMATLABWolframTeX?

if x < 1.3200000000000001e-8

if 1.3200000000000001e-8 < x

Alternative 8: 33.1% accurate, 2.0× speedupMathFPCoreCFortranJavaPythonJuliaMATLABWolframTeX?

Reproduce

Initial Program: 85.1% accurate, 1.0× speedup?

Alternative 1: 99.3% accurate, 0.5× speedup?

Alternative 2: 99.3% accurate, 0.5× speedup?

Alternative 3: 99.2% accurate, 0.7× speedup?

Alternative 4: 96.2% accurate, 0.5× speedup?

`if x < 9.7999999999999993e-6`

`if 9.7999999999999993e-6 < x`

Alternative 5: 96.2% accurate, 0.6× speedup?

`if x < 9.7999999999999993e-6`

`if 9.7999999999999993e-6 < x`

Alternative 6: 96.1% accurate, 0.6× speedup?

`if x < 9.7999999999999993e-6`

`if 9.7999999999999993e-6 < x`

Alternative 7: 88.8% accurate, 0.7× speedup?

`if x < 1.3200000000000001e-8`

`if 1.3200000000000001e-8 < x`

Alternative 8: 33.1% accurate, 2.0× speedup?