Graphics.Rendering.Chart.Plot.AreaSpots:renderAreaSpots4D from Chart-1.5.3

Percentage Accurate: 84.2% → 97.0%

Time: 11.0s

Alternatives: 11

Speedup: 1.0×

Specification

Math

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

FPCore

(FPCore (x y z t) :precision binary64 (/ (* x (- y z)) (- t z)))

C

double code(double x, double y, double z, double t) {
	return (x * (y - z)) / (t - z);
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = (x * (y - z)) / (t - z)
end function

Java

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

Python

def code(x, y, z, t):
	return (x * (y - z)) / (t - z)

Julia

function code(x, y, z, t)
	return Float64(Float64(x * Float64(y - z)) / Float64(t - z))
end

MATLAB

function tmp = code(x, y, z, t)
	tmp = (x * (y - z)) / (t - z);
end

Wolfram

code[x_, y_, z_, t_] := N[(N[(x * N[(y - z), $MachinePrecision]), $MachinePrecision] / N[(t - z), $MachinePrecision]), $MachinePrecision]

Initial Program: 84.2% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y z t) :precision binary64 (/ (* x (- y z)) (- t z)))

C

double code(double x, double y, double z, double t) {
	return (x * (y - z)) / (t - z);
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = (x * (y - z)) / (t - z)
end function

Java

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

Python

def code(x, y, z, t):
	return (x * (y - z)) / (t - z)

Julia

function code(x, y, z, t)
	return Float64(Float64(x * Float64(y - z)) / Float64(t - z))
end

MATLAB

function tmp = code(x, y, z, t)
	tmp = (x * (y - z)) / (t - z);
end

Wolfram

code[x_, y_, z_, t_] := N[(N[(x * N[(y - z), $MachinePrecision]), $MachinePrecision] / N[(t - z), $MachinePrecision]), $MachinePrecision]

Alternative 1: 97.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{y - z}{t - z} \cdot x \end{array} \]

FPCore

(FPCore (x y z t) :precision binary64 (* (/ (- y z) (- t z)) x))

C

double code(double x, double y, double z, double t) {
	return ((y - z) / (t - z)) * x;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = ((y - z) / (t - z)) * x
end function

Java

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

Python

def code(x, y, z, t):
	return ((y - z) / (t - z)) * x

Julia

function code(x, y, z, t)
	return Float64(Float64(Float64(y - z) / Float64(t - z)) * x)
end

MATLAB

function tmp = code(x, y, z, t)
	tmp = ((y - z) / (t - z)) * x;
end

Wolfram

code[x_, y_, z_, t_] := N[(N[(N[(y - z), $MachinePrecision] / N[(t - z), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]

Derivation

1. Initial program 83.9%

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

   1. lift-/.f64 N/A

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

   2. lift-*.f64 N/A

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

   3. associate-/l* N/A

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

   4. *-commutative N/A

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

   5. lower-*.f64 N/A

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

   6. lower-/.f64 96.0

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

4. Applied rewrites 96.0%

   \[\leadsto \color{blue}{\frac{y - z}{t - z} \cdot x} \]
5. Add Preprocessing

Alternative 2: 66.9% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{x}{z} \cdot \left(z - y\right)\\ \mathbf{if}\;z \leq -4.6 \cdot 10^{+134}:\\ \;\;\;\;1 \cdot x\\ \mathbf{elif}\;z \leq -1.85 \cdot 10^{-33}:\\ \;\;\;\;\frac{y - z}{t} \cdot x\\ \mathbf{elif}\;z \leq -1.02 \cdot 10^{-60}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 2.5 \cdot 10^{-40}:\\ \;\;\;\;\frac{x}{t} \cdot \left(y - z\right)\\ \mathbf{elif}\;z \leq 1.4 \cdot 10^{+138}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;1 \cdot x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (* (/ x z) (- z y))))
   (if (<= z -4.6e+134)
     (* 1.0 x)
     (if (<= z -1.85e-33)
       (* (/ (- y z) t) x)
       (if (<= z -1.02e-60)
         t_1
         (if (<= z 2.5e-40)
           (* (/ x t) (- y z))
           (if (<= z 1.4e+138) t_1 (* 1.0 x))))))))

C

double code(double x, double y, double z, double t) {
	double t_1 = (x / z) * (z - y);
	double tmp;
	if (z <= -4.6e+134) {
		tmp = 1.0 * x;
	} else if (z <= -1.85e-33) {
		tmp = ((y - z) / t) * x;
	} else if (z <= -1.02e-60) {
		tmp = t_1;
	} else if (z <= 2.5e-40) {
		tmp = (x / t) * (y - z);
	} else if (z <= 1.4e+138) {
		tmp = t_1;
	} else {
		tmp = 1.0 * x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (x / z) * (z - y)
    if (z <= (-4.6d+134)) then
        tmp = 1.0d0 * x
    else if (z <= (-1.85d-33)) then
        tmp = ((y - z) / t) * x
    else if (z <= (-1.02d-60)) then
        tmp = t_1
    else if (z <= 2.5d-40) then
        tmp = (x / t) * (y - z)
    else if (z <= 1.4d+138) then
        tmp = t_1
    else
        tmp = 1.0d0 * x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = (x / z) * (z - y);
	double tmp;
	if (z <= -4.6e+134) {
		tmp = 1.0 * x;
	} else if (z <= -1.85e-33) {
		tmp = ((y - z) / t) * x;
	} else if (z <= -1.02e-60) {
		tmp = t_1;
	} else if (z <= 2.5e-40) {
		tmp = (x / t) * (y - z);
	} else if (z <= 1.4e+138) {
		tmp = t_1;
	} else {
		tmp = 1.0 * x;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = (x / z) * (z - y)
	tmp = 0
	if z <= -4.6e+134:
		tmp = 1.0 * x
	elif z <= -1.85e-33:
		tmp = ((y - z) / t) * x
	elif z <= -1.02e-60:
		tmp = t_1
	elif z <= 2.5e-40:
		tmp = (x / t) * (y - z)
	elif z <= 1.4e+138:
		tmp = t_1
	else:
		tmp = 1.0 * x
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(Float64(x / z) * Float64(z - y))
	tmp = 0.0
	if (z <= -4.6e+134)
		tmp = Float64(1.0 * x);
	elseif (z <= -1.85e-33)
		tmp = Float64(Float64(Float64(y - z) / t) * x);
	elseif (z <= -1.02e-60)
		tmp = t_1;
	elseif (z <= 2.5e-40)
		tmp = Float64(Float64(x / t) * Float64(y - z));
	elseif (z <= 1.4e+138)
		tmp = t_1;
	else
		tmp = Float64(1.0 * x);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = (x / z) * (z - y);
	tmp = 0.0;
	if (z <= -4.6e+134)
		tmp = 1.0 * x;
	elseif (z <= -1.85e-33)
		tmp = ((y - z) / t) * x;
	elseif (z <= -1.02e-60)
		tmp = t_1;
	elseif (z <= 2.5e-40)
		tmp = (x / t) * (y - z);
	elseif (z <= 1.4e+138)
		tmp = t_1;
	else
		tmp = 1.0 * x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(x / z), $MachinePrecision] * N[(z - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -4.6e+134], N[(1.0 * x), $MachinePrecision], If[LessEqual[z, -1.85e-33], N[(N[(N[(y - z), $MachinePrecision] / t), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[z, -1.02e-60], t$95$1, If[LessEqual[z, 2.5e-40], N[(N[(x / t), $MachinePrecision] * N[(y - z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.4e+138], t$95$1, N[(1.0 * x), $MachinePrecision]]]]]]]

Derivation

1. Split input into 4 regimes

2. if z < -4.5999999999999996e134 or 1.4e138 < z

   1. Initial program 66.6%

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

      1. lift-/.f64 N/A

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

      2. lift-*.f64 N/A

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

      3. associate-/l* N/A

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

      4. *-commutative N/A

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

      5. lower-*.f64 N/A

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

      6. lower-/.f64 99.9

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

   4. Applied rewrites 99.9%

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

   5. Taylor expanded in z around inf

      \[\leadsto \color{blue}{1} \cdot x \]
   6. Step-by-step derivation

   7. Applied rewrites 72.1%

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

   if -4.5999999999999996e134 < z < -1.85000000000000007e-33

   1. Initial program 96.6%

      \[\frac{x \cdot \left(y - z\right)}{t - z} \]
   2. Add Preprocessing

   3. Taylor expanded in t around inf

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

      1. associate-/l* N/A

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

      2. *-commutative N/A

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

      3. lower-*.f64 N/A

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

      4. lower-/.f64 N/A

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

      5. lower--.f64 62.3

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

   5. Applied rewrites 62.3%

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

   6. Taylor expanded in y around 0

      \[\leadsto \frac{-1 \cdot z}{t} \cdot x \]
   7. Step-by-step derivation

   8. Applied rewrites 32.0%

      \[\leadsto \frac{-z}{t} \cdot x \]

   9. Taylor expanded in y around 0

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

   11. Applied rewrites 62.3%

       \[\leadsto \frac{y - z}{t} \cdot x \]

   if -1.85000000000000007e-33 < z < -1.01999999999999994e-60 or 2.49999999999999982e-40 < z < 1.4e138

   1. Initial program 91.0%

      \[\frac{x \cdot \left(y - z\right)}{t - z} \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0

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

      1. mul-1-neg N/A

         \[\leadsto \color{blue}{\mathsf{neg}\left(\frac{x \cdot \left(y - z\right)}{z}\right)} \]

      2. associate-/l* N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{x \cdot \frac{y - z}{z}}\right) \]

      3. *-commutative N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{\frac{y - z}{z} \cdot x}\right) \]

      4. distribute-lft-neg-in N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(\frac{y - z}{z}\right)\right) \cdot x} \]

      5. lower-*.f64 N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(\frac{y - z}{z}\right)\right) \cdot x} \]

      6. distribute-neg-frac N/A

         \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(\left(y - z\right)\right)}{z}} \cdot x \]

      7. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(\left(y - z\right)\right)}{z}} \cdot x \]

      8. *-lft-identity N/A

         \[\leadsto \frac{\mathsf{neg}\left(\left(y - \color{blue}{1 \cdot z}\right)\right)}{z} \cdot x \]

      9. metadata-eval N/A

         \[\leadsto \frac{\mathsf{neg}\left(\left(y - \color{blue}{\left(\mathsf{neg}\left(-1\right)\right)} \cdot z\right)\right)}{z} \cdot x \]

      10. fp-cancel-sign-sub-inv N/A

          \[\leadsto \frac{\mathsf{neg}\left(\color{blue}{\left(y + -1 \cdot z\right)}\right)}{z} \cdot x \]

      11. +-commutative N/A

          \[\leadsto \frac{\mathsf{neg}\left(\color{blue}{\left(-1 \cdot z + y\right)}\right)}{z} \cdot x \]

      12. distribute-neg-in N/A

          \[\leadsto \frac{\color{blue}{\left(\mathsf{neg}\left(-1 \cdot z\right)\right) + \left(\mathsf{neg}\left(y\right)\right)}}{z} \cdot x \]

      13. mul-1-neg N/A

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

      14. remove-double-neg N/A

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

      15. mul-1-neg N/A

          \[\leadsto \frac{z + \color{blue}{-1 \cdot y}}{z} \cdot x \]

      16. metadata-eval N/A

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

      17. fp-cancel-sub-sign-inv N/A

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

      18. *-lft-identity N/A

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

      19. lower--.f64 70.0

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

   5. Applied rewrites 70.0%

      \[\leadsto \color{blue}{\frac{z - y}{z} \cdot x} \]
   6. Step-by-step derivation

   7. Applied rewrites 66.2%

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

   if -1.01999999999999994e-60 < z < 2.49999999999999982e-40

   1. Initial program 90.5%

      \[\frac{x \cdot \left(y - z\right)}{t - z} \]
   2. Add Preprocessing

   3. Taylor expanded in t around inf

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

      1. associate-/l* N/A

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

      2. *-commutative N/A

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

      3. lower-*.f64 N/A

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

      4. lower-/.f64 N/A

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

      5. lower--.f64 81.9

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

   5. Applied rewrites 81.9%

      \[\leadsto \color{blue}{\frac{y - z}{t} \cdot x} \]
   6. Step-by-step derivation

   7. Applied rewrites 85.7%

      \[\leadsto \frac{x}{t} \cdot \color{blue}{\left(y - z\right)} \]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 3: 72.9% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{z}{t - z} \cdot \left(-x\right)\\ \mathbf{if}\;z \leq -8 \cdot 10^{-65}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 1.75 \cdot 10^{-40}:\\ \;\;\;\;\frac{x}{t} \cdot \left(y - z\right)\\ \mathbf{elif}\;z \leq 3.8 \cdot 10^{+57}:\\ \;\;\;\;\frac{z - y}{z} \cdot x\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (* (/ z (- t z)) (- x))))
   (if (<= z -8e-65)
     t_1
     (if (<= z 1.75e-40)
       (* (/ x t) (- y z))
       (if (<= z 3.8e+57) (* (/ (- z y) z) x) t_1)))))

C

double code(double x, double y, double z, double t) {
	double t_1 = (z / (t - z)) * -x;
	double tmp;
	if (z <= -8e-65) {
		tmp = t_1;
	} else if (z <= 1.75e-40) {
		tmp = (x / t) * (y - z);
	} else if (z <= 3.8e+57) {
		tmp = ((z - y) / z) * x;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (z / (t - z)) * -x
    if (z <= (-8d-65)) then
        tmp = t_1
    else if (z <= 1.75d-40) then
        tmp = (x / t) * (y - z)
    else if (z <= 3.8d+57) then
        tmp = ((z - y) / z) * x
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = (z / (t - z)) * -x;
	double tmp;
	if (z <= -8e-65) {
		tmp = t_1;
	} else if (z <= 1.75e-40) {
		tmp = (x / t) * (y - z);
	} else if (z <= 3.8e+57) {
		tmp = ((z - y) / z) * x;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = (z / (t - z)) * -x
	tmp = 0
	if z <= -8e-65:
		tmp = t_1
	elif z <= 1.75e-40:
		tmp = (x / t) * (y - z)
	elif z <= 3.8e+57:
		tmp = ((z - y) / z) * x
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(Float64(z / Float64(t - z)) * Float64(-x))
	tmp = 0.0
	if (z <= -8e-65)
		tmp = t_1;
	elseif (z <= 1.75e-40)
		tmp = Float64(Float64(x / t) * Float64(y - z));
	elseif (z <= 3.8e+57)
		tmp = Float64(Float64(Float64(z - y) / z) * x);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = (z / (t - z)) * -x;
	tmp = 0.0;
	if (z <= -8e-65)
		tmp = t_1;
	elseif (z <= 1.75e-40)
		tmp = (x / t) * (y - z);
	elseif (z <= 3.8e+57)
		tmp = ((z - y) / z) * x;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(z / N[(t - z), $MachinePrecision]), $MachinePrecision] * (-x)), $MachinePrecision]}, If[LessEqual[z, -8e-65], t$95$1, If[LessEqual[z, 1.75e-40], N[(N[(x / t), $MachinePrecision] * N[(y - z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.8e+57], N[(N[(N[(z - y), $MachinePrecision] / z), $MachinePrecision] * x), $MachinePrecision], t$95$1]]]]

Derivation

1. Split input into 3 regimes

2. if z < -7.99999999999999939e-65 or 3.7999999999999999e57 < z

   1. Initial program 77.6%

      \[\frac{x \cdot \left(y - z\right)}{t - z} \]
   2. Add Preprocessing

   3. Taylor expanded in y around 0

      \[\leadsto \color{blue}{-1 \cdot \frac{x \cdot z}{t - z}} \]
   4. Step-by-step derivation

      1. mul-1-neg N/A

         \[\leadsto \color{blue}{\mathsf{neg}\left(\frac{x \cdot z}{t - z}\right)} \]

      2. associate-/l* N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{x \cdot \frac{z}{t - z}}\right) \]

      3. *-commutative N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{\frac{z}{t - z} \cdot x}\right) \]

      4. distribute-rgt-neg-in N/A

         \[\leadsto \color{blue}{\frac{z}{t - z} \cdot \left(\mathsf{neg}\left(x\right)\right)} \]

      5. mul-1-neg N/A

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

      6. lower-*.f64 N/A

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

      7. lower-/.f64 N/A

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

      8. lower--.f64 N/A

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

      9. mul-1-neg N/A

         \[\leadsto \frac{z}{t - z} \cdot \color{blue}{\left(\mathsf{neg}\left(x\right)\right)} \]

      10. lower-neg.f64 78.4

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

   5. Applied rewrites 78.4%

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

   if -7.99999999999999939e-65 < z < 1.7500000000000001e-40

   1. Initial program 90.4%

      \[\frac{x \cdot \left(y - z\right)}{t - z} \]
   2. Add Preprocessing

   3. Taylor expanded in t around inf

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

      1. associate-/l* N/A

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

      2. *-commutative N/A

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

      3. lower-*.f64 N/A

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

      4. lower-/.f64 N/A

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

      5. lower--.f64 81.7

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

   5. Applied rewrites 81.7%

      \[\leadsto \color{blue}{\frac{y - z}{t} \cdot x} \]
   6. Step-by-step derivation

   7. Applied rewrites 85.6%

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

   if 1.7500000000000001e-40 < z < 3.7999999999999999e57

   1. Initial program 91.0%

      \[\frac{x \cdot \left(y - z\right)}{t - z} \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0

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

      1. mul-1-neg N/A

         \[\leadsto \color{blue}{\mathsf{neg}\left(\frac{x \cdot \left(y - z\right)}{z}\right)} \]

      2. associate-/l* N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{x \cdot \frac{y - z}{z}}\right) \]

      3. *-commutative N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{\frac{y - z}{z} \cdot x}\right) \]

      4. distribute-lft-neg-in N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(\frac{y - z}{z}\right)\right) \cdot x} \]

      5. lower-*.f64 N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(\frac{y - z}{z}\right)\right) \cdot x} \]

      6. distribute-neg-frac N/A

         \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(\left(y - z\right)\right)}{z}} \cdot x \]

      7. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(\left(y - z\right)\right)}{z}} \cdot x \]

      8. *-lft-identity N/A

         \[\leadsto \frac{\mathsf{neg}\left(\left(y - \color{blue}{1 \cdot z}\right)\right)}{z} \cdot x \]

      9. metadata-eval N/A

         \[\leadsto \frac{\mathsf{neg}\left(\left(y - \color{blue}{\left(\mathsf{neg}\left(-1\right)\right)} \cdot z\right)\right)}{z} \cdot x \]

      10. fp-cancel-sign-sub-inv N/A

          \[\leadsto \frac{\mathsf{neg}\left(\color{blue}{\left(y + -1 \cdot z\right)}\right)}{z} \cdot x \]

      11. +-commutative N/A

          \[\leadsto \frac{\mathsf{neg}\left(\color{blue}{\left(-1 \cdot z + y\right)}\right)}{z} \cdot x \]

      12. distribute-neg-in N/A

          \[\leadsto \frac{\color{blue}{\left(\mathsf{neg}\left(-1 \cdot z\right)\right) + \left(\mathsf{neg}\left(y\right)\right)}}{z} \cdot x \]

      13. mul-1-neg N/A

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

      14. remove-double-neg N/A

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

      15. mul-1-neg N/A

          \[\leadsto \frac{z + \color{blue}{-1 \cdot y}}{z} \cdot x \]

      16. metadata-eval N/A

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

      17. fp-cancel-sub-sign-inv N/A

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

      18. *-lft-identity N/A

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

      19. lower--.f64 73.7

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

   5. Applied rewrites 73.7%

      \[\leadsto \color{blue}{\frac{z - y}{z} \cdot x} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 4: 65.6% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -2.9 \cdot 10^{+67}:\\ \;\;\;\;1 \cdot x\\ \mathbf{elif}\;z \leq 4.6 \cdot 10^{+39}:\\ \;\;\;\;\frac{x}{t} \cdot \left(y - z\right)\\ \mathbf{elif}\;z \leq 6 \cdot 10^{+75}:\\ \;\;\;\;\frac{-y}{z} \cdot x\\ \mathbf{else}:\\ \;\;\;\;1 \cdot x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= z -2.9e+67)
   (* 1.0 x)
   (if (<= z 4.6e+39)
     (* (/ x t) (- y z))
     (if (<= z 6e+75) (* (/ (- y) z) x) (* 1.0 x)))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (z <= -2.9e+67) {
		tmp = 1.0 * x;
	} else if (z <= 4.6e+39) {
		tmp = (x / t) * (y - z);
	} else if (z <= 6e+75) {
		tmp = (-y / z) * x;
	} else {
		tmp = 1.0 * x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: tmp
    if (z <= (-2.9d+67)) then
        tmp = 1.0d0 * x
    else if (z <= 4.6d+39) then
        tmp = (x / t) * (y - z)
    else if (z <= 6d+75) then
        tmp = (-y / z) * x
    else
        tmp = 1.0d0 * x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (z <= -2.9e+67) {
		tmp = 1.0 * x;
	} else if (z <= 4.6e+39) {
		tmp = (x / t) * (y - z);
	} else if (z <= 6e+75) {
		tmp = (-y / z) * x;
	} else {
		tmp = 1.0 * x;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if z <= -2.9e+67:
		tmp = 1.0 * x
	elif z <= 4.6e+39:
		tmp = (x / t) * (y - z)
	elif z <= 6e+75:
		tmp = (-y / z) * x
	else:
		tmp = 1.0 * x
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (z <= -2.9e+67)
		tmp = Float64(1.0 * x);
	elseif (z <= 4.6e+39)
		tmp = Float64(Float64(x / t) * Float64(y - z));
	elseif (z <= 6e+75)
		tmp = Float64(Float64(Float64(-y) / z) * x);
	else
		tmp = Float64(1.0 * x);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (z <= -2.9e+67)
		tmp = 1.0 * x;
	elseif (z <= 4.6e+39)
		tmp = (x / t) * (y - z);
	elseif (z <= 6e+75)
		tmp = (-y / z) * x;
	else
		tmp = 1.0 * x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[z, -2.9e+67], N[(1.0 * x), $MachinePrecision], If[LessEqual[z, 4.6e+39], N[(N[(x / t), $MachinePrecision] * N[(y - z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 6e+75], N[(N[((-y) / z), $MachinePrecision] * x), $MachinePrecision], N[(1.0 * x), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if z < -2.90000000000000023e67 or 6e75 < z

   1. Initial program 71.8%

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

      1. lift-/.f64 N/A

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

      2. lift-*.f64 N/A

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

      3. associate-/l* N/A

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

      4. *-commutative N/A

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

      5. lower-*.f64 N/A

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

      6. lower-/.f64 99.9

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

   4. Applied rewrites 99.9%

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

   5. Taylor expanded in z around inf

      \[\leadsto \color{blue}{1} \cdot x \]
   6. Step-by-step derivation

   7. Applied rewrites 67.6%

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

   if -2.90000000000000023e67 < z < 4.60000000000000024e39

   1. Initial program 91.2%

      \[\frac{x \cdot \left(y - z\right)}{t - z} \]
   2. Add Preprocessing

   3. Taylor expanded in t around inf

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

      1. associate-/l* N/A

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

      2. *-commutative N/A

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

      3. lower-*.f64 N/A

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

      4. lower-/.f64 N/A

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

      5. lower--.f64 72.8

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

   5. Applied rewrites 72.8%

      \[\leadsto \color{blue}{\frac{y - z}{t} \cdot x} \]
   6. Step-by-step derivation

   7. Applied rewrites 74.3%

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

   if 4.60000000000000024e39 < z < 6e75

   1. Initial program 92.1%

      \[\frac{x \cdot \left(y - z\right)}{t - z} \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0

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

      1. mul-1-neg N/A

         \[\leadsto \color{blue}{\mathsf{neg}\left(\frac{x \cdot \left(y - z\right)}{z}\right)} \]

      2. associate-/l* N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{x \cdot \frac{y - z}{z}}\right) \]

      3. *-commutative N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{\frac{y - z}{z} \cdot x}\right) \]

      4. distribute-lft-neg-in N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(\frac{y - z}{z}\right)\right) \cdot x} \]

      5. lower-*.f64 N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(\frac{y - z}{z}\right)\right) \cdot x} \]

      6. distribute-neg-frac N/A

         \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(\left(y - z\right)\right)}{z}} \cdot x \]

      7. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(\left(y - z\right)\right)}{z}} \cdot x \]

      8. *-lft-identity N/A

         \[\leadsto \frac{\mathsf{neg}\left(\left(y - \color{blue}{1 \cdot z}\right)\right)}{z} \cdot x \]

      9. metadata-eval N/A

         \[\leadsto \frac{\mathsf{neg}\left(\left(y - \color{blue}{\left(\mathsf{neg}\left(-1\right)\right)} \cdot z\right)\right)}{z} \cdot x \]

      10. fp-cancel-sign-sub-inv N/A

          \[\leadsto \frac{\mathsf{neg}\left(\color{blue}{\left(y + -1 \cdot z\right)}\right)}{z} \cdot x \]

      11. +-commutative N/A

          \[\leadsto \frac{\mathsf{neg}\left(\color{blue}{\left(-1 \cdot z + y\right)}\right)}{z} \cdot x \]

      12. distribute-neg-in N/A

          \[\leadsto \frac{\color{blue}{\left(\mathsf{neg}\left(-1 \cdot z\right)\right) + \left(\mathsf{neg}\left(y\right)\right)}}{z} \cdot x \]

      13. mul-1-neg N/A

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

      14. remove-double-neg N/A

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

      15. mul-1-neg N/A

          \[\leadsto \frac{z + \color{blue}{-1 \cdot y}}{z} \cdot x \]

      16. metadata-eval N/A

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

      17. fp-cancel-sub-sign-inv N/A

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

      18. *-lft-identity N/A

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

      19. lower--.f64 64.1

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

   5. Applied rewrites 64.1%

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

   6. Taylor expanded in y around inf

      \[\leadsto \frac{-1 \cdot y}{z} \cdot x \]
   7. Step-by-step derivation

   8. Applied rewrites 68.5%

      \[\leadsto \frac{-y}{z} \cdot x \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 5: 66.3% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -4.6 \cdot 10^{+134}:\\ \;\;\;\;1 \cdot x\\ \mathbf{elif}\;z \leq 4.6 \cdot 10^{+39}:\\ \;\;\;\;\frac{y - z}{t} \cdot x\\ \mathbf{elif}\;z \leq 6 \cdot 10^{+75}:\\ \;\;\;\;\frac{-y}{z} \cdot x\\ \mathbf{else}:\\ \;\;\;\;1 \cdot x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= z -4.6e+134)
   (* 1.0 x)
   (if (<= z 4.6e+39)
     (* (/ (- y z) t) x)
     (if (<= z 6e+75) (* (/ (- y) z) x) (* 1.0 x)))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (z <= -4.6e+134) {
		tmp = 1.0 * x;
	} else if (z <= 4.6e+39) {
		tmp = ((y - z) / t) * x;
	} else if (z <= 6e+75) {
		tmp = (-y / z) * x;
	} else {
		tmp = 1.0 * x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: tmp
    if (z <= (-4.6d+134)) then
        tmp = 1.0d0 * x
    else if (z <= 4.6d+39) then
        tmp = ((y - z) / t) * x
    else if (z <= 6d+75) then
        tmp = (-y / z) * x
    else
        tmp = 1.0d0 * x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (z <= -4.6e+134) {
		tmp = 1.0 * x;
	} else if (z <= 4.6e+39) {
		tmp = ((y - z) / t) * x;
	} else if (z <= 6e+75) {
		tmp = (-y / z) * x;
	} else {
		tmp = 1.0 * x;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if z <= -4.6e+134:
		tmp = 1.0 * x
	elif z <= 4.6e+39:
		tmp = ((y - z) / t) * x
	elif z <= 6e+75:
		tmp = (-y / z) * x
	else:
		tmp = 1.0 * x
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (z <= -4.6e+134)
		tmp = Float64(1.0 * x);
	elseif (z <= 4.6e+39)
		tmp = Float64(Float64(Float64(y - z) / t) * x);
	elseif (z <= 6e+75)
		tmp = Float64(Float64(Float64(-y) / z) * x);
	else
		tmp = Float64(1.0 * x);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (z <= -4.6e+134)
		tmp = 1.0 * x;
	elseif (z <= 4.6e+39)
		tmp = ((y - z) / t) * x;
	elseif (z <= 6e+75)
		tmp = (-y / z) * x;
	else
		tmp = 1.0 * x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[z, -4.6e+134], N[(1.0 * x), $MachinePrecision], If[LessEqual[z, 4.6e+39], N[(N[(N[(y - z), $MachinePrecision] / t), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[z, 6e+75], N[(N[((-y) / z), $MachinePrecision] * x), $MachinePrecision], N[(1.0 * x), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if z < -4.5999999999999996e134 or 6e75 < z

   1. Initial program 69.3%

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

      1. lift-/.f64 N/A

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

      2. lift-*.f64 N/A

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

      3. associate-/l* N/A

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

      4. *-commutative N/A

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

      5. lower-*.f64 N/A

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

      6. lower-/.f64 99.9

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

   4. Applied rewrites 99.9%

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

   5. Taylor expanded in z around inf

      \[\leadsto \color{blue}{1} \cdot x \]
   6. Step-by-step derivation

   7. Applied rewrites 70.0%

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

   if -4.5999999999999996e134 < z < 4.60000000000000024e39

   1. Initial program 91.7%

      \[\frac{x \cdot \left(y - z\right)}{t - z} \]
   2. Add Preprocessing

   3. Taylor expanded in t around inf

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

      1. associate-/l* N/A

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

      2. *-commutative N/A

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

      3. lower-*.f64 N/A

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

      4. lower-/.f64 N/A

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

      5. lower--.f64 71.7

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

   5. Applied rewrites 71.7%

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

   6. Taylor expanded in y around 0

      \[\leadsto \frac{-1 \cdot z}{t} \cdot x \]
   7. Step-by-step derivation

   8. Applied rewrites 25.0%

      \[\leadsto \frac{-z}{t} \cdot x \]

   9. Taylor expanded in y around 0

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

   11. Applied rewrites 71.7%

       \[\leadsto \frac{y - z}{t} \cdot x \]

   if 4.60000000000000024e39 < z < 6e75

   1. Initial program 92.1%

      \[\frac{x \cdot \left(y - z\right)}{t - z} \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0

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

      1. mul-1-neg N/A

         \[\leadsto \color{blue}{\mathsf{neg}\left(\frac{x \cdot \left(y - z\right)}{z}\right)} \]

      2. associate-/l* N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{x \cdot \frac{y - z}{z}}\right) \]

      3. *-commutative N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{\frac{y - z}{z} \cdot x}\right) \]

      4. distribute-lft-neg-in N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(\frac{y - z}{z}\right)\right) \cdot x} \]

      5. lower-*.f64 N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(\frac{y - z}{z}\right)\right) \cdot x} \]

      6. distribute-neg-frac N/A

         \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(\left(y - z\right)\right)}{z}} \cdot x \]

      7. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(\left(y - z\right)\right)}{z}} \cdot x \]

      8. *-lft-identity N/A

         \[\leadsto \frac{\mathsf{neg}\left(\left(y - \color{blue}{1 \cdot z}\right)\right)}{z} \cdot x \]

      9. metadata-eval N/A

         \[\leadsto \frac{\mathsf{neg}\left(\left(y - \color{blue}{\left(\mathsf{neg}\left(-1\right)\right)} \cdot z\right)\right)}{z} \cdot x \]

      10. fp-cancel-sign-sub-inv N/A

          \[\leadsto \frac{\mathsf{neg}\left(\color{blue}{\left(y + -1 \cdot z\right)}\right)}{z} \cdot x \]

      11. +-commutative N/A

          \[\leadsto \frac{\mathsf{neg}\left(\color{blue}{\left(-1 \cdot z + y\right)}\right)}{z} \cdot x \]

      12. distribute-neg-in N/A

          \[\leadsto \frac{\color{blue}{\left(\mathsf{neg}\left(-1 \cdot z\right)\right) + \left(\mathsf{neg}\left(y\right)\right)}}{z} \cdot x \]

      13. mul-1-neg N/A

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

      14. remove-double-neg N/A

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

      15. mul-1-neg N/A

          \[\leadsto \frac{z + \color{blue}{-1 \cdot y}}{z} \cdot x \]

      16. metadata-eval N/A

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

      17. fp-cancel-sub-sign-inv N/A

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

      18. *-lft-identity N/A

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

      19. lower--.f64 64.1

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

   5. Applied rewrites 64.1%

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

   6. Taylor expanded in y around inf

      \[\leadsto \frac{-1 \cdot y}{z} \cdot x \]
   7. Step-by-step derivation

   8. Applied rewrites 68.5%

      \[\leadsto \frac{-y}{z} \cdot x \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 6: 59.0% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -8.5 \cdot 10^{-65}:\\ \;\;\;\;1 \cdot x\\ \mathbf{elif}\;z \leq 4.5 \cdot 10^{-19}:\\ \;\;\;\;\frac{x}{t} \cdot y\\ \mathbf{elif}\;z \leq 6 \cdot 10^{+75}:\\ \;\;\;\;\frac{-y}{z} \cdot x\\ \mathbf{else}:\\ \;\;\;\;1 \cdot x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= z -8.5e-65)
   (* 1.0 x)
   (if (<= z 4.5e-19)
     (* (/ x t) y)
     (if (<= z 6e+75) (* (/ (- y) z) x) (* 1.0 x)))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (z <= -8.5e-65) {
		tmp = 1.0 * x;
	} else if (z <= 4.5e-19) {
		tmp = (x / t) * y;
	} else if (z <= 6e+75) {
		tmp = (-y / z) * x;
	} else {
		tmp = 1.0 * x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: tmp
    if (z <= (-8.5d-65)) then
        tmp = 1.0d0 * x
    else if (z <= 4.5d-19) then
        tmp = (x / t) * y
    else if (z <= 6d+75) then
        tmp = (-y / z) * x
    else
        tmp = 1.0d0 * x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (z <= -8.5e-65) {
		tmp = 1.0 * x;
	} else if (z <= 4.5e-19) {
		tmp = (x / t) * y;
	} else if (z <= 6e+75) {
		tmp = (-y / z) * x;
	} else {
		tmp = 1.0 * x;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if z <= -8.5e-65:
		tmp = 1.0 * x
	elif z <= 4.5e-19:
		tmp = (x / t) * y
	elif z <= 6e+75:
		tmp = (-y / z) * x
	else:
		tmp = 1.0 * x
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (z <= -8.5e-65)
		tmp = Float64(1.0 * x);
	elseif (z <= 4.5e-19)
		tmp = Float64(Float64(x / t) * y);
	elseif (z <= 6e+75)
		tmp = Float64(Float64(Float64(-y) / z) * x);
	else
		tmp = Float64(1.0 * x);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (z <= -8.5e-65)
		tmp = 1.0 * x;
	elseif (z <= 4.5e-19)
		tmp = (x / t) * y;
	elseif (z <= 6e+75)
		tmp = (-y / z) * x;
	else
		tmp = 1.0 * x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[z, -8.5e-65], N[(1.0 * x), $MachinePrecision], If[LessEqual[z, 4.5e-19], N[(N[(x / t), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[z, 6e+75], N[(N[((-y) / z), $MachinePrecision] * x), $MachinePrecision], N[(1.0 * x), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if z < -8.5000000000000003e-65 or 6e75 < z

   1. Initial program 77.5%

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

      1. lift-/.f64 N/A

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

      2. lift-*.f64 N/A

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

      3. associate-/l* N/A

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

      4. *-commutative N/A

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

      5. lower-*.f64 N/A

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

      6. lower-/.f64 99.1

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

   4. Applied rewrites 99.1%

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

   5. Taylor expanded in z around inf

      \[\leadsto \color{blue}{1} \cdot x \]
   6. Step-by-step derivation

   7. Applied rewrites 60.6%

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

   if -8.5000000000000003e-65 < z < 4.50000000000000013e-19

   1. Initial program 90.0%

      \[\frac{x \cdot \left(y - z\right)}{t - z} \]
   2. Add Preprocessing

   3. Taylor expanded in z around 0

      \[\leadsto \color{blue}{\frac{x \cdot y}{t}} \]
   4. Step-by-step derivation

      1. lower-/.f64 N/A

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

      2. *-commutative N/A

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

      3. lower-*.f64 66.9

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

   5. Applied rewrites 66.9%

      \[\leadsto \color{blue}{\frac{y \cdot x}{t}} \]
   6. Step-by-step derivation

   7. Applied rewrites 70.7%

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

   if 4.50000000000000013e-19 < z < 6e75

   1. Initial program 90.8%

      \[\frac{x \cdot \left(y - z\right)}{t - z} \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0

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

      1. mul-1-neg N/A

         \[\leadsto \color{blue}{\mathsf{neg}\left(\frac{x \cdot \left(y - z\right)}{z}\right)} \]

      2. associate-/l* N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{x \cdot \frac{y - z}{z}}\right) \]

      3. *-commutative N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{\frac{y - z}{z} \cdot x}\right) \]

      4. distribute-lft-neg-in N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(\frac{y - z}{z}\right)\right) \cdot x} \]

      5. lower-*.f64 N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(\frac{y - z}{z}\right)\right) \cdot x} \]

      6. distribute-neg-frac N/A

         \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(\left(y - z\right)\right)}{z}} \cdot x \]

      7. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(\left(y - z\right)\right)}{z}} \cdot x \]

      8. *-lft-identity N/A

         \[\leadsto \frac{\mathsf{neg}\left(\left(y - \color{blue}{1 \cdot z}\right)\right)}{z} \cdot x \]

      9. metadata-eval N/A

         \[\leadsto \frac{\mathsf{neg}\left(\left(y - \color{blue}{\left(\mathsf{neg}\left(-1\right)\right)} \cdot z\right)\right)}{z} \cdot x \]

      10. fp-cancel-sign-sub-inv N/A

          \[\leadsto \frac{\mathsf{neg}\left(\color{blue}{\left(y + -1 \cdot z\right)}\right)}{z} \cdot x \]

      11. +-commutative N/A

          \[\leadsto \frac{\mathsf{neg}\left(\color{blue}{\left(-1 \cdot z + y\right)}\right)}{z} \cdot x \]

      12. distribute-neg-in N/A

          \[\leadsto \frac{\color{blue}{\left(\mathsf{neg}\left(-1 \cdot z\right)\right) + \left(\mathsf{neg}\left(y\right)\right)}}{z} \cdot x \]

      13. mul-1-neg N/A

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

      14. remove-double-neg N/A

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

      15. mul-1-neg N/A

          \[\leadsto \frac{z + \color{blue}{-1 \cdot y}}{z} \cdot x \]

      16. metadata-eval N/A

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

      17. fp-cancel-sub-sign-inv N/A

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

      18. *-lft-identity N/A

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

      19. lower--.f64 61.3

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

   5. Applied rewrites 61.3%

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

   6. Taylor expanded in y around inf

      \[\leadsto \frac{-1 \cdot y}{z} \cdot x \]
   7. Step-by-step derivation

   8. Applied rewrites 54.1%

      \[\leadsto \frac{-y}{z} \cdot x \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 7: 58.9% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -8.5 \cdot 10^{-65}:\\ \;\;\;\;1 \cdot x\\ \mathbf{elif}\;z \leq 4.5 \cdot 10^{-19}:\\ \;\;\;\;\frac{x}{t} \cdot y\\ \mathbf{elif}\;z \leq 5.8 \cdot 10^{+75}:\\ \;\;\;\;\left(-y\right) \cdot \frac{x}{z}\\ \mathbf{else}:\\ \;\;\;\;1 \cdot x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= z -8.5e-65)
   (* 1.0 x)
   (if (<= z 4.5e-19)
     (* (/ x t) y)
     (if (<= z 5.8e+75) (* (- y) (/ x z)) (* 1.0 x)))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (z <= -8.5e-65) {
		tmp = 1.0 * x;
	} else if (z <= 4.5e-19) {
		tmp = (x / t) * y;
	} else if (z <= 5.8e+75) {
		tmp = -y * (x / z);
	} else {
		tmp = 1.0 * x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: tmp
    if (z <= (-8.5d-65)) then
        tmp = 1.0d0 * x
    else if (z <= 4.5d-19) then
        tmp = (x / t) * y
    else if (z <= 5.8d+75) then
        tmp = -y * (x / z)
    else
        tmp = 1.0d0 * x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (z <= -8.5e-65) {
		tmp = 1.0 * x;
	} else if (z <= 4.5e-19) {
		tmp = (x / t) * y;
	} else if (z <= 5.8e+75) {
		tmp = -y * (x / z);
	} else {
		tmp = 1.0 * x;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if z <= -8.5e-65:
		tmp = 1.0 * x
	elif z <= 4.5e-19:
		tmp = (x / t) * y
	elif z <= 5.8e+75:
		tmp = -y * (x / z)
	else:
		tmp = 1.0 * x
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (z <= -8.5e-65)
		tmp = Float64(1.0 * x);
	elseif (z <= 4.5e-19)
		tmp = Float64(Float64(x / t) * y);
	elseif (z <= 5.8e+75)
		tmp = Float64(Float64(-y) * Float64(x / z));
	else
		tmp = Float64(1.0 * x);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (z <= -8.5e-65)
		tmp = 1.0 * x;
	elseif (z <= 4.5e-19)
		tmp = (x / t) * y;
	elseif (z <= 5.8e+75)
		tmp = -y * (x / z);
	else
		tmp = 1.0 * x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[z, -8.5e-65], N[(1.0 * x), $MachinePrecision], If[LessEqual[z, 4.5e-19], N[(N[(x / t), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[z, 5.8e+75], N[((-y) * N[(x / z), $MachinePrecision]), $MachinePrecision], N[(1.0 * x), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if z < -8.5000000000000003e-65 or 5.7999999999999997e75 < z

   1. Initial program 77.5%

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

      1. lift-/.f64 N/A

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

      2. lift-*.f64 N/A

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

      3. associate-/l* N/A

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

      4. *-commutative N/A

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

      5. lower-*.f64 N/A

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

      6. lower-/.f64 99.1

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

   4. Applied rewrites 99.1%

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

   5. Taylor expanded in z around inf

      \[\leadsto \color{blue}{1} \cdot x \]
   6. Step-by-step derivation

   7. Applied rewrites 60.6%

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

   if -8.5000000000000003e-65 < z < 4.50000000000000013e-19

   1. Initial program 90.0%

      \[\frac{x \cdot \left(y - z\right)}{t - z} \]
   2. Add Preprocessing

   3. Taylor expanded in z around 0

      \[\leadsto \color{blue}{\frac{x \cdot y}{t}} \]
   4. Step-by-step derivation

      1. lower-/.f64 N/A

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

      2. *-commutative N/A

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

      3. lower-*.f64 66.9

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

   5. Applied rewrites 66.9%

      \[\leadsto \color{blue}{\frac{y \cdot x}{t}} \]
   6. Step-by-step derivation

   7. Applied rewrites 70.7%

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

   if 4.50000000000000013e-19 < z < 5.7999999999999997e75

   1. Initial program 90.8%

      \[\frac{x \cdot \left(y - z\right)}{t - z} \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0

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

      1. mul-1-neg N/A

         \[\leadsto \color{blue}{\mathsf{neg}\left(\frac{x \cdot \left(y - z\right)}{z}\right)} \]

      2. associate-/l* N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{x \cdot \frac{y - z}{z}}\right) \]

      3. *-commutative N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{\frac{y - z}{z} \cdot x}\right) \]

      4. distribute-lft-neg-in N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(\frac{y - z}{z}\right)\right) \cdot x} \]

      5. lower-*.f64 N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(\frac{y - z}{z}\right)\right) \cdot x} \]

      6. distribute-neg-frac N/A

         \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(\left(y - z\right)\right)}{z}} \cdot x \]

      7. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(\left(y - z\right)\right)}{z}} \cdot x \]

      8. *-lft-identity N/A

         \[\leadsto \frac{\mathsf{neg}\left(\left(y - \color{blue}{1 \cdot z}\right)\right)}{z} \cdot x \]

      9. metadata-eval N/A

         \[\leadsto \frac{\mathsf{neg}\left(\left(y - \color{blue}{\left(\mathsf{neg}\left(-1\right)\right)} \cdot z\right)\right)}{z} \cdot x \]

      10. fp-cancel-sign-sub-inv N/A

          \[\leadsto \frac{\mathsf{neg}\left(\color{blue}{\left(y + -1 \cdot z\right)}\right)}{z} \cdot x \]

      11. +-commutative N/A

          \[\leadsto \frac{\mathsf{neg}\left(\color{blue}{\left(-1 \cdot z + y\right)}\right)}{z} \cdot x \]

      12. distribute-neg-in N/A

          \[\leadsto \frac{\color{blue}{\left(\mathsf{neg}\left(-1 \cdot z\right)\right) + \left(\mathsf{neg}\left(y\right)\right)}}{z} \cdot x \]

      13. mul-1-neg N/A

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

      14. remove-double-neg N/A

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

      15. mul-1-neg N/A

          \[\leadsto \frac{z + \color{blue}{-1 \cdot y}}{z} \cdot x \]

      16. metadata-eval N/A

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

      17. fp-cancel-sub-sign-inv N/A

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

      18. *-lft-identity N/A

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

      19. lower--.f64 61.3

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

   5. Applied rewrites 61.3%

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

   6. Taylor expanded in y around inf

      \[\leadsto \frac{-1 \cdot y}{z} \cdot x \]
   7. Step-by-step derivation

   8. Applied rewrites 54.1%

      \[\leadsto \frac{-y}{z} \cdot x \]
   9. Step-by-step derivation

   10. Applied rewrites 49.6%

       \[\leadsto \color{blue}{\left(-y\right) \cdot \frac{x}{z}} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 8: 89.5% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -1.05 \cdot 10^{+143} \lor \neg \left(z \leq 1.2 \cdot 10^{+83}\right):\\ \;\;\;\;\frac{z}{t - z} \cdot \left(-x\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{t - z} \cdot \left(y - z\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (or (<= z -1.05e+143) (not (<= z 1.2e+83)))
   (* (/ z (- t z)) (- x))
   (* (/ x (- t z)) (- y z))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if ((z <= -1.05e+143) || !(z <= 1.2e+83)) {
		tmp = (z / (t - z)) * -x;
	} else {
		tmp = (x / (t - z)) * (y - z);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: tmp
    if ((z <= (-1.05d+143)) .or. (.not. (z <= 1.2d+83))) then
        tmp = (z / (t - z)) * -x
    else
        tmp = (x / (t - z)) * (y - z)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if ((z <= -1.05e+143) || !(z <= 1.2e+83)) {
		tmp = (z / (t - z)) * -x;
	} else {
		tmp = (x / (t - z)) * (y - z);
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if (z <= -1.05e+143) or not (z <= 1.2e+83):
		tmp = (z / (t - z)) * -x
	else:
		tmp = (x / (t - z)) * (y - z)
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if ((z <= -1.05e+143) || !(z <= 1.2e+83))
		tmp = Float64(Float64(z / Float64(t - z)) * Float64(-x));
	else
		tmp = Float64(Float64(x / Float64(t - z)) * Float64(y - z));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if ((z <= -1.05e+143) || ~((z <= 1.2e+83)))
		tmp = (z / (t - z)) * -x;
	else
		tmp = (x / (t - z)) * (y - z);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[Or[LessEqual[z, -1.05e+143], N[Not[LessEqual[z, 1.2e+83]], $MachinePrecision]], N[(N[(z / N[(t - z), $MachinePrecision]), $MachinePrecision] * (-x)), $MachinePrecision], N[(N[(x / N[(t - z), $MachinePrecision]), $MachinePrecision] * N[(y - z), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if z < -1.04999999999999994e143 or 1.19999999999999996e83 < z

   1. Initial program 69.3%

      \[\frac{x \cdot \left(y - z\right)}{t - z} \]
   2. Add Preprocessing

   3. Taylor expanded in y around 0

      \[\leadsto \color{blue}{-1 \cdot \frac{x \cdot z}{t - z}} \]
   4. Step-by-step derivation

      1. mul-1-neg N/A

         \[\leadsto \color{blue}{\mathsf{neg}\left(\frac{x \cdot z}{t - z}\right)} \]

      2. associate-/l* N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{x \cdot \frac{z}{t - z}}\right) \]

      3. *-commutative N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{\frac{z}{t - z} \cdot x}\right) \]

      4. distribute-rgt-neg-in N/A

         \[\leadsto \color{blue}{\frac{z}{t - z} \cdot \left(\mathsf{neg}\left(x\right)\right)} \]

      5. mul-1-neg N/A

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

      6. lower-*.f64 N/A

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

      7. lower-/.f64 N/A

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

      8. lower--.f64 N/A

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

      9. mul-1-neg N/A

         \[\leadsto \frac{z}{t - z} \cdot \color{blue}{\left(\mathsf{neg}\left(x\right)\right)} \]

      10. lower-neg.f64 86.1

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

   5. Applied rewrites 86.1%

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

   if -1.04999999999999994e143 < z < 1.19999999999999996e83

   1. Initial program 91.3%

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

      1. lift-/.f64 N/A

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

      2. lift-*.f64 N/A

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

      3. *-commutative N/A

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

      4. associate-/l* N/A

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

      5. *-commutative N/A

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

      6. lower-*.f64 N/A

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

      7. lower-/.f64 94.6

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

   4. Applied rewrites 94.6%

      \[\leadsto \color{blue}{\frac{x}{t - z} \cdot \left(y - z\right)} \]
3. Recombined 2 regimes into one program.

4. Final simplification 91.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -1.05 \cdot 10^{+143} \lor \neg \left(z \leq 1.2 \cdot 10^{+83}\right):\\ \;\;\;\;\frac{z}{t - z} \cdot \left(-x\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{t - z} \cdot \left(y - z\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 9: 72.4% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -1.02 \cdot 10^{-60} \lor \neg \left(z \leq 1.75 \cdot 10^{-40}\right):\\ \;\;\;\;\frac{z - y}{z} \cdot x\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{t} \cdot \left(y - z\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (or (<= z -1.02e-60) (not (<= z 1.75e-40)))
   (* (/ (- z y) z) x)
   (* (/ x t) (- y z))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if ((z <= -1.02e-60) || !(z <= 1.75e-40)) {
		tmp = ((z - y) / z) * x;
	} else {
		tmp = (x / t) * (y - z);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: tmp
    if ((z <= (-1.02d-60)) .or. (.not. (z <= 1.75d-40))) then
        tmp = ((z - y) / z) * x
    else
        tmp = (x / t) * (y - z)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if ((z <= -1.02e-60) || !(z <= 1.75e-40)) {
		tmp = ((z - y) / z) * x;
	} else {
		tmp = (x / t) * (y - z);
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if (z <= -1.02e-60) or not (z <= 1.75e-40):
		tmp = ((z - y) / z) * x
	else:
		tmp = (x / t) * (y - z)
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if ((z <= -1.02e-60) || !(z <= 1.75e-40))
		tmp = Float64(Float64(Float64(z - y) / z) * x);
	else
		tmp = Float64(Float64(x / t) * Float64(y - z));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if ((z <= -1.02e-60) || ~((z <= 1.75e-40)))
		tmp = ((z - y) / z) * x;
	else
		tmp = (x / t) * (y - z);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[Or[LessEqual[z, -1.02e-60], N[Not[LessEqual[z, 1.75e-40]], $MachinePrecision]], N[(N[(N[(z - y), $MachinePrecision] / z), $MachinePrecision] * x), $MachinePrecision], N[(N[(x / t), $MachinePrecision] * N[(y - z), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if z < -1.01999999999999994e-60 or 1.7500000000000001e-40 < z

   1. Initial program 79.4%

      \[\frac{x \cdot \left(y - z\right)}{t - z} \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0

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

      1. mul-1-neg N/A

         \[\leadsto \color{blue}{\mathsf{neg}\left(\frac{x \cdot \left(y - z\right)}{z}\right)} \]

      2. associate-/l* N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{x \cdot \frac{y - z}{z}}\right) \]

      3. *-commutative N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{\frac{y - z}{z} \cdot x}\right) \]

      4. distribute-lft-neg-in N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(\frac{y - z}{z}\right)\right) \cdot x} \]

      5. lower-*.f64 N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(\frac{y - z}{z}\right)\right) \cdot x} \]

      6. distribute-neg-frac N/A

         \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(\left(y - z\right)\right)}{z}} \cdot x \]

      7. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(\left(y - z\right)\right)}{z}} \cdot x \]

      8. *-lft-identity N/A

         \[\leadsto \frac{\mathsf{neg}\left(\left(y - \color{blue}{1 \cdot z}\right)\right)}{z} \cdot x \]

      9. metadata-eval N/A

         \[\leadsto \frac{\mathsf{neg}\left(\left(y - \color{blue}{\left(\mathsf{neg}\left(-1\right)\right)} \cdot z\right)\right)}{z} \cdot x \]

      10. fp-cancel-sign-sub-inv N/A

          \[\leadsto \frac{\mathsf{neg}\left(\color{blue}{\left(y + -1 \cdot z\right)}\right)}{z} \cdot x \]

      11. +-commutative N/A

          \[\leadsto \frac{\mathsf{neg}\left(\color{blue}{\left(-1 \cdot z + y\right)}\right)}{z} \cdot x \]

      12. distribute-neg-in N/A

          \[\leadsto \frac{\color{blue}{\left(\mathsf{neg}\left(-1 \cdot z\right)\right) + \left(\mathsf{neg}\left(y\right)\right)}}{z} \cdot x \]

      13. mul-1-neg N/A

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

      14. remove-double-neg N/A

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

      15. mul-1-neg N/A

          \[\leadsto \frac{z + \color{blue}{-1 \cdot y}}{z} \cdot x \]

      16. metadata-eval N/A

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

      17. fp-cancel-sub-sign-inv N/A

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

      18. *-lft-identity N/A

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

      19. lower--.f64 69.1

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

   5. Applied rewrites 69.1%

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

   if -1.01999999999999994e-60 < z < 1.7500000000000001e-40

   1. Initial program 90.5%

      \[\frac{x \cdot \left(y - z\right)}{t - z} \]
   2. Add Preprocessing

   3. Taylor expanded in t around inf

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

      1. associate-/l* N/A

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

      2. *-commutative N/A

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

      3. lower-*.f64 N/A

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

      4. lower-/.f64 N/A

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

      5. lower--.f64 81.9

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

   5. Applied rewrites 81.9%

      \[\leadsto \color{blue}{\frac{y - z}{t} \cdot x} \]
   6. Step-by-step derivation

   7. Applied rewrites 85.7%

      \[\leadsto \frac{x}{t} \cdot \color{blue}{\left(y - z\right)} \]
3. Recombined 2 regimes into one program.

4. Final simplification 75.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -1.02 \cdot 10^{-60} \lor \neg \left(z \leq 1.75 \cdot 10^{-40}\right):\\ \;\;\;\;\frac{z - y}{z} \cdot x\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{t} \cdot \left(y - z\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 10: 59.3% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -8.5 \cdot 10^{-65} \lor \neg \left(z \leq 1.9 \cdot 10^{-24}\right):\\ \;\;\;\;1 \cdot x\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{t} \cdot y\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (or (<= z -8.5e-65) (not (<= z 1.9e-24))) (* 1.0 x) (* (/ x t) y)))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if ((z <= -8.5e-65) || !(z <= 1.9e-24)) {
		tmp = 1.0 * x;
	} else {
		tmp = (x / t) * y;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: tmp
    if ((z <= (-8.5d-65)) .or. (.not. (z <= 1.9d-24))) then
        tmp = 1.0d0 * x
    else
        tmp = (x / t) * y
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if ((z <= -8.5e-65) || !(z <= 1.9e-24)) {
		tmp = 1.0 * x;
	} else {
		tmp = (x / t) * y;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if (z <= -8.5e-65) or not (z <= 1.9e-24):
		tmp = 1.0 * x
	else:
		tmp = (x / t) * y
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if ((z <= -8.5e-65) || !(z <= 1.9e-24))
		tmp = Float64(1.0 * x);
	else
		tmp = Float64(Float64(x / t) * y);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if ((z <= -8.5e-65) || ~((z <= 1.9e-24)))
		tmp = 1.0 * x;
	else
		tmp = (x / t) * y;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[Or[LessEqual[z, -8.5e-65], N[Not[LessEqual[z, 1.9e-24]], $MachinePrecision]], N[(1.0 * x), $MachinePrecision], N[(N[(x / t), $MachinePrecision] * y), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if z < -8.5000000000000003e-65 or 1.90000000000000013e-24 < z

   1. Initial program 79.5%

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

      1. lift-/.f64 N/A

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

      2. lift-*.f64 N/A

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

      3. associate-/l* N/A

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

      4. *-commutative N/A

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

      5. lower-*.f64 N/A

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

      6. lower-/.f64 99.2

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

   4. Applied rewrites 99.2%

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

   5. Taylor expanded in z around inf

      \[\leadsto \color{blue}{1} \cdot x \]
   6. Step-by-step derivation

   7. Applied rewrites 55.1%

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

   if -8.5000000000000003e-65 < z < 1.90000000000000013e-24

   1. Initial program 89.9%

      \[\frac{x \cdot \left(y - z\right)}{t - z} \]
   2. Add Preprocessing

   3. Taylor expanded in z around 0

      \[\leadsto \color{blue}{\frac{x \cdot y}{t}} \]
   4. Step-by-step derivation

      1. lower-/.f64 N/A

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

      2. *-commutative N/A

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

      3. lower-*.f64 67.5

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

   5. Applied rewrites 67.5%

      \[\leadsto \color{blue}{\frac{y \cdot x}{t}} \]
   6. Step-by-step derivation

   7. Applied rewrites 71.3%

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

4. Final simplification 61.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -8.5 \cdot 10^{-65} \lor \neg \left(z \leq 1.9 \cdot 10^{-24}\right):\\ \;\;\;\;1 \cdot x\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{t} \cdot y\\ \end{array} \]
5. Add Preprocessing

Alternative 11: 35.1% accurate, 3.8× speedup

Math

\[\begin{array}{l} \\ 1 \cdot x \end{array} \]

FPCore

(FPCore (x y z t) :precision binary64 (* 1.0 x))

C

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

Fortran

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

Java

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

Python

def code(x, y, z, t):
	return 1.0 * x

Julia

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

MATLAB

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

Wolfram

code[x_, y_, z_, t_] := N[(1.0 * x), $MachinePrecision]

Derivation

1. Initial program 83.9%

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

   1. lift-/.f64 N/A

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

   2. lift-*.f64 N/A

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

   3. associate-/l* N/A

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

   4. *-commutative N/A

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

   5. lower-*.f64 N/A

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

   6. lower-/.f64 96.0

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

4. Applied rewrites 96.0%

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

5. Taylor expanded in z around inf

   \[\leadsto \color{blue}{1} \cdot x \]
6. Step-by-step derivation

7. Applied rewrites 36.1%

   \[\leadsto \color{blue}{1} \cdot x \]
8. Add Preprocessing

Developer Target 1: 97.0% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \frac{x}{\frac{t - z}{y - z}} \end{array} \]

FPCore

(FPCore (x y z t) :precision binary64 (/ x (/ (- t z) (- y z))))

C

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

Fortran

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

Java

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

Python

def code(x, y, z, t):
	return x / ((t - z) / (y - z))

Julia

function code(x, y, z, t)
	return Float64(x / Float64(Float64(t - z) / Float64(y - z)))
end

MATLAB

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

Wolfram

code[x_, y_, z_, t_] := N[(x / N[(N[(t - z), $MachinePrecision] / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Reproduce

herbie shell --seed 2024329 
(FPCore (x y z t)
  :name "Graphics.Rendering.Chart.Plot.AreaSpots:renderAreaSpots4D from Chart-1.5.3"
  :precision binary64

  :alt
  (! :herbie-platform default (/ x (/ (- t z) (- y z))))

  (/ (* x (- y z)) (- t z)))