Main:bigenough3 from C

Percentage Accurate: 52.8% → 99.7%

Time: 2.7s

Alternatives: 6

Speedup: 1.0×

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

ReFlow

f(x):
	x in [-inf, +inf]
code: THEORY
BEGIN
f(x: real): real =
	(sqrt((x + (1)))) - (sqrt(x))
END code

Initial Program: 52.8% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

ReFlow

f(x):
	x in [-inf, +inf]
code: THEORY
BEGIN
f(x: real): real =
	(sqrt((x + (1)))) - (sqrt(x))
END code

Alternative 1: 99.7% accurate, 0.7× speedup

Math

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

FPCore

(FPCore (x)
  :precision binary64
  :pre TRUE
  (/ 1.0 (+ (sqrt x) (sqrt (+ 1.0 x)))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

ReFlow

f(x):
	x in [-inf, +inf]
code: THEORY
BEGIN
f(x: real): real =
	(1) / ((sqrt(x)) + (sqrt(((1) + x))))
END code

Derivation

1. Initial program 52.8%

   \[\sqrt{x + 1} - \sqrt{x} \]
2. Step-by-step derivation

3. Applied rewrites 99.7%

   \[\leadsto \frac{1}{\sqrt{x} + \sqrt{1 + x}} \]
4. Add Preprocessing

Alternative 2: 99.4% accurate, 0.7× speedup

Math

\[\begin{array}{l} \mathbf{if}\;x \leq 1907310.3737776245:\\ \;\;\;\;\sqrt{x + 1} - \sqrt{x}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \sqrt{\frac{1}{x}}\\ \end{array} \]

FPCore

(FPCore (x)
  :precision binary64
  :pre TRUE
  (if (<= x 1907310.3737776245)
  (- (sqrt (+ x 1.0)) (sqrt x))
  (* 0.5 (sqrt (/ 1.0 x)))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

ReFlow

f(x):
	x in [-inf, +inf]
code: THEORY
BEGIN
f(x: real): real =
	LET tmp = IF (x <= (190731037377762445248663425445556640625e-32)) THEN ((sqrt((x + (1)))) - (sqrt(x))) ELSE ((5e-1) * (sqrt(((1) / x)))) ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if x < 1907310.3737776245

   1. Initial program 52.8%

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

   if 1907310.3737776245 < x

   1. Initial program 52.8%

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

   2. Taylor expanded in x around inf

      \[\leadsto \frac{\frac{1}{2}}{x \cdot \sqrt{\frac{1}{x}}} \]
   3. Step-by-step derivation

   4. Applied rewrites 52.8%

      \[\leadsto \frac{0.5}{x \cdot \sqrt{\frac{1}{x}}} \]
   5. Step-by-step derivation

   6. Applied rewrites 52.9%

      \[\leadsto 0.5 \cdot \frac{\sqrt{x}}{x} \]

   7. Taylor expanded in x around inf

      \[\leadsto 0.5 \cdot \sqrt{\frac{1}{x}} \]
   8. Step-by-step derivation

   9. Applied rewrites 53.0%

      \[\leadsto 0.5 \cdot \sqrt{\frac{1}{x}} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 3: 97.7% accurate, 0.7× speedup

Math

\[\begin{array}{l} \mathbf{if}\;x \leq 0.19634788085319213:\\ \;\;\;\;1 - \sqrt{x}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \sqrt{\frac{1}{x}}\\ \end{array} \]

FPCore

(FPCore (x)
  :precision binary64
  :pre TRUE
  (if (<= x 0.19634788085319213)
  (- 1.0 (sqrt x))
  (* 0.5 (sqrt (/ 1.0 x)))))

C

double code(double x) {
	double tmp;
	if (x <= 0.19634788085319213) {
		tmp = 1.0 - sqrt(x);
	} else {
		tmp = 0.5 * sqrt((1.0 / x));
	}
	return tmp;
}

Fortran

real(8) function code(x)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8) :: tmp
    if (x <= 0.19634788085319213d0) then
        tmp = 1.0d0 - sqrt(x)
    else
        tmp = 0.5d0 * sqrt((1.0d0 / x))
    end if
    code = tmp
end function

Java

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

Python

def code(x):
	tmp = 0
	if x <= 0.19634788085319213:
		tmp = 1.0 - math.sqrt(x)
	else:
		tmp = 0.5 * math.sqrt((1.0 / x))
	return tmp

Julia

function code(x)
	tmp = 0.0
	if (x <= 0.19634788085319213)
		tmp = Float64(1.0 - sqrt(x));
	else
		tmp = Float64(0.5 * sqrt(Float64(1.0 / x)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x)
	tmp = 0.0;
	if (x <= 0.19634788085319213)
		tmp = 1.0 - sqrt(x);
	else
		tmp = 0.5 * sqrt((1.0 / x));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_] := If[LessEqual[x, 0.19634788085319213], N[(1.0 - N[Sqrt[x], $MachinePrecision]), $MachinePrecision], N[(0.5 * N[Sqrt[N[(1.0 / x), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]

ReFlow

f(x):
	x in [-inf, +inf]
code: THEORY
BEGIN
f(x: real): real =
	LET tmp = IF (x <= (1963478808531921304680878392900922335684299468994140625e-55)) THEN ((1) - (sqrt(x))) ELSE ((5e-1) * (sqrt(((1) / x)))) ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if x < 0.19634788085319213

   1. Initial program 52.8%

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

   2. Taylor expanded in x around 0

      \[\leadsto 1 - \sqrt{x} \]
   3. Step-by-step derivation

   4. Applied rewrites 49.0%

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

   if 0.19634788085319213 < x

   1. Initial program 52.8%

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

   2. Taylor expanded in x around inf

      \[\leadsto \frac{\frac{1}{2}}{x \cdot \sqrt{\frac{1}{x}}} \]
   3. Step-by-step derivation

   4. Applied rewrites 52.8%

      \[\leadsto \frac{0.5}{x \cdot \sqrt{\frac{1}{x}}} \]
   5. Step-by-step derivation

   6. Applied rewrites 52.9%

      \[\leadsto 0.5 \cdot \frac{\sqrt{x}}{x} \]

   7. Taylor expanded in x around inf

      \[\leadsto 0.5 \cdot \sqrt{\frac{1}{x}} \]
   8. Step-by-step derivation

   9. Applied rewrites 53.0%

      \[\leadsto 0.5 \cdot \sqrt{\frac{1}{x}} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 4: 97.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \mathbf{if}\;x \leq 0.19634788085319213:\\ \;\;\;\;1 - \sqrt{x}\\ \mathbf{else}:\\ \;\;\;\;\frac{0.5}{\sqrt{x}}\\ \end{array} \]

FPCore

(FPCore (x)
  :precision binary64
  :pre TRUE
  (if (<= x 0.19634788085319213) (- 1.0 (sqrt x)) (/ 0.5 (sqrt x))))

C

double code(double x) {
	double tmp;
	if (x <= 0.19634788085319213) {
		tmp = 1.0 - sqrt(x);
	} else {
		tmp = 0.5 / sqrt(x);
	}
	return tmp;
}

Fortran

real(8) function code(x)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8) :: tmp
    if (x <= 0.19634788085319213d0) then
        tmp = 1.0d0 - sqrt(x)
    else
        tmp = 0.5d0 / sqrt(x)
    end if
    code = tmp
end function

Java

public static double code(double x) {
	double tmp;
	if (x <= 0.19634788085319213) {
		tmp = 1.0 - Math.sqrt(x);
	} else {
		tmp = 0.5 / Math.sqrt(x);
	}
	return tmp;
}

Python

def code(x):
	tmp = 0
	if x <= 0.19634788085319213:
		tmp = 1.0 - math.sqrt(x)
	else:
		tmp = 0.5 / math.sqrt(x)
	return tmp

Julia

function code(x)
	tmp = 0.0
	if (x <= 0.19634788085319213)
		tmp = Float64(1.0 - sqrt(x));
	else
		tmp = Float64(0.5 / sqrt(x));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x)
	tmp = 0.0;
	if (x <= 0.19634788085319213)
		tmp = 1.0 - sqrt(x);
	else
		tmp = 0.5 / sqrt(x);
	end
	tmp_2 = tmp;
end

Wolfram

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

ReFlow

f(x):
	x in [-inf, +inf]
code: THEORY
BEGIN
f(x: real): real =
	LET tmp = IF (x <= (1963478808531921304680878392900922335684299468994140625e-55)) THEN ((1) - (sqrt(x))) ELSE ((5e-1) / (sqrt(x))) ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if x < 0.19634788085319213

   1. Initial program 52.8%

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

   2. Taylor expanded in x around 0

      \[\leadsto 1 - \sqrt{x} \]
   3. Step-by-step derivation

   4. Applied rewrites 49.0%

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

   if 0.19634788085319213 < x

   1. Initial program 52.8%

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

   2. Taylor expanded in x around inf

      \[\leadsto \frac{\frac{1}{2}}{x \cdot \sqrt{\frac{1}{x}}} \]
   3. Step-by-step derivation

   4. Applied rewrites 52.8%

      \[\leadsto \frac{0.5}{x \cdot \sqrt{\frac{1}{x}}} \]

   6. Applied rewrites 52.9%

      \[\leadsto \frac{0.5}{\sqrt{x}} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 5: 50.6% accurate, 1.8× speedup

Math

\[1 - \sqrt{0} \]

FPCore

(FPCore (x)
  :precision binary64
  :pre TRUE
  (- 1.0 (sqrt 0.0)))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

ReFlow

f(x):
	x in [-inf, +inf]
code: THEORY
BEGIN
f(x: real): real =
	(1) - (sqrt((0)))
END code

Derivation

1. Initial program 52.8%

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

2. Taylor expanded in x around 0

   \[\leadsto 1 - \sqrt{x} \]
3. Step-by-step derivation

4. Applied rewrites 49.0%

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

5. Taylor expanded in undef-var around zero

   \[\leadsto 1 - \sqrt{0} \]
6. Step-by-step derivation

7. Applied rewrites 50.6%

   \[\leadsto 1 - \sqrt{0} \]
8. Add Preprocessing

Alternative 6: 49.0% accurate, 1.8× speedup

Math

\[1 - \sqrt{x} \]

FPCore

(FPCore (x)
  :precision binary64
  :pre TRUE
  (- 1.0 (sqrt x)))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

ReFlow

f(x):
	x in [-inf, +inf]
code: THEORY
BEGIN
f(x: real): real =
	(1) - (sqrt(x))
END code

Derivation

1. Initial program 52.8%

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

2. Taylor expanded in x around 0

   \[\leadsto 1 - \sqrt{x} \]
3. Step-by-step derivation

4. Applied rewrites 49.0%

   \[\leadsto 1 - \sqrt{x} \]
5. Add Preprocessing

Reproduce

herbie shell --seed 2026092 
(FPCore (x)
  :name "Main:bigenough3 from C"
  :precision binary64
  (- (sqrt (+ x 1.0)) (sqrt x)))