forward-half-diff

Percentage Accurate: 100.0% → 100.0%

Time: 35.4s

Alternatives: 3

Speedup: 1.1×

Specification

Math

\[0.5 \cdot \left(W - \frac{1}{W}\right) \]

FPCore

(FPCore (W)
  :precision binary64
  :pre TRUE
  (* 0.5 (- W (/ 1.0 W))))

C

double code(double W) {
	return 0.5 * (W - (1.0 / W));
}

Fortran

real(8) function code(w)
use fmin_fmax_functions
    real(8), intent (in) :: w
    code = 0.5d0 * (w - (1.0d0 / w))
end function

Java

public static double code(double W) {
	return 0.5 * (W - (1.0 / W));
}

Python

def code(W):
	return 0.5 * (W - (1.0 / W))

Julia

function code(W)
	return Float64(0.5 * Float64(W - Float64(1.0 / W)))
end

MATLAB

function tmp = code(W)
	tmp = 0.5 * (W - (1.0 / W));
end

Wolfram

code[W_] := N[(0.5 * N[(W - N[(1.0 / W), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

ReFlow

f(W):
	W in [-inf, +inf]
code: THEORY
BEGIN
f(W: real): real =
	(5e-1) * (W - ((1) / W))
END code

Initial Program: 100.0% accurate, 1.0× speedup

Math

\[0.5 \cdot \left(W - \frac{1}{W}\right) \]

FPCore

(FPCore (W)
  :precision binary64
  :pre TRUE
  (* 0.5 (- W (/ 1.0 W))))

C

double code(double W) {
	return 0.5 * (W - (1.0 / W));
}

Fortran

real(8) function code(w)
use fmin_fmax_functions
    real(8), intent (in) :: w
    code = 0.5d0 * (w - (1.0d0 / w))
end function

Java

public static double code(double W) {
	return 0.5 * (W - (1.0 / W));
}

Python

def code(W):
	return 0.5 * (W - (1.0 / W))

Julia

function code(W)
	return Float64(0.5 * Float64(W - Float64(1.0 / W)))
end

MATLAB

function tmp = code(W)
	tmp = 0.5 * (W - (1.0 / W));
end

Wolfram

code[W_] := N[(0.5 * N[(W - N[(1.0 / W), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

ReFlow

f(W):
	W in [-inf, +inf]
code: THEORY
BEGIN
f(W: real): real =
	(5e-1) * (W - ((1) / W))
END code

Alternative 1: 100.0% accurate, 1.1× speedup

Math

\[\mathsf{fma}\left(W, 0.5, \frac{-0.5}{W}\right) \]

FPCore

(FPCore (W)
  :precision binary64
  :pre TRUE
  (fma W 0.5 (/ -0.5 W)))

C

double code(double W) {
	return fma(W, 0.5, (-0.5 / W));
}

Julia

function code(W)
	return fma(W, 0.5, Float64(-0.5 / W))
end

Wolfram

code[W_] := N[(W * 0.5 + N[(-0.5 / W), $MachinePrecision]), $MachinePrecision]

ReFlow

f(W):
	W in [-inf, +inf]
code: THEORY
BEGIN
f(W: real): real =
	(W * (5e-1)) + ((-5e-1) / W)
END code

Derivation

1. Initial program 100.0%

   \[0.5 \cdot \left(W - \frac{1}{W}\right) \]

3. Applied rewrites 100.0%

   \[\leadsto \mathsf{fma}\left(W, 0.5, \frac{-0.5}{W}\right) \]
4. Add Preprocessing

Alternative 2: 97.9% accurate, 0.4× speedup

Math

\[\mathsf{copysign}\left(1, W\right) \cdot \begin{array}{l} \mathbf{if}\;\left|W\right| - \frac{1}{\left|W\right|} \leq -10000000000:\\ \;\;\;\;\frac{-0.5}{\left|W\right|}\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot \left|W\right|\\ \end{array} \]

FPCore

(FPCore (W)
  :precision binary64
  :pre TRUE
  (*
 (copysign 1.0 W)
 (if (<= (- (fabs W) (/ 1.0 (fabs W))) -10000000000.0)
   (/ -0.5 (fabs W))
   (* 0.5 (fabs W)))))

C

double code(double W) {
	double tmp;
	if ((fabs(W) - (1.0 / fabs(W))) <= -10000000000.0) {
		tmp = -0.5 / fabs(W);
	} else {
		tmp = 0.5 * fabs(W);
	}
	return copysign(1.0, W) * tmp;
}

Java

public static double code(double W) {
	double tmp;
	if ((Math.abs(W) - (1.0 / Math.abs(W))) <= -10000000000.0) {
		tmp = -0.5 / Math.abs(W);
	} else {
		tmp = 0.5 * Math.abs(W);
	}
	return Math.copySign(1.0, W) * tmp;
}

Python

def code(W):
	tmp = 0
	if (math.fabs(W) - (1.0 / math.fabs(W))) <= -10000000000.0:
		tmp = -0.5 / math.fabs(W)
	else:
		tmp = 0.5 * math.fabs(W)
	return math.copysign(1.0, W) * tmp

Julia

function code(W)
	tmp = 0.0
	if (Float64(abs(W) - Float64(1.0 / abs(W))) <= -10000000000.0)
		tmp = Float64(-0.5 / abs(W));
	else
		tmp = Float64(0.5 * abs(W));
	end
	return Float64(copysign(1.0, W) * tmp)
end

MATLAB

function tmp_2 = code(W)
	tmp = 0.0;
	if ((abs(W) - (1.0 / abs(W))) <= -10000000000.0)
		tmp = -0.5 / abs(W);
	else
		tmp = 0.5 * abs(W);
	end
	tmp_2 = (sign(W) * abs(1.0)) * tmp;
end

Wolfram

code[W_] := N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[W]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[(N[Abs[W], $MachinePrecision] - N[(1.0 / N[Abs[W], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], -10000000000.0], N[(-0.5 / N[Abs[W], $MachinePrecision]), $MachinePrecision], N[(0.5 * N[Abs[W], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]

Derivation

1. Split input into 2 regimes

2. if (-.f64 W (/.f64 #s(literal 1 binary64) W)) < -1e10

   1. Initial program 100.0%

      \[0.5 \cdot \left(W - \frac{1}{W}\right) \]

   2. Taylor expanded in W around 0

      \[\leadsto \frac{\frac{-1}{2}}{W} \]

   4. Applied rewrites 49.8%

      \[\leadsto \frac{-0.5}{W} \]

   if -1e10 < (-.f64 W (/.f64 #s(literal 1 binary64) W))

   1. Initial program 100.0%

      \[0.5 \cdot \left(W - \frac{1}{W}\right) \]

   2. Taylor expanded in W around inf

      \[\leadsto \frac{1}{2} \cdot W \]

   4. Applied rewrites 50.8%

      \[\leadsto 0.5 \cdot W \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 3: 50.8% accurate, 2.6× speedup

Math

\[0.5 \cdot W \]

FPCore

(FPCore (W)
  :precision binary64
  :pre TRUE
  (* 0.5 W))

C

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

Fortran

real(8) function code(w)
use fmin_fmax_functions
    real(8), intent (in) :: w
    code = 0.5d0 * w
end function

Java

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

Python

def code(W):
	return 0.5 * W

Julia

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

MATLAB

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

Wolfram

code[W_] := N[(0.5 * W), $MachinePrecision]

ReFlow

f(W):
	W in [-inf, +inf]
code: THEORY
BEGIN
f(W: real): real =
	(5e-1) * W
END code

Derivation

1. Initial program 100.0%

   \[0.5 \cdot \left(W - \frac{1}{W}\right) \]

2. Taylor expanded in W around inf

   \[\leadsto \frac{1}{2} \cdot W \]

4. Applied rewrites 50.8%

   \[\leadsto 0.5 \cdot W \]
5. Add Preprocessing

Reproduce

herbie shell --seed 2026050 +o generate:egglog
(FPCore (W)
  :name "forward-half-diff"
  :precision binary64
  (* 0.5 (- W (/ 1.0 W))))