Graphics.Rendering.Plot.Render.Plot.Legend:renderLegendOutside from plot-0.2.3.4, C

Percentage Accurate: 99.9% → 100.0%

Time: 5.3s

Alternatives: 9

Speedup: 1.0×

• 21.3% of points produce a very large (infinite) output. You may want to add a precondition.

Specification

Math

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

FPCore

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

C

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

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 * (y + z)) + (z * 5.0d0)
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 99.9% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

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 * (y + z)) + (z * 5.0d0)
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 100.0% accurate, 0.1× speedup

Math

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

FPCore

(FPCore (x y z) :precision binary64 (fma z 5.0 (* x (+ z y))))

C

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

Julia

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

Wolfram

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

Derivation

1. Initial program 99.9%

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

   1. +-commutative 99.9%

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

   2. fma-def 100.0%

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

3. Applied egg-rr 100.0%

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

4. Final simplification 100.0%

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

Alternative 2: 59.8% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -4.3 \cdot 10^{+93}:\\ \;\;\;\;z \cdot x\\ \mathbf{elif}\;x \leq -2.3 \cdot 10^{-65}:\\ \;\;\;\;x \cdot y\\ \mathbf{elif}\;x \leq 1.55 \cdot 10^{-138}:\\ \;\;\;\;z \cdot 5\\ \mathbf{elif}\;x \leq 3.8 \cdot 10^{-79}:\\ \;\;\;\;x \cdot y\\ \mathbf{elif}\;x \leq 5:\\ \;\;\;\;z \cdot 5\\ \mathbf{elif}\;x \leq 1.05 \cdot 10^{+257}:\\ \;\;\;\;z \cdot x\\ \mathbf{elif}\;x \leq 1.04 \cdot 10^{+301}:\\ \;\;\;\;x \cdot y\\ \mathbf{else}:\\ \;\;\;\;z \cdot x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x -4.3e+93)
   (* z x)
   (if (<= x -2.3e-65)
     (* x y)
     (if (<= x 1.55e-138)
       (* z 5.0)
       (if (<= x 3.8e-79)
         (* x y)
         (if (<= x 5.0)
           (* z 5.0)
           (if (<= x 1.05e+257)
             (* z x)
             (if (<= x 1.04e+301) (* x y) (* z x)))))))))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= -4.3e+93) {
		tmp = z * x;
	} else if (x <= -2.3e-65) {
		tmp = x * y;
	} else if (x <= 1.55e-138) {
		tmp = z * 5.0;
	} else if (x <= 3.8e-79) {
		tmp = x * y;
	} else if (x <= 5.0) {
		tmp = z * 5.0;
	} else if (x <= 1.05e+257) {
		tmp = z * x;
	} else if (x <= 1.04e+301) {
		tmp = x * y;
	} else {
		tmp = z * 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 (x <= (-4.3d+93)) then
        tmp = z * x
    else if (x <= (-2.3d-65)) then
        tmp = x * y
    else if (x <= 1.55d-138) then
        tmp = z * 5.0d0
    else if (x <= 3.8d-79) then
        tmp = x * y
    else if (x <= 5.0d0) then
        tmp = z * 5.0d0
    else if (x <= 1.05d+257) then
        tmp = z * x
    else if (x <= 1.04d+301) then
        tmp = x * y
    else
        tmp = z * x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (x <= -4.3e+93) {
		tmp = z * x;
	} else if (x <= -2.3e-65) {
		tmp = x * y;
	} else if (x <= 1.55e-138) {
		tmp = z * 5.0;
	} else if (x <= 3.8e-79) {
		tmp = x * y;
	} else if (x <= 5.0) {
		tmp = z * 5.0;
	} else if (x <= 1.05e+257) {
		tmp = z * x;
	} else if (x <= 1.04e+301) {
		tmp = x * y;
	} else {
		tmp = z * x;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= -4.3e+93:
		tmp = z * x
	elif x <= -2.3e-65:
		tmp = x * y
	elif x <= 1.55e-138:
		tmp = z * 5.0
	elif x <= 3.8e-79:
		tmp = x * y
	elif x <= 5.0:
		tmp = z * 5.0
	elif x <= 1.05e+257:
		tmp = z * x
	elif x <= 1.04e+301:
		tmp = x * y
	else:
		tmp = z * x
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= -4.3e+93)
		tmp = Float64(z * x);
	elseif (x <= -2.3e-65)
		tmp = Float64(x * y);
	elseif (x <= 1.55e-138)
		tmp = Float64(z * 5.0);
	elseif (x <= 3.8e-79)
		tmp = Float64(x * y);
	elseif (x <= 5.0)
		tmp = Float64(z * 5.0);
	elseif (x <= 1.05e+257)
		tmp = Float64(z * x);
	elseif (x <= 1.04e+301)
		tmp = Float64(x * y);
	else
		tmp = Float64(z * x);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= -4.3e+93)
		tmp = z * x;
	elseif (x <= -2.3e-65)
		tmp = x * y;
	elseif (x <= 1.55e-138)
		tmp = z * 5.0;
	elseif (x <= 3.8e-79)
		tmp = x * y;
	elseif (x <= 5.0)
		tmp = z * 5.0;
	elseif (x <= 1.05e+257)
		tmp = z * x;
	elseif (x <= 1.04e+301)
		tmp = x * y;
	else
		tmp = z * x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, -4.3e+93], N[(z * x), $MachinePrecision], If[LessEqual[x, -2.3e-65], N[(x * y), $MachinePrecision], If[LessEqual[x, 1.55e-138], N[(z * 5.0), $MachinePrecision], If[LessEqual[x, 3.8e-79], N[(x * y), $MachinePrecision], If[LessEqual[x, 5.0], N[(z * 5.0), $MachinePrecision], If[LessEqual[x, 1.05e+257], N[(z * x), $MachinePrecision], If[LessEqual[x, 1.04e+301], N[(x * y), $MachinePrecision], N[(z * x), $MachinePrecision]]]]]]]]

Derivation

1. Split input into 3 regimes

2. if x < -4.3e93 or 5 < x < 1.05000000000000006e257 or 1.0400000000000001e301 < x

   1. Initial program 100.0%

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

   2. Taylor expanded in x around inf 99.7%

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

      1. +-commutative 99.7%

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

   4. Simplified 99.7%

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

   5. Taylor expanded in z around inf 68.6%

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

   if -4.3e93 < x < -2.3e-65 or 1.5499999999999999e-138 < x < 3.8000000000000001e-79 or 1.05000000000000006e257 < x < 1.0400000000000001e301

   1. Initial program 99.9%

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

   2. Taylor expanded in y around inf 67.7%

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

   if -2.3e-65 < x < 1.5499999999999999e-138 or 3.8000000000000001e-79 < x < 5

   1. Initial program 99.8%

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

   2. Taylor expanded in x around 0 76.5%

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

4. Final simplification 71.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -4.3 \cdot 10^{+93}:\\ \;\;\;\;z \cdot x\\ \mathbf{elif}\;x \leq -2.3 \cdot 10^{-65}:\\ \;\;\;\;x \cdot y\\ \mathbf{elif}\;x \leq 1.55 \cdot 10^{-138}:\\ \;\;\;\;z \cdot 5\\ \mathbf{elif}\;x \leq 3.8 \cdot 10^{-79}:\\ \;\;\;\;x \cdot y\\ \mathbf{elif}\;x \leq 5:\\ \;\;\;\;z \cdot 5\\ \mathbf{elif}\;x \leq 1.05 \cdot 10^{+257}:\\ \;\;\;\;z \cdot x\\ \mathbf{elif}\;x \leq 1.04 \cdot 10^{+301}:\\ \;\;\;\;x \cdot y\\ \mathbf{else}:\\ \;\;\;\;z \cdot x\\ \end{array} \]

Alternative 3: 82.1% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := x \cdot \left(z + y\right)\\ \mathbf{if}\;x \leq -1.6 \cdot 10^{-65}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;x \leq 1.06 \cdot 10^{-159}:\\ \;\;\;\;z \cdot \left(5 + x\right)\\ \mathbf{elif}\;x \leq 3.3 \cdot 10^{-79} \lor \neg \left(x \leq 1020000000000\right):\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;z \cdot 5 + z \cdot x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (* x (+ z y))))
   (if (<= x -1.6e-65)
     t_0
     (if (<= x 1.06e-159)
       (* z (+ 5.0 x))
       (if (or (<= x 3.3e-79) (not (<= x 1020000000000.0)))
         t_0
         (+ (* z 5.0) (* z x)))))))

C

double code(double x, double y, double z) {
	double t_0 = x * (z + y);
	double tmp;
	if (x <= -1.6e-65) {
		tmp = t_0;
	} else if (x <= 1.06e-159) {
		tmp = z * (5.0 + x);
	} else if ((x <= 3.3e-79) || !(x <= 1020000000000.0)) {
		tmp = t_0;
	} else {
		tmp = (z * 5.0) + (z * 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 = x * (z + y)
    if (x <= (-1.6d-65)) then
        tmp = t_0
    else if (x <= 1.06d-159) then
        tmp = z * (5.0d0 + x)
    else if ((x <= 3.3d-79) .or. (.not. (x <= 1020000000000.0d0))) then
        tmp = t_0
    else
        tmp = (z * 5.0d0) + (z * x)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = x * (z + y);
	double tmp;
	if (x <= -1.6e-65) {
		tmp = t_0;
	} else if (x <= 1.06e-159) {
		tmp = z * (5.0 + x);
	} else if ((x <= 3.3e-79) || !(x <= 1020000000000.0)) {
		tmp = t_0;
	} else {
		tmp = (z * 5.0) + (z * x);
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = x * (z + y)
	tmp = 0
	if x <= -1.6e-65:
		tmp = t_0
	elif x <= 1.06e-159:
		tmp = z * (5.0 + x)
	elif (x <= 3.3e-79) or not (x <= 1020000000000.0):
		tmp = t_0
	else:
		tmp = (z * 5.0) + (z * x)
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(x * Float64(z + y))
	tmp = 0.0
	if (x <= -1.6e-65)
		tmp = t_0;
	elseif (x <= 1.06e-159)
		tmp = Float64(z * Float64(5.0 + x));
	elseif ((x <= 3.3e-79) || !(x <= 1020000000000.0))
		tmp = t_0;
	else
		tmp = Float64(Float64(z * 5.0) + Float64(z * x));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = x * (z + y);
	tmp = 0.0;
	if (x <= -1.6e-65)
		tmp = t_0;
	elseif (x <= 1.06e-159)
		tmp = z * (5.0 + x);
	elseif ((x <= 3.3e-79) || ~((x <= 1020000000000.0)))
		tmp = t_0;
	else
		tmp = (z * 5.0) + (z * x);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(x * N[(z + y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.6e-65], t$95$0, If[LessEqual[x, 1.06e-159], N[(z * N[(5.0 + x), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[x, 3.3e-79], N[Not[LessEqual[x, 1020000000000.0]], $MachinePrecision]], t$95$0, N[(N[(z * 5.0), $MachinePrecision] + N[(z * x), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

1. Split input into 3 regimes

2. if x < -1.6e-65 or 1.06e-159 < x < 3.2999999999999998e-79 or 1.02e12 < x

   1. Initial program 100.0%

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

   2. Taylor expanded in x around inf 95.2%

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

      1. +-commutative 95.2%

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

   4. Simplified 95.2%

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

   if -1.6e-65 < x < 1.06e-159

   1. Initial program 99.8%

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

   2. Taylor expanded in y around 0 77.5%

      \[\leadsto \color{blue}{5 \cdot z + x \cdot z} \]
   3. Step-by-step derivation

      1. distribute-rgt-in 77.5%

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

   4. Simplified 77.5%

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

   if 3.2999999999999998e-79 < x < 1.02e12

   1. Initial program 100.0%

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

   2. Taylor expanded in y around 0 80.5%

      \[\leadsto \color{blue}{x \cdot z} + z \cdot 5 \]
   3. Step-by-step derivation

      1. *-commutative 80.5%

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

   4. Simplified 80.5%

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

4. Final simplification 88.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -1.6 \cdot 10^{-65}:\\ \;\;\;\;x \cdot \left(z + y\right)\\ \mathbf{elif}\;x \leq 1.06 \cdot 10^{-159}:\\ \;\;\;\;z \cdot \left(5 + x\right)\\ \mathbf{elif}\;x \leq 3.3 \cdot 10^{-79} \lor \neg \left(x \leq 1020000000000\right):\\ \;\;\;\;x \cdot \left(z + y\right)\\ \mathbf{else}:\\ \;\;\;\;z \cdot 5 + z \cdot x\\ \end{array} \]

Alternative 4: 81.9% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := x \cdot \left(z + y\right)\\ \mathbf{if}\;x \leq -2.65 \cdot 10^{-65}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;x \leq 1.7 \cdot 10^{-162}:\\ \;\;\;\;\frac{25}{\frac{5 - x}{z}}\\ \mathbf{elif}\;x \leq 3.3 \cdot 10^{-79} \lor \neg \left(x \leq 1020000000000\right):\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;z \cdot 5 + z \cdot x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (* x (+ z y))))
   (if (<= x -2.65e-65)
     t_0
     (if (<= x 1.7e-162)
       (/ 25.0 (/ (- 5.0 x) z))
       (if (or (<= x 3.3e-79) (not (<= x 1020000000000.0)))
         t_0
         (+ (* z 5.0) (* z x)))))))

C

double code(double x, double y, double z) {
	double t_0 = x * (z + y);
	double tmp;
	if (x <= -2.65e-65) {
		tmp = t_0;
	} else if (x <= 1.7e-162) {
		tmp = 25.0 / ((5.0 - x) / z);
	} else if ((x <= 3.3e-79) || !(x <= 1020000000000.0)) {
		tmp = t_0;
	} else {
		tmp = (z * 5.0) + (z * 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 = x * (z + y)
    if (x <= (-2.65d-65)) then
        tmp = t_0
    else if (x <= 1.7d-162) then
        tmp = 25.0d0 / ((5.0d0 - x) / z)
    else if ((x <= 3.3d-79) .or. (.not. (x <= 1020000000000.0d0))) then
        tmp = t_0
    else
        tmp = (z * 5.0d0) + (z * x)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = x * (z + y);
	double tmp;
	if (x <= -2.65e-65) {
		tmp = t_0;
	} else if (x <= 1.7e-162) {
		tmp = 25.0 / ((5.0 - x) / z);
	} else if ((x <= 3.3e-79) || !(x <= 1020000000000.0)) {
		tmp = t_0;
	} else {
		tmp = (z * 5.0) + (z * x);
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = x * (z + y)
	tmp = 0
	if x <= -2.65e-65:
		tmp = t_0
	elif x <= 1.7e-162:
		tmp = 25.0 / ((5.0 - x) / z)
	elif (x <= 3.3e-79) or not (x <= 1020000000000.0):
		tmp = t_0
	else:
		tmp = (z * 5.0) + (z * x)
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(x * Float64(z + y))
	tmp = 0.0
	if (x <= -2.65e-65)
		tmp = t_0;
	elseif (x <= 1.7e-162)
		tmp = Float64(25.0 / Float64(Float64(5.0 - x) / z));
	elseif ((x <= 3.3e-79) || !(x <= 1020000000000.0))
		tmp = t_0;
	else
		tmp = Float64(Float64(z * 5.0) + Float64(z * x));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = x * (z + y);
	tmp = 0.0;
	if (x <= -2.65e-65)
		tmp = t_0;
	elseif (x <= 1.7e-162)
		tmp = 25.0 / ((5.0 - x) / z);
	elseif ((x <= 3.3e-79) || ~((x <= 1020000000000.0)))
		tmp = t_0;
	else
		tmp = (z * 5.0) + (z * x);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(x * N[(z + y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -2.65e-65], t$95$0, If[LessEqual[x, 1.7e-162], N[(25.0 / N[(N[(5.0 - x), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[x, 3.3e-79], N[Not[LessEqual[x, 1020000000000.0]], $MachinePrecision]], t$95$0, N[(N[(z * 5.0), $MachinePrecision] + N[(z * x), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

1. Split input into 3 regimes

2. if x < -2.65000000000000019e-65 or 1.7e-162 < x < 3.2999999999999998e-79 or 1.02e12 < x

   1. Initial program 100.0%

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

   2. Taylor expanded in x around inf 95.2%

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

      1. +-commutative 95.2%

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

   4. Simplified 95.2%

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

   if -2.65000000000000019e-65 < x < 1.7e-162

   1. Initial program 99.8%

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

   2. Taylor expanded in y around 0 77.5%

      \[\leadsto \color{blue}{x \cdot z} + z \cdot 5 \]
   3. Step-by-step derivation

      1. *-commutative 77.5%

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

   4. Simplified 77.5%

      \[\leadsto \color{blue}{z \cdot x} + z \cdot 5 \]
   5. Step-by-step derivation

      1. distribute-lft-out 77.5%

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

      2. metadata-eval 77.5%

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

      3. sub-neg 77.5%

         \[\leadsto z \cdot \color{blue}{\left(x - -5\right)} \]

      4. *-commutative 77.5%

         \[\leadsto \color{blue}{\left(x - -5\right) \cdot z} \]

      5. sub-neg 77.5%

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

      6. metadata-eval 77.5%

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

      7. +-commutative 77.5%

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

   6. Applied egg-rr 77.5%

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

      1. *-commutative 77.5%

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

      2. flip-+ 77.5%

         \[\leadsto z \cdot \color{blue}{\frac{5 \cdot 5 - x \cdot x}{5 - x}} \]

      3. sub-neg 77.5%

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

      4. metadata-eval 77.5%

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

      5. distribute-neg-in 77.5%

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

      6. +-commutative 77.5%

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

      7. associate-*r/ 77.4%

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

      8. metadata-eval 77.4%

         \[\leadsto \frac{z \cdot \left(\color{blue}{25} - x \cdot x\right)}{-\left(x + -5\right)} \]

      9. +-commutative 77.4%

         \[\leadsto \frac{z \cdot \left(25 - x \cdot x\right)}{-\color{blue}{\left(-5 + x\right)}} \]

      10. distribute-neg-in 77.4%

          \[\leadsto \frac{z \cdot \left(25 - x \cdot x\right)}{\color{blue}{\left(--5\right) + \left(-x\right)}} \]

      11. metadata-eval 77.4%

          \[\leadsto \frac{z \cdot \left(25 - x \cdot x\right)}{\color{blue}{5} + \left(-x\right)} \]

      12. sub-neg 77.4%

          \[\leadsto \frac{z \cdot \left(25 - x \cdot x\right)}{\color{blue}{5 - x}} \]

   8. Applied egg-rr 77.4%

      \[\leadsto \color{blue}{\frac{z \cdot \left(25 - x \cdot x\right)}{5 - x}} \]
   9. Step-by-step derivation

      1. *-commutative 77.4%

         \[\leadsto \frac{\color{blue}{\left(25 - x \cdot x\right) \cdot z}}{5 - x} \]

      2. associate-/l* 77.5%

         \[\leadsto \color{blue}{\frac{25 - x \cdot x}{\frac{5 - x}{z}}} \]

   10. Simplified 77.5%

       \[\leadsto \color{blue}{\frac{25 - x \cdot x}{\frac{5 - x}{z}}} \]

   11. Taylor expanded in x around 0 77.5%

       \[\leadsto \frac{\color{blue}{25}}{\frac{5 - x}{z}} \]

   if 3.2999999999999998e-79 < x < 1.02e12

   1. Initial program 100.0%

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

   2. Taylor expanded in y around 0 80.5%

      \[\leadsto \color{blue}{x \cdot z} + z \cdot 5 \]
   3. Step-by-step derivation

      1. *-commutative 80.5%

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

   4. Simplified 80.5%

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

4. Final simplification 88.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -2.65 \cdot 10^{-65}:\\ \;\;\;\;x \cdot \left(z + y\right)\\ \mathbf{elif}\;x \leq 1.7 \cdot 10^{-162}:\\ \;\;\;\;\frac{25}{\frac{5 - x}{z}}\\ \mathbf{elif}\;x \leq 3.3 \cdot 10^{-79} \lor \neg \left(x \leq 1020000000000\right):\\ \;\;\;\;x \cdot \left(z + y\right)\\ \mathbf{else}:\\ \;\;\;\;z \cdot 5 + z \cdot x\\ \end{array} \]

Alternative 5: 82.4% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -2.65 \cdot 10^{-65} \lor \neg \left(x \leq 1.06 \cdot 10^{-159} \lor \neg \left(x \leq 3.3 \cdot 10^{-79}\right) \land x \leq 4.2 \cdot 10^{-10}\right):\\ \;\;\;\;x \cdot \left(z + y\right)\\ \mathbf{else}:\\ \;\;\;\;z \cdot 5\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (or (<= x -2.65e-65)
         (not (or (<= x 1.06e-159) (and (not (<= x 3.3e-79)) (<= x 4.2e-10)))))
   (* x (+ z y))
   (* z 5.0)))

C

double code(double x, double y, double z) {
	double tmp;
	if ((x <= -2.65e-65) || !((x <= 1.06e-159) || (!(x <= 3.3e-79) && (x <= 4.2e-10)))) {
		tmp = x * (z + y);
	} else {
		tmp = z * 5.0;
	}
	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 ((x <= (-2.65d-65)) .or. (.not. (x <= 1.06d-159) .or. (.not. (x <= 3.3d-79)) .and. (x <= 4.2d-10))) then
        tmp = x * (z + y)
    else
        tmp = z * 5.0d0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if ((x <= -2.65e-65) || !((x <= 1.06e-159) || (!(x <= 3.3e-79) && (x <= 4.2e-10)))) {
		tmp = x * (z + y);
	} else {
		tmp = z * 5.0;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if (x <= -2.65e-65) or not ((x <= 1.06e-159) or (not (x <= 3.3e-79) and (x <= 4.2e-10))):
		tmp = x * (z + y)
	else:
		tmp = z * 5.0
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if ((x <= -2.65e-65) || !((x <= 1.06e-159) || (!(x <= 3.3e-79) && (x <= 4.2e-10))))
		tmp = Float64(x * Float64(z + y));
	else
		tmp = Float64(z * 5.0);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if ((x <= -2.65e-65) || ~(((x <= 1.06e-159) || (~((x <= 3.3e-79)) && (x <= 4.2e-10)))))
		tmp = x * (z + y);
	else
		tmp = z * 5.0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[Or[LessEqual[x, -2.65e-65], N[Not[Or[LessEqual[x, 1.06e-159], And[N[Not[LessEqual[x, 3.3e-79]], $MachinePrecision], LessEqual[x, 4.2e-10]]]], $MachinePrecision]], N[(x * N[(z + y), $MachinePrecision]), $MachinePrecision], N[(z * 5.0), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if x < -2.65000000000000019e-65 or 1.06e-159 < x < 3.2999999999999998e-79 or 4.2e-10 < x

   1. Initial program 100.0%

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

   2. Taylor expanded in x around inf 95.1%

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

      1. +-commutative 95.1%

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

   4. Simplified 95.1%

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

   if -2.65000000000000019e-65 < x < 1.06e-159 or 3.2999999999999998e-79 < x < 4.2e-10

   1. Initial program 99.8%

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

   2. Taylor expanded in x around 0 77.4%

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

4. Final simplification 87.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -2.65 \cdot 10^{-65} \lor \neg \left(x \leq 1.06 \cdot 10^{-159} \lor \neg \left(x \leq 3.3 \cdot 10^{-79}\right) \land x \leq 4.2 \cdot 10^{-10}\right):\\ \;\;\;\;x \cdot \left(z + y\right)\\ \mathbf{else}:\\ \;\;\;\;z \cdot 5\\ \end{array} \]

Alternative 6: 82.1% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -1.85 \cdot 10^{-65} \lor \neg \left(x \leq 1.06 \cdot 10^{-159}\right) \land \left(x \leq 3.3 \cdot 10^{-79} \lor \neg \left(x \leq 1020000000000\right)\right):\\ \;\;\;\;x \cdot \left(z + y\right)\\ \mathbf{else}:\\ \;\;\;\;z \cdot \left(5 + x\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (or (<= x -1.85e-65)
         (and (not (<= x 1.06e-159))
              (or (<= x 3.3e-79) (not (<= x 1020000000000.0)))))
   (* x (+ z y))
   (* z (+ 5.0 x))))

C

double code(double x, double y, double z) {
	double tmp;
	if ((x <= -1.85e-65) || (!(x <= 1.06e-159) && ((x <= 3.3e-79) || !(x <= 1020000000000.0)))) {
		tmp = x * (z + y);
	} else {
		tmp = z * (5.0 + 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 ((x <= (-1.85d-65)) .or. (.not. (x <= 1.06d-159)) .and. (x <= 3.3d-79) .or. (.not. (x <= 1020000000000.0d0))) then
        tmp = x * (z + y)
    else
        tmp = z * (5.0d0 + x)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if ((x <= -1.85e-65) || (!(x <= 1.06e-159) && ((x <= 3.3e-79) || !(x <= 1020000000000.0)))) {
		tmp = x * (z + y);
	} else {
		tmp = z * (5.0 + x);
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if (x <= -1.85e-65) or (not (x <= 1.06e-159) and ((x <= 3.3e-79) or not (x <= 1020000000000.0))):
		tmp = x * (z + y)
	else:
		tmp = z * (5.0 + x)
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if ((x <= -1.85e-65) || (!(x <= 1.06e-159) && ((x <= 3.3e-79) || !(x <= 1020000000000.0))))
		tmp = Float64(x * Float64(z + y));
	else
		tmp = Float64(z * Float64(5.0 + x));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if ((x <= -1.85e-65) || (~((x <= 1.06e-159)) && ((x <= 3.3e-79) || ~((x <= 1020000000000.0)))))
		tmp = x * (z + y);
	else
		tmp = z * (5.0 + x);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[Or[LessEqual[x, -1.85e-65], And[N[Not[LessEqual[x, 1.06e-159]], $MachinePrecision], Or[LessEqual[x, 3.3e-79], N[Not[LessEqual[x, 1020000000000.0]], $MachinePrecision]]]], N[(x * N[(z + y), $MachinePrecision]), $MachinePrecision], N[(z * N[(5.0 + x), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if x < -1.85e-65 or 1.06e-159 < x < 3.2999999999999998e-79 or 1.02e12 < x

   1. Initial program 100.0%

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

   2. Taylor expanded in x around inf 95.2%

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

      1. +-commutative 95.2%

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

   4. Simplified 95.2%

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

   if -1.85e-65 < x < 1.06e-159 or 3.2999999999999998e-79 < x < 1.02e12

   1. Initial program 99.8%

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

   2. Taylor expanded in y around 0 78.0%

      \[\leadsto \color{blue}{5 \cdot z + x \cdot z} \]
   3. Step-by-step derivation

      1. distribute-rgt-in 78.0%

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

   4. Simplified 78.0%

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

4. Final simplification 88.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -1.85 \cdot 10^{-65} \lor \neg \left(x \leq 1.06 \cdot 10^{-159}\right) \land \left(x \leq 3.3 \cdot 10^{-79} \lor \neg \left(x \leq 1020000000000\right)\right):\\ \;\;\;\;x \cdot \left(z + y\right)\\ \mathbf{else}:\\ \;\;\;\;z \cdot \left(5 + x\right)\\ \end{array} \]

Alternative 7: 59.0% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -9.5 \cdot 10^{-66}:\\ \;\;\;\;x \cdot y\\ \mathbf{elif}\;x \leq 8.6 \cdot 10^{-142} \lor \neg \left(x \leq 3.3 \cdot 10^{-79}\right) \land x \leq 1020000000000:\\ \;\;\;\;z \cdot 5\\ \mathbf{else}:\\ \;\;\;\;x \cdot y\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x -9.5e-66)
   (* x y)
   (if (or (<= x 8.6e-142) (and (not (<= x 3.3e-79)) (<= x 1020000000000.0)))
     (* z 5.0)
     (* x y))))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= -9.5e-66) {
		tmp = x * y;
	} else if ((x <= 8.6e-142) || (!(x <= 3.3e-79) && (x <= 1020000000000.0))) {
		tmp = z * 5.0;
	} else {
		tmp = x * y;
	}
	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 (x <= (-9.5d-66)) then
        tmp = x * y
    else if ((x <= 8.6d-142) .or. (.not. (x <= 3.3d-79)) .and. (x <= 1020000000000.0d0)) then
        tmp = z * 5.0d0
    else
        tmp = x * y
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (x <= -9.5e-66) {
		tmp = x * y;
	} else if ((x <= 8.6e-142) || (!(x <= 3.3e-79) && (x <= 1020000000000.0))) {
		tmp = z * 5.0;
	} else {
		tmp = x * y;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= -9.5e-66:
		tmp = x * y
	elif (x <= 8.6e-142) or (not (x <= 3.3e-79) and (x <= 1020000000000.0)):
		tmp = z * 5.0
	else:
		tmp = x * y
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= -9.5e-66)
		tmp = Float64(x * y);
	elseif ((x <= 8.6e-142) || (!(x <= 3.3e-79) && (x <= 1020000000000.0)))
		tmp = Float64(z * 5.0);
	else
		tmp = Float64(x * y);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= -9.5e-66)
		tmp = x * y;
	elseif ((x <= 8.6e-142) || (~((x <= 3.3e-79)) && (x <= 1020000000000.0)))
		tmp = z * 5.0;
	else
		tmp = x * y;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, -9.5e-66], N[(x * y), $MachinePrecision], If[Or[LessEqual[x, 8.6e-142], And[N[Not[LessEqual[x, 3.3e-79]], $MachinePrecision], LessEqual[x, 1020000000000.0]]], N[(z * 5.0), $MachinePrecision], N[(x * y), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if x < -9.5000000000000004e-66 or 8.5999999999999995e-142 < x < 3.2999999999999998e-79 or 1.02e12 < x

   1. Initial program 100.0%

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

   2. Taylor expanded in y around inf 47.6%

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

   if -9.5000000000000004e-66 < x < 8.5999999999999995e-142 or 3.2999999999999998e-79 < x < 1.02e12

   1. Initial program 99.8%

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

   2. Taylor expanded in x around 0 75.9%

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

4. Final simplification 60.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -9.5 \cdot 10^{-66}:\\ \;\;\;\;x \cdot y\\ \mathbf{elif}\;x \leq 8.6 \cdot 10^{-142} \lor \neg \left(x \leq 3.3 \cdot 10^{-79}\right) \land x \leq 1020000000000:\\ \;\;\;\;z \cdot 5\\ \mathbf{else}:\\ \;\;\;\;x \cdot y\\ \end{array} \]

Alternative 8: 99.9% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

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 * (z + y)) + (z * 5.0d0)
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 99.9%

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

2. Final simplification 99.9%

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

Alternative 9: 36.2% accurate, 3.0× speedup

Math

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

FPCore

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

C

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

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 * 5.0d0
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[x_, y_, z_] := N[(z * 5.0), $MachinePrecision]

Derivation

1. Initial program 99.9%

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

2. Taylor expanded in x around 0 36.0%

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

3. Final simplification 36.0%

   \[\leadsto z \cdot 5 \]

Developer target: 97.7% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

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 + 5.0d0) * z) + (x * y)
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Reproduce

herbie shell --seed 2023271 
(FPCore (x y z)
  :name "Graphics.Rendering.Plot.Render.Plot.Legend:renderLegendOutside from plot-0.2.3.4, C"
  :precision binary64

  :herbie-target
  (+ (* (+ x 5.0) z) (* x y))

  (+ (* x (+ y z)) (* z 5.0)))