Data.Histogram.Bin.BinF:$cfromIndex from histogram-fill-0.8.4.1

Percentage Accurate: 100.0% → 100.0%

Time: 3.2s

Alternatives: 7

Speedup: 0.1×

Specification

Math

\[\begin{array}{l} \\ \left(\frac{x}{2} + y \cdot x\right) + z \end{array} \]

FPCore

(FPCore (x y z) :precision binary64 (+ (+ (/ x 2.0) (* y x)) z))

C

double code(double x, double y, double z) {
	return ((x / 2.0) + (y * x)) + z;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    code = ((x / 2.0d0) + (y * x)) + z
end function

Java

public static double code(double x, double y, double z) {
	return ((x / 2.0) + (y * x)) + z;
}

Python

def code(x, y, z):
	return ((x / 2.0) + (y * x)) + z

Julia

function code(x, y, z)
	return Float64(Float64(Float64(x / 2.0) + Float64(y * x)) + z)
end

MATLAB

function tmp = code(x, y, z)
	tmp = ((x / 2.0) + (y * x)) + z;
end

Wolfram

code[x_, y_, z_] := N[(N[(N[(x / 2.0), $MachinePrecision] + N[(y * x), $MachinePrecision]), $MachinePrecision] + z), $MachinePrecision]

Initial Program: 100.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \left(\frac{x}{2} + y \cdot x\right) + z \end{array} \]

FPCore

(FPCore (x y z) :precision binary64 (+ (+ (/ x 2.0) (* y x)) z))

C

double code(double x, double y, double z) {
	return ((x / 2.0) + (y * x)) + z;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    code = ((x / 2.0d0) + (y * x)) + z
end function

Java

public static double code(double x, double y, double z) {
	return ((x / 2.0) + (y * x)) + z;
}

Python

def code(x, y, z):
	return ((x / 2.0) + (y * x)) + z

Julia

function code(x, y, z)
	return Float64(Float64(Float64(x / 2.0) + Float64(y * x)) + z)
end

MATLAB

function tmp = code(x, y, z)
	tmp = ((x / 2.0) + (y * x)) + z;
end

Wolfram

code[x_, y_, z_] := N[(N[(N[(x / 2.0), $MachinePrecision] + N[(y * x), $MachinePrecision]), $MachinePrecision] + z), $MachinePrecision]

Alternative 1: 100.0% accurate, 0.1× speedup

Math

\[\begin{array}{l} \\ \mathsf{fma}\left(0.5 + y, x, z\right) \end{array} \]

FPCore

(FPCore (x y z) :precision binary64 (fma (+ 0.5 y) x z))

C

double code(double x, double y, double z) {
	return fma((0.5 + y), x, z);
}

Julia

function code(x, y, z)
	return fma(Float64(0.5 + y), x, z)
end

Wolfram

code[x_, y_, z_] := N[(N[(0.5 + y), $MachinePrecision] * x + z), $MachinePrecision]

Derivation

1. Initial program 100.0%

   \[\left(\frac{x}{2} + y \cdot x\right) + z \]
2. Step-by-step derivation

   1. associate-+l+ 100.0%

      \[\leadsto \color{blue}{\frac{x}{2} + \left(y \cdot x + z\right)} \]

   2. *-commutative 100.0%

      \[\leadsto \frac{x}{2} + \left(\color{blue}{x \cdot y} + z\right) \]

3. Simplified 100.0%

   \[\leadsto \color{blue}{\frac{x}{2} + \left(x \cdot y + z\right)} \]

4. Taylor expanded in x around 0 100.0%

   \[\leadsto \color{blue}{z + \left(0.5 + y\right) \cdot x} \]
5. Step-by-step derivation

   1. +-commutative 100.0%

      \[\leadsto \color{blue}{\left(0.5 + y\right) \cdot x + z} \]

   2. fma-def 100.0%

      \[\leadsto \color{blue}{\mathsf{fma}\left(0.5 + y, x, z\right)} \]

6. Simplified 100.0%

   \[\leadsto \color{blue}{\mathsf{fma}\left(0.5 + y, x, z\right)} \]

7. Final simplification 100.0%

   \[\leadsto \mathsf{fma}\left(0.5 + y, x, z\right) \]

Alternative 2: 61.0% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -42000:\\ \;\;\;\;y \cdot x\\ \mathbf{elif}\;y \leq -4.8 \cdot 10^{-46}:\\ \;\;\;\;z\\ \mathbf{elif}\;y \leq -9 \cdot 10^{-156}:\\ \;\;\;\;0.5 \cdot x\\ \mathbf{elif}\;y \leq -3.3 \cdot 10^{-254}:\\ \;\;\;\;z\\ \mathbf{elif}\;y \leq 4.8 \cdot 10^{-293}:\\ \;\;\;\;0.5 \cdot x\\ \mathbf{elif}\;y \leq 1.8 \cdot 10^{-152}:\\ \;\;\;\;z\\ \mathbf{elif}\;y \leq 1.9 \cdot 10^{-42}:\\ \;\;\;\;0.5 \cdot x\\ \mathbf{elif}\;y \leq 130000000:\\ \;\;\;\;z\\ \mathbf{elif}\;y \leq 2.5 \cdot 10^{+22}:\\ \;\;\;\;y \cdot x\\ \mathbf{elif}\;y \leq 2.2 \cdot 10^{+54}:\\ \;\;\;\;z\\ \mathbf{else}:\\ \;\;\;\;y \cdot x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= y -42000.0)
   (* y x)
   (if (<= y -4.8e-46)
     z
     (if (<= y -9e-156)
       (* 0.5 x)
       (if (<= y -3.3e-254)
         z
         (if (<= y 4.8e-293)
           (* 0.5 x)
           (if (<= y 1.8e-152)
             z
             (if (<= y 1.9e-42)
               (* 0.5 x)
               (if (<= y 130000000.0)
                 z
                 (if (<= y 2.5e+22)
                   (* y x)
                   (if (<= y 2.2e+54) z (* y x))))))))))))

C

double code(double x, double y, double z) {
	double tmp;
	if (y <= -42000.0) {
		tmp = y * x;
	} else if (y <= -4.8e-46) {
		tmp = z;
	} else if (y <= -9e-156) {
		tmp = 0.5 * x;
	} else if (y <= -3.3e-254) {
		tmp = z;
	} else if (y <= 4.8e-293) {
		tmp = 0.5 * x;
	} else if (y <= 1.8e-152) {
		tmp = z;
	} else if (y <= 1.9e-42) {
		tmp = 0.5 * x;
	} else if (y <= 130000000.0) {
		tmp = z;
	} else if (y <= 2.5e+22) {
		tmp = y * x;
	} else if (y <= 2.2e+54) {
		tmp = z;
	} else {
		tmp = y * x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (y <= (-42000.0d0)) then
        tmp = y * x
    else if (y <= (-4.8d-46)) then
        tmp = z
    else if (y <= (-9d-156)) then
        tmp = 0.5d0 * x
    else if (y <= (-3.3d-254)) then
        tmp = z
    else if (y <= 4.8d-293) then
        tmp = 0.5d0 * x
    else if (y <= 1.8d-152) then
        tmp = z
    else if (y <= 1.9d-42) then
        tmp = 0.5d0 * x
    else if (y <= 130000000.0d0) then
        tmp = z
    else if (y <= 2.5d+22) then
        tmp = y * x
    else if (y <= 2.2d+54) then
        tmp = z
    else
        tmp = y * x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (y <= -42000.0) {
		tmp = y * x;
	} else if (y <= -4.8e-46) {
		tmp = z;
	} else if (y <= -9e-156) {
		tmp = 0.5 * x;
	} else if (y <= -3.3e-254) {
		tmp = z;
	} else if (y <= 4.8e-293) {
		tmp = 0.5 * x;
	} else if (y <= 1.8e-152) {
		tmp = z;
	} else if (y <= 1.9e-42) {
		tmp = 0.5 * x;
	} else if (y <= 130000000.0) {
		tmp = z;
	} else if (y <= 2.5e+22) {
		tmp = y * x;
	} else if (y <= 2.2e+54) {
		tmp = z;
	} else {
		tmp = y * x;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if y <= -42000.0:
		tmp = y * x
	elif y <= -4.8e-46:
		tmp = z
	elif y <= -9e-156:
		tmp = 0.5 * x
	elif y <= -3.3e-254:
		tmp = z
	elif y <= 4.8e-293:
		tmp = 0.5 * x
	elif y <= 1.8e-152:
		tmp = z
	elif y <= 1.9e-42:
		tmp = 0.5 * x
	elif y <= 130000000.0:
		tmp = z
	elif y <= 2.5e+22:
		tmp = y * x
	elif y <= 2.2e+54:
		tmp = z
	else:
		tmp = y * x
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (y <= -42000.0)
		tmp = Float64(y * x);
	elseif (y <= -4.8e-46)
		tmp = z;
	elseif (y <= -9e-156)
		tmp = Float64(0.5 * x);
	elseif (y <= -3.3e-254)
		tmp = z;
	elseif (y <= 4.8e-293)
		tmp = Float64(0.5 * x);
	elseif (y <= 1.8e-152)
		tmp = z;
	elseif (y <= 1.9e-42)
		tmp = Float64(0.5 * x);
	elseif (y <= 130000000.0)
		tmp = z;
	elseif (y <= 2.5e+22)
		tmp = Float64(y * x);
	elseif (y <= 2.2e+54)
		tmp = z;
	else
		tmp = Float64(y * x);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (y <= -42000.0)
		tmp = y * x;
	elseif (y <= -4.8e-46)
		tmp = z;
	elseif (y <= -9e-156)
		tmp = 0.5 * x;
	elseif (y <= -3.3e-254)
		tmp = z;
	elseif (y <= 4.8e-293)
		tmp = 0.5 * x;
	elseif (y <= 1.8e-152)
		tmp = z;
	elseif (y <= 1.9e-42)
		tmp = 0.5 * x;
	elseif (y <= 130000000.0)
		tmp = z;
	elseif (y <= 2.5e+22)
		tmp = y * x;
	elseif (y <= 2.2e+54)
		tmp = z;
	else
		tmp = y * x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[y, -42000.0], N[(y * x), $MachinePrecision], If[LessEqual[y, -4.8e-46], z, If[LessEqual[y, -9e-156], N[(0.5 * x), $MachinePrecision], If[LessEqual[y, -3.3e-254], z, If[LessEqual[y, 4.8e-293], N[(0.5 * x), $MachinePrecision], If[LessEqual[y, 1.8e-152], z, If[LessEqual[y, 1.9e-42], N[(0.5 * x), $MachinePrecision], If[LessEqual[y, 130000000.0], z, If[LessEqual[y, 2.5e+22], N[(y * x), $MachinePrecision], If[LessEqual[y, 2.2e+54], z, N[(y * x), $MachinePrecision]]]]]]]]]]]

Derivation

1. Split input into 3 regimes

2. if y < -42000 or 1.3e8 < y < 2.4999999999999998e22 or 2.1999999999999999e54 < y

   1. Initial program 100.0%

      \[\left(\frac{x}{2} + y \cdot x\right) + z \]
   2. Step-by-step derivation

      1. associate-+l+ 100.0%

         \[\leadsto \color{blue}{\frac{x}{2} + \left(y \cdot x + z\right)} \]

      2. *-commutative 100.0%

         \[\leadsto \frac{x}{2} + \left(\color{blue}{x \cdot y} + z\right) \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{x}{2} + \left(x \cdot y + z\right)} \]

   4. Taylor expanded in y around inf 73.4%

      \[\leadsto \color{blue}{y \cdot x} \]

   if -42000 < y < -4.80000000000000027e-46 or -8.99999999999999971e-156 < y < -3.30000000000000016e-254 or 4.7999999999999998e-293 < y < 1.8e-152 or 1.90000000000000009e-42 < y < 1.3e8 or 2.4999999999999998e22 < y < 2.1999999999999999e54

   1. Initial program 100.0%

      \[\left(\frac{x}{2} + y \cdot x\right) + z \]
   2. Step-by-step derivation

      1. associate-+l+ 100.0%

         \[\leadsto \color{blue}{\frac{x}{2} + \left(y \cdot x + z\right)} \]

      2. *-commutative 100.0%

         \[\leadsto \frac{x}{2} + \left(\color{blue}{x \cdot y} + z\right) \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{x}{2} + \left(x \cdot y + z\right)} \]

   4. Taylor expanded in x around 0 69.9%

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

   if -4.80000000000000027e-46 < y < -8.99999999999999971e-156 or -3.30000000000000016e-254 < y < 4.7999999999999998e-293 or 1.8e-152 < y < 1.90000000000000009e-42

   1. Initial program 100.0%

      \[\left(\frac{x}{2} + y \cdot x\right) + z \]
   2. Step-by-step derivation

      1. associate-+l+ 100.0%

         \[\leadsto \color{blue}{\frac{x}{2} + \left(y \cdot x + z\right)} \]

      2. *-commutative 100.0%

         \[\leadsto \frac{x}{2} + \left(\color{blue}{x \cdot y} + z\right) \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{x}{2} + \left(x \cdot y + z\right)} \]

   4. Taylor expanded in x around inf 77.2%

      \[\leadsto \color{blue}{\left(0.5 + y\right) \cdot x} \]

   5. Taylor expanded in y around 0 77.2%

      \[\leadsto \color{blue}{0.5 \cdot x} \]
3. Recombined 3 regimes into one program.

4. Final simplification 73.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -42000:\\ \;\;\;\;y \cdot x\\ \mathbf{elif}\;y \leq -4.8 \cdot 10^{-46}:\\ \;\;\;\;z\\ \mathbf{elif}\;y \leq -9 \cdot 10^{-156}:\\ \;\;\;\;0.5 \cdot x\\ \mathbf{elif}\;y \leq -3.3 \cdot 10^{-254}:\\ \;\;\;\;z\\ \mathbf{elif}\;y \leq 4.8 \cdot 10^{-293}:\\ \;\;\;\;0.5 \cdot x\\ \mathbf{elif}\;y \leq 1.8 \cdot 10^{-152}:\\ \;\;\;\;z\\ \mathbf{elif}\;y \leq 1.9 \cdot 10^{-42}:\\ \;\;\;\;0.5 \cdot x\\ \mathbf{elif}\;y \leq 130000000:\\ \;\;\;\;z\\ \mathbf{elif}\;y \leq 2.5 \cdot 10^{+22}:\\ \;\;\;\;y \cdot x\\ \mathbf{elif}\;y \leq 2.2 \cdot 10^{+54}:\\ \;\;\;\;z\\ \mathbf{else}:\\ \;\;\;\;y \cdot x\\ \end{array} \]

Alternative 3: 85.0% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(0.5 + y\right) \cdot x\\ \mathbf{if}\;y \leq -88:\\ \;\;\;\;t_0\\ \mathbf{elif}\;y \leq 5.2:\\ \;\;\;\;z + 0.5 \cdot x\\ \mathbf{elif}\;y \leq 1.3 \cdot 10^{+21}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;y \leq 4 \cdot 10^{+52}:\\ \;\;\;\;z\\ \mathbf{else}:\\ \;\;\;\;y \cdot x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (* (+ 0.5 y) x)))
   (if (<= y -88.0)
     t_0
     (if (<= y 5.2)
       (+ z (* 0.5 x))
       (if (<= y 1.3e+21) t_0 (if (<= y 4e+52) z (* y x)))))))

C

double code(double x, double y, double z) {
	double t_0 = (0.5 + y) * x;
	double tmp;
	if (y <= -88.0) {
		tmp = t_0;
	} else if (y <= 5.2) {
		tmp = z + (0.5 * x);
	} else if (y <= 1.3e+21) {
		tmp = t_0;
	} else if (y <= 4e+52) {
		tmp = z;
	} else {
		tmp = y * x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (0.5d0 + y) * x
    if (y <= (-88.0d0)) then
        tmp = t_0
    else if (y <= 5.2d0) then
        tmp = z + (0.5d0 * x)
    else if (y <= 1.3d+21) then
        tmp = t_0
    else if (y <= 4d+52) then
        tmp = z
    else
        tmp = y * x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = (0.5 + y) * x;
	double tmp;
	if (y <= -88.0) {
		tmp = t_0;
	} else if (y <= 5.2) {
		tmp = z + (0.5 * x);
	} else if (y <= 1.3e+21) {
		tmp = t_0;
	} else if (y <= 4e+52) {
		tmp = z;
	} else {
		tmp = y * x;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = (0.5 + y) * x
	tmp = 0
	if y <= -88.0:
		tmp = t_0
	elif y <= 5.2:
		tmp = z + (0.5 * x)
	elif y <= 1.3e+21:
		tmp = t_0
	elif y <= 4e+52:
		tmp = z
	else:
		tmp = y * x
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(Float64(0.5 + y) * x)
	tmp = 0.0
	if (y <= -88.0)
		tmp = t_0;
	elseif (y <= 5.2)
		tmp = Float64(z + Float64(0.5 * x));
	elseif (y <= 1.3e+21)
		tmp = t_0;
	elseif (y <= 4e+52)
		tmp = z;
	else
		tmp = Float64(y * x);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = (0.5 + y) * x;
	tmp = 0.0;
	if (y <= -88.0)
		tmp = t_0;
	elseif (y <= 5.2)
		tmp = z + (0.5 * x);
	elseif (y <= 1.3e+21)
		tmp = t_0;
	elseif (y <= 4e+52)
		tmp = z;
	else
		tmp = y * x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(N[(0.5 + y), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[y, -88.0], t$95$0, If[LessEqual[y, 5.2], N[(z + N[(0.5 * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.3e+21], t$95$0, If[LessEqual[y, 4e+52], z, N[(y * x), $MachinePrecision]]]]]]

Derivation

1. Split input into 4 regimes

2. if y < -88 or 5.20000000000000018 < y < 1.3e21

   1. Initial program 99.9%

      \[\left(\frac{x}{2} + y \cdot x\right) + z \]
   2. Step-by-step derivation

      1. associate-+l+ 99.9%

         \[\leadsto \color{blue}{\frac{x}{2} + \left(y \cdot x + z\right)} \]

      2. *-commutative 99.9%

         \[\leadsto \frac{x}{2} + \left(\color{blue}{x \cdot y} + z\right) \]

   3. Simplified 99.9%

      \[\leadsto \color{blue}{\frac{x}{2} + \left(x \cdot y + z\right)} \]

   4. Taylor expanded in x around inf 77.5%

      \[\leadsto \color{blue}{\left(0.5 + y\right) \cdot x} \]

   if -88 < y < 5.20000000000000018

   1. Initial program 100.0%

      \[\left(\frac{x}{2} + y \cdot x\right) + z \]
   2. Step-by-step derivation

      1. associate-+l+ 100.0%

         \[\leadsto \color{blue}{\frac{x}{2} + \left(y \cdot x + z\right)} \]

      2. *-commutative 100.0%

         \[\leadsto \frac{x}{2} + \left(\color{blue}{x \cdot y} + z\right) \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{x}{2} + \left(x \cdot y + z\right)} \]

   4. Taylor expanded in y around 0 99.7%

      \[\leadsto \color{blue}{0.5 \cdot x + z} \]

   if 1.3e21 < y < 4e52

   1. Initial program 100.0%

      \[\left(\frac{x}{2} + y \cdot x\right) + z \]
   2. Step-by-step derivation

      1. associate-+l+ 100.0%

         \[\leadsto \color{blue}{\frac{x}{2} + \left(y \cdot x + z\right)} \]

      2. *-commutative 100.0%

         \[\leadsto \frac{x}{2} + \left(\color{blue}{x \cdot y} + z\right) \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{x}{2} + \left(x \cdot y + z\right)} \]

   4. Taylor expanded in x around 0 100.0%

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

   if 4e52 < y

   1. Initial program 100.0%

      \[\left(\frac{x}{2} + y \cdot x\right) + z \]
   2. Step-by-step derivation

      1. associate-+l+ 100.0%

         \[\leadsto \color{blue}{\frac{x}{2} + \left(y \cdot x + z\right)} \]

      2. *-commutative 100.0%

         \[\leadsto \frac{x}{2} + \left(\color{blue}{x \cdot y} + z\right) \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{x}{2} + \left(x \cdot y + z\right)} \]

   4. Taylor expanded in y around inf 70.8%

      \[\leadsto \color{blue}{y \cdot x} \]
3. Recombined 4 regimes into one program.

4. Final simplification 88.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -88:\\ \;\;\;\;\left(0.5 + y\right) \cdot x\\ \mathbf{elif}\;y \leq 5.2:\\ \;\;\;\;z + 0.5 \cdot x\\ \mathbf{elif}\;y \leq 1.3 \cdot 10^{+21}:\\ \;\;\;\;\left(0.5 + y\right) \cdot x\\ \mathbf{elif}\;y \leq 4 \cdot 10^{+52}:\\ \;\;\;\;z\\ \mathbf{else}:\\ \;\;\;\;y \cdot x\\ \end{array} \]

Alternative 4: 71.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -9.5 \cdot 10^{+199}:\\ \;\;\;\;z\\ \mathbf{elif}\;z \leq 1.85 \cdot 10^{+38}:\\ \;\;\;\;\left(0.5 + y\right) \cdot x\\ \mathbf{else}:\\ \;\;\;\;z\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= z -9.5e+199) z (if (<= z 1.85e+38) (* (+ 0.5 y) x) z)))

C

double code(double x, double y, double z) {
	double tmp;
	if (z <= -9.5e+199) {
		tmp = z;
	} else if (z <= 1.85e+38) {
		tmp = (0.5 + y) * x;
	} else {
		tmp = z;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (z <= (-9.5d+199)) then
        tmp = z
    else if (z <= 1.85d+38) then
        tmp = (0.5d0 + y) * x
    else
        tmp = z
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (z <= -9.5e+199) {
		tmp = z;
	} else if (z <= 1.85e+38) {
		tmp = (0.5 + y) * x;
	} else {
		tmp = z;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if z <= -9.5e+199:
		tmp = z
	elif z <= 1.85e+38:
		tmp = (0.5 + y) * x
	else:
		tmp = z
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (z <= -9.5e+199)
		tmp = z;
	elseif (z <= 1.85e+38)
		tmp = Float64(Float64(0.5 + y) * x);
	else
		tmp = z;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (z <= -9.5e+199)
		tmp = z;
	elseif (z <= 1.85e+38)
		tmp = (0.5 + y) * x;
	else
		tmp = z;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[z, -9.5e+199], z, If[LessEqual[z, 1.85e+38], N[(N[(0.5 + y), $MachinePrecision] * x), $MachinePrecision], z]]

Derivation

1. Split input into 2 regimes

2. if z < -9.49999999999999954e199 or 1.8500000000000001e38 < z

   1. Initial program 100.0%

      \[\left(\frac{x}{2} + y \cdot x\right) + z \]
   2. Step-by-step derivation

      1. associate-+l+ 100.0%

         \[\leadsto \color{blue}{\frac{x}{2} + \left(y \cdot x + z\right)} \]

      2. *-commutative 100.0%

         \[\leadsto \frac{x}{2} + \left(\color{blue}{x \cdot y} + z\right) \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{x}{2} + \left(x \cdot y + z\right)} \]

   4. Taylor expanded in x around 0 74.8%

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

   if -9.49999999999999954e199 < z < 1.8500000000000001e38

   1. Initial program 100.0%

      \[\left(\frac{x}{2} + y \cdot x\right) + z \]
   2. Step-by-step derivation

      1. associate-+l+ 100.0%

         \[\leadsto \color{blue}{\frac{x}{2} + \left(y \cdot x + z\right)} \]

      2. *-commutative 100.0%

         \[\leadsto \frac{x}{2} + \left(\color{blue}{x \cdot y} + z\right) \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{x}{2} + \left(x \cdot y + z\right)} \]

   4. Taylor expanded in x around inf 81.3%

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

4. Final simplification 79.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -9.5 \cdot 10^{+199}:\\ \;\;\;\;z\\ \mathbf{elif}\;z \leq 1.85 \cdot 10^{+38}:\\ \;\;\;\;\left(0.5 + y\right) \cdot x\\ \mathbf{else}:\\ \;\;\;\;z\\ \end{array} \]

Alternative 5: 46.3% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -1.5 \cdot 10^{+146}:\\ \;\;\;\;z\\ \mathbf{elif}\;z \leq 1.65 \cdot 10^{-99}:\\ \;\;\;\;0.5 \cdot x\\ \mathbf{else}:\\ \;\;\;\;z\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= z -1.5e+146) z (if (<= z 1.65e-99) (* 0.5 x) z)))

C

double code(double x, double y, double z) {
	double tmp;
	if (z <= -1.5e+146) {
		tmp = z;
	} else if (z <= 1.65e-99) {
		tmp = 0.5 * x;
	} else {
		tmp = z;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (z <= (-1.5d+146)) then
        tmp = z
    else if (z <= 1.65d-99) then
        tmp = 0.5d0 * x
    else
        tmp = z
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (z <= -1.5e+146) {
		tmp = z;
	} else if (z <= 1.65e-99) {
		tmp = 0.5 * x;
	} else {
		tmp = z;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if z <= -1.5e+146:
		tmp = z
	elif z <= 1.65e-99:
		tmp = 0.5 * x
	else:
		tmp = z
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (z <= -1.5e+146)
		tmp = z;
	elseif (z <= 1.65e-99)
		tmp = Float64(0.5 * x);
	else
		tmp = z;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (z <= -1.5e+146)
		tmp = z;
	elseif (z <= 1.65e-99)
		tmp = 0.5 * x;
	else
		tmp = z;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[z, -1.5e+146], z, If[LessEqual[z, 1.65e-99], N[(0.5 * x), $MachinePrecision], z]]

Derivation

1. Split input into 2 regimes

2. if z < -1.50000000000000001e146 or 1.64999999999999993e-99 < z

   1. Initial program 100.0%

      \[\left(\frac{x}{2} + y \cdot x\right) + z \]
   2. Step-by-step derivation

      1. associate-+l+ 100.0%

         \[\leadsto \color{blue}{\frac{x}{2} + \left(y \cdot x + z\right)} \]

      2. *-commutative 100.0%

         \[\leadsto \frac{x}{2} + \left(\color{blue}{x \cdot y} + z\right) \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{x}{2} + \left(x \cdot y + z\right)} \]

   4. Taylor expanded in x around 0 62.2%

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

   if -1.50000000000000001e146 < z < 1.64999999999999993e-99

   1. Initial program 100.0%

      \[\left(\frac{x}{2} + y \cdot x\right) + z \]
   2. Step-by-step derivation

      1. associate-+l+ 100.0%

         \[\leadsto \color{blue}{\frac{x}{2} + \left(y \cdot x + z\right)} \]

      2. *-commutative 100.0%

         \[\leadsto \frac{x}{2} + \left(\color{blue}{x \cdot y} + z\right) \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{x}{2} + \left(x \cdot y + z\right)} \]

   4. Taylor expanded in x around inf 87.7%

      \[\leadsto \color{blue}{\left(0.5 + y\right) \cdot x} \]

   5. Taylor expanded in y around 0 51.1%

      \[\leadsto \color{blue}{0.5 \cdot x} \]
3. Recombined 2 regimes into one program.

4. Final simplification 56.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -1.5 \cdot 10^{+146}:\\ \;\;\;\;z\\ \mathbf{elif}\;z \leq 1.65 \cdot 10^{-99}:\\ \;\;\;\;0.5 \cdot x\\ \mathbf{else}:\\ \;\;\;\;z\\ \end{array} \]

Alternative 6: 100.0% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ z + \left(0.5 + y\right) \cdot x \end{array} \]

FPCore

(FPCore (x y z) :precision binary64 (+ z (* (+ 0.5 y) x)))

C

double code(double x, double y, double z) {
	return z + ((0.5 + y) * x);
}

Fortran

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

Java

public static double code(double x, double y, double z) {
	return z + ((0.5 + y) * x);
}

Python

def code(x, y, z):
	return z + ((0.5 + y) * x)

Julia

function code(x, y, z)
	return Float64(z + Float64(Float64(0.5 + y) * x))
end

MATLAB

function tmp = code(x, y, z)
	tmp = z + ((0.5 + y) * x);
end

Wolfram

code[x_, y_, z_] := N[(z + N[(N[(0.5 + y), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 100.0%

   \[\left(\frac{x}{2} + y \cdot x\right) + z \]
2. Step-by-step derivation

   1. associate-+l+ 100.0%

      \[\leadsto \color{blue}{\frac{x}{2} + \left(y \cdot x + z\right)} \]

   2. *-commutative 100.0%

      \[\leadsto \frac{x}{2} + \left(\color{blue}{x \cdot y} + z\right) \]

3. Simplified 100.0%

   \[\leadsto \color{blue}{\frac{x}{2} + \left(x \cdot y + z\right)} \]

4. Taylor expanded in x around 0 100.0%

   \[\leadsto \color{blue}{z + \left(0.5 + y\right) \cdot x} \]

5. Final simplification 100.0%

   \[\leadsto z + \left(0.5 + y\right) \cdot x \]

Alternative 7: 39.1% accurate, 9.0× speedup

Math

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

FPCore

(FPCore (x y z) :precision binary64 z)

C

double code(double x, double y, double z) {
	return z;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    code = z
end function

Java

public static double code(double x, double y, double z) {
	return z;
}

Python

def code(x, y, z):
	return z

Julia

function code(x, y, z)
	return z
end

MATLAB

function tmp = code(x, y, z)
	tmp = z;
end

Wolfram

code[x_, y_, z_] := z

Derivation

1. Initial program 100.0%

   \[\left(\frac{x}{2} + y \cdot x\right) + z \]
2. Step-by-step derivation

   1. associate-+l+ 100.0%

      \[\leadsto \color{blue}{\frac{x}{2} + \left(y \cdot x + z\right)} \]

   2. *-commutative 100.0%

      \[\leadsto \frac{x}{2} + \left(\color{blue}{x \cdot y} + z\right) \]

3. Simplified 100.0%

   \[\leadsto \color{blue}{\frac{x}{2} + \left(x \cdot y + z\right)} \]

4. Taylor expanded in x around 0 39.3%

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

5. Final simplification 39.3%

   \[\leadsto z \]

Reproduce

herbie shell --seed 2023224 
(FPCore (x y z)
  :name "Data.Histogram.Bin.BinF:$cfromIndex from histogram-fill-0.8.4.1"
  :precision binary64
  (+ (+ (/ x 2.0) (* y x)) z))