Diagrams.Solve.Polynomial:cubForm from diagrams-solve-0.1, H

Percentage Accurate: 95.7% → 98.3%

Time: 12.2s

Alternatives: 17

Speedup: 0.7×

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

Specification

Math

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

FPCore

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

C

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

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 95.7% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 98.3% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{y \cdot z} \cdot 0.3333333333333333\\ \mathbf{if}\;z \cdot 3 \leq -2 \cdot 10^{+136}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \cdot 3 \leq 10^{-193}:\\ \;\;\;\;x + \frac{\frac{y - \frac{t}{y}}{z}}{-3}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (+ (- x (/ y (* z 3.0))) (* (/ t (* y z)) 0.3333333333333333))))
   (if (<= (* z 3.0) -2e+136)
     t_1
     (if (<= (* z 3.0) 1e-193) (+ x (/ (/ (- y (/ t y)) z) -3.0)) t_1))))

C

double code(double x, double y, double z, double t) {
	double t_1 = (x - (y / (z * 3.0))) + ((t / (y * z)) * 0.3333333333333333);
	double tmp;
	if ((z * 3.0) <= -2e+136) {
		tmp = t_1;
	} else if ((z * 3.0) <= 1e-193) {
		tmp = x + (((y - (t / y)) / z) / -3.0);
	} 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 = (x - (y / (z * 3.0d0))) + ((t / (y * z)) * 0.3333333333333333d0)
    if ((z * 3.0d0) <= (-2d+136)) then
        tmp = t_1
    else if ((z * 3.0d0) <= 1d-193) then
        tmp = x + (((y - (t / y)) / z) / (-3.0d0))
    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 = (x - (y / (z * 3.0))) + ((t / (y * z)) * 0.3333333333333333);
	double tmp;
	if ((z * 3.0) <= -2e+136) {
		tmp = t_1;
	} else if ((z * 3.0) <= 1e-193) {
		tmp = x + (((y - (t / y)) / z) / -3.0);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = (x - (y / (z * 3.0))) + ((t / (y * z)) * 0.3333333333333333)
	tmp = 0
	if (z * 3.0) <= -2e+136:
		tmp = t_1
	elif (z * 3.0) <= 1e-193:
		tmp = x + (((y - (t / y)) / z) / -3.0)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(Float64(x - Float64(y / Float64(z * 3.0))) + Float64(Float64(t / Float64(y * z)) * 0.3333333333333333))
	tmp = 0.0
	if (Float64(z * 3.0) <= -2e+136)
		tmp = t_1;
	elseif (Float64(z * 3.0) <= 1e-193)
		tmp = Float64(x + Float64(Float64(Float64(y - Float64(t / y)) / z) / -3.0));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = (x - (y / (z * 3.0))) + ((t / (y * z)) * 0.3333333333333333);
	tmp = 0.0;
	if ((z * 3.0) <= -2e+136)
		tmp = t_1;
	elseif ((z * 3.0) <= 1e-193)
		tmp = x + (((y - (t / y)) / z) / -3.0);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(t / N[(y * z), $MachinePrecision]), $MachinePrecision] * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(z * 3.0), $MachinePrecision], -2e+136], t$95$1, If[LessEqual[N[(z * 3.0), $MachinePrecision], 1e-193], N[(x + N[(N[(N[(y - N[(t / y), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision] / -3.0), $MachinePrecision]), $MachinePrecision], t$95$1]]]

Derivation

1. Split input into 2 regimes

2. if (*.f64 z #s(literal 3 binary64)) < -2.00000000000000012e136 or 1e-193 < (*.f64 z #s(literal 3 binary64))

   1. Initial program 99.8%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   if -2.00000000000000012e136 < (*.f64 z #s(literal 3 binary64)) < 1e-193

   1. Initial program 91.2%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 2: 80.0% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + \frac{y}{\frac{z}{-0.3333333333333333}}\\ \mathbf{if}\;z \cdot 3 \leq -2 \cdot 10^{+193}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \cdot 3 \leq -2 \cdot 10^{+154}:\\ \;\;\;\;\frac{\frac{t}{z}}{\frac{y}{0.3333333333333333}}\\ \mathbf{elif}\;z \cdot 3 \leq -5 \cdot 10^{+47}:\\ \;\;\;\;x + \frac{\frac{y}{-3}}{z}\\ \mathbf{elif}\;z \cdot 3 \leq 10^{+106}:\\ \;\;\;\;\frac{y - \frac{t}{y}}{z} \cdot -0.3333333333333333\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (+ x (/ y (/ z -0.3333333333333333)))))
   (if (<= (* z 3.0) -2e+193)
     t_1
     (if (<= (* z 3.0) -2e+154)
       (/ (/ t z) (/ y 0.3333333333333333))
       (if (<= (* z 3.0) -5e+47)
         (+ x (/ (/ y -3.0) z))
         (if (<= (* z 3.0) 1e+106)
           (* (/ (- y (/ t y)) z) -0.3333333333333333)
           t_1))))))

C

double code(double x, double y, double z, double t) {
	double t_1 = x + (y / (z / -0.3333333333333333));
	double tmp;
	if ((z * 3.0) <= -2e+193) {
		tmp = t_1;
	} else if ((z * 3.0) <= -2e+154) {
		tmp = (t / z) / (y / 0.3333333333333333);
	} else if ((z * 3.0) <= -5e+47) {
		tmp = x + ((y / -3.0) / z);
	} else if ((z * 3.0) <= 1e+106) {
		tmp = ((y - (t / y)) / z) * -0.3333333333333333;
	} 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 = x + (y / (z / (-0.3333333333333333d0)))
    if ((z * 3.0d0) <= (-2d+193)) then
        tmp = t_1
    else if ((z * 3.0d0) <= (-2d+154)) then
        tmp = (t / z) / (y / 0.3333333333333333d0)
    else if ((z * 3.0d0) <= (-5d+47)) then
        tmp = x + ((y / (-3.0d0)) / z)
    else if ((z * 3.0d0) <= 1d+106) then
        tmp = ((y - (t / y)) / z) * (-0.3333333333333333d0)
    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 = x + (y / (z / -0.3333333333333333));
	double tmp;
	if ((z * 3.0) <= -2e+193) {
		tmp = t_1;
	} else if ((z * 3.0) <= -2e+154) {
		tmp = (t / z) / (y / 0.3333333333333333);
	} else if ((z * 3.0) <= -5e+47) {
		tmp = x + ((y / -3.0) / z);
	} else if ((z * 3.0) <= 1e+106) {
		tmp = ((y - (t / y)) / z) * -0.3333333333333333;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = x + (y / (z / -0.3333333333333333))
	tmp = 0
	if (z * 3.0) <= -2e+193:
		tmp = t_1
	elif (z * 3.0) <= -2e+154:
		tmp = (t / z) / (y / 0.3333333333333333)
	elif (z * 3.0) <= -5e+47:
		tmp = x + ((y / -3.0) / z)
	elif (z * 3.0) <= 1e+106:
		tmp = ((y - (t / y)) / z) * -0.3333333333333333
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(x + Float64(y / Float64(z / -0.3333333333333333)))
	tmp = 0.0
	if (Float64(z * 3.0) <= -2e+193)
		tmp = t_1;
	elseif (Float64(z * 3.0) <= -2e+154)
		tmp = Float64(Float64(t / z) / Float64(y / 0.3333333333333333));
	elseif (Float64(z * 3.0) <= -5e+47)
		tmp = Float64(x + Float64(Float64(y / -3.0) / z));
	elseif (Float64(z * 3.0) <= 1e+106)
		tmp = Float64(Float64(Float64(y - Float64(t / y)) / z) * -0.3333333333333333);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = x + (y / (z / -0.3333333333333333));
	tmp = 0.0;
	if ((z * 3.0) <= -2e+193)
		tmp = t_1;
	elseif ((z * 3.0) <= -2e+154)
		tmp = (t / z) / (y / 0.3333333333333333);
	elseif ((z * 3.0) <= -5e+47)
		tmp = x + ((y / -3.0) / z);
	elseif ((z * 3.0) <= 1e+106)
		tmp = ((y - (t / y)) / z) * -0.3333333333333333;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(x + N[(y / N[(z / -0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(z * 3.0), $MachinePrecision], -2e+193], t$95$1, If[LessEqual[N[(z * 3.0), $MachinePrecision], -2e+154], N[(N[(t / z), $MachinePrecision] / N[(y / 0.3333333333333333), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(z * 3.0), $MachinePrecision], -5e+47], N[(x + N[(N[(y / -3.0), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(z * 3.0), $MachinePrecision], 1e+106], N[(N[(N[(y - N[(t / y), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision] * -0.3333333333333333), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 4 regimes

2. if (*.f64 z #s(literal 3 binary64)) < -2.00000000000000013e193 or 1.00000000000000009e106 < (*.f64 z #s(literal 3 binary64))

   1. Initial program 99.8%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   if -2.00000000000000013e193 < (*.f64 z #s(literal 3 binary64)) < -2.00000000000000007e154

   1. Initial program 99.3%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   12. Applied egg-rr 0

       \[\leadsto expr\]

   if -2.00000000000000007e154 < (*.f64 z #s(literal 3 binary64)) < -5.00000000000000022e47

   1. Initial program 99.6%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -5.00000000000000022e47 < (*.f64 z #s(literal 3 binary64)) < 1.00000000000000009e106

   1. Initial program 94.1%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 3: 97.6% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y}\\ \mathbf{if}\;t\_1 \leq -\infty:\\ \;\;\;\;x - \frac{y - \frac{t}{y}}{z \cdot 3}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (+ (- x (/ y (* z 3.0))) (/ t (* (* z 3.0) y)))))
   (if (<= t_1 (- INFINITY)) (- x (/ (- y (/ t y)) (* z 3.0))) t_1)))

C

double code(double x, double y, double z, double t) {
	double t_1 = (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y));
	double tmp;
	if (t_1 <= -((double) INFINITY)) {
		tmp = x - ((y - (t / y)) / (z * 3.0));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y));
	double tmp;
	if (t_1 <= -Double.POSITIVE_INFINITY) {
		tmp = x - ((y - (t / y)) / (z * 3.0));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y))
	tmp = 0
	if t_1 <= -math.inf:
		tmp = x - ((y - (t / y)) / (z * 3.0))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(Float64(x - Float64(y / Float64(z * 3.0))) + Float64(t / Float64(Float64(z * 3.0) * y)))
	tmp = 0.0
	if (t_1 <= Float64(-Inf))
		tmp = Float64(x - Float64(Float64(y - Float64(t / y)) / Float64(z * 3.0)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y));
	tmp = 0.0;
	if (t_1 <= -Inf)
		tmp = x - ((y - (t / y)) / (z * 3.0));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(t / N[(N[(z * 3.0), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, (-Infinity)], N[(x - N[(N[(y - N[(t / y), $MachinePrecision]), $MachinePrecision] / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]

Derivation

1. Split input into 2 regimes

2. if (+.f64 (-.f64 x (/.f64 y (*.f64 z #s(literal 3 binary64)))) (/.f64 t (*.f64 (*.f64 z #s(literal 3 binary64)) y))) < -inf.0

   1. Initial program 86.0%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   if -inf.0 < (+.f64 (-.f64 x (/.f64 y (*.f64 z #s(literal 3 binary64)))) (/.f64 t (*.f64 (*.f64 z #s(literal 3 binary64)) y)))

   1. Initial program 98.3%

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

Alternative 4: 62.4% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -5 \cdot 10^{+110}:\\ \;\;\;\;\frac{\frac{y}{-3}}{z}\\ \mathbf{elif}\;y \leq -3.4 \cdot 10^{+75}:\\ \;\;\;\;x\\ \mathbf{elif}\;y \leq -0.000118:\\ \;\;\;\;\frac{\frac{y}{z}}{-3}\\ \mathbf{elif}\;y \leq 4.2 \cdot 10^{-15}:\\ \;\;\;\;\frac{t}{z} \cdot \frac{0.3333333333333333}{y}\\ \mathbf{elif}\;y \leq 1.4 \cdot 10^{+109}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;\frac{y}{\frac{z}{-0.3333333333333333}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= y -5e+110)
   (/ (/ y -3.0) z)
   (if (<= y -3.4e+75)
     x
     (if (<= y -0.000118)
       (/ (/ y z) -3.0)
       (if (<= y 4.2e-15)
         (* (/ t z) (/ 0.3333333333333333 y))
         (if (<= y 1.4e+109) x (/ y (/ z -0.3333333333333333))))))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -5e+110) {
		tmp = (y / -3.0) / z;
	} else if (y <= -3.4e+75) {
		tmp = x;
	} else if (y <= -0.000118) {
		tmp = (y / z) / -3.0;
	} else if (y <= 4.2e-15) {
		tmp = (t / z) * (0.3333333333333333 / y);
	} else if (y <= 1.4e+109) {
		tmp = x;
	} else {
		tmp = y / (z / -0.3333333333333333);
	}
	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 (y <= (-5d+110)) then
        tmp = (y / (-3.0d0)) / z
    else if (y <= (-3.4d+75)) then
        tmp = x
    else if (y <= (-0.000118d0)) then
        tmp = (y / z) / (-3.0d0)
    else if (y <= 4.2d-15) then
        tmp = (t / z) * (0.3333333333333333d0 / y)
    else if (y <= 1.4d+109) then
        tmp = x
    else
        tmp = y / (z / (-0.3333333333333333d0))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -5e+110) {
		tmp = (y / -3.0) / z;
	} else if (y <= -3.4e+75) {
		tmp = x;
	} else if (y <= -0.000118) {
		tmp = (y / z) / -3.0;
	} else if (y <= 4.2e-15) {
		tmp = (t / z) * (0.3333333333333333 / y);
	} else if (y <= 1.4e+109) {
		tmp = x;
	} else {
		tmp = y / (z / -0.3333333333333333);
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if y <= -5e+110:
		tmp = (y / -3.0) / z
	elif y <= -3.4e+75:
		tmp = x
	elif y <= -0.000118:
		tmp = (y / z) / -3.0
	elif y <= 4.2e-15:
		tmp = (t / z) * (0.3333333333333333 / y)
	elif y <= 1.4e+109:
		tmp = x
	else:
		tmp = y / (z / -0.3333333333333333)
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (y <= -5e+110)
		tmp = Float64(Float64(y / -3.0) / z);
	elseif (y <= -3.4e+75)
		tmp = x;
	elseif (y <= -0.000118)
		tmp = Float64(Float64(y / z) / -3.0);
	elseif (y <= 4.2e-15)
		tmp = Float64(Float64(t / z) * Float64(0.3333333333333333 / y));
	elseif (y <= 1.4e+109)
		tmp = x;
	else
		tmp = Float64(y / Float64(z / -0.3333333333333333));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (y <= -5e+110)
		tmp = (y / -3.0) / z;
	elseif (y <= -3.4e+75)
		tmp = x;
	elseif (y <= -0.000118)
		tmp = (y / z) / -3.0;
	elseif (y <= 4.2e-15)
		tmp = (t / z) * (0.3333333333333333 / y);
	elseif (y <= 1.4e+109)
		tmp = x;
	else
		tmp = y / (z / -0.3333333333333333);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[y, -5e+110], N[(N[(y / -3.0), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[y, -3.4e+75], x, If[LessEqual[y, -0.000118], N[(N[(y / z), $MachinePrecision] / -3.0), $MachinePrecision], If[LessEqual[y, 4.2e-15], N[(N[(t / z), $MachinePrecision] * N[(0.3333333333333333 / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.4e+109], x, N[(y / N[(z / -0.3333333333333333), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

1. Split input into 5 regimes

2. if y < -4.99999999999999978e110

   1. Initial program 99.8%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   11. Applied egg-rr 0

       \[\leadsto expr\]

   if -4.99999999999999978e110 < y < -3.40000000000000011e75 or 4.19999999999999962e-15 < y < 1.4000000000000001e109

   1. Initial program 99.9%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -3.40000000000000011e75 < y < -1.18e-4

   1. Initial program 95.2%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   if -1.18e-4 < y < 4.19999999999999962e-15

   1. Initial program 93.5%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   12. Applied egg-rr 0

       \[\leadsto expr\]

   if 1.4000000000000001e109 < y

   1. Initial program 99.9%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]
3. Recombined 5 regimes into one program.
4. Add Preprocessing

Alternative 5: 60.3% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -1.3 \cdot 10^{+111}:\\ \;\;\;\;\frac{\frac{y}{-3}}{z}\\ \mathbf{elif}\;y \leq -3 \cdot 10^{+75}:\\ \;\;\;\;x\\ \mathbf{elif}\;y \leq -0.018:\\ \;\;\;\;\frac{\frac{y}{z}}{-3}\\ \mathbf{elif}\;y \leq 5.2 \cdot 10^{-17}:\\ \;\;\;\;t \cdot \frac{\frac{0.3333333333333333}{y}}{z}\\ \mathbf{elif}\;y \leq 1.25 \cdot 10^{+109}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;\frac{y}{\frac{z}{-0.3333333333333333}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= y -1.3e+111)
   (/ (/ y -3.0) z)
   (if (<= y -3e+75)
     x
     (if (<= y -0.018)
       (/ (/ y z) -3.0)
       (if (<= y 5.2e-17)
         (* t (/ (/ 0.3333333333333333 y) z))
         (if (<= y 1.25e+109) x (/ y (/ z -0.3333333333333333))))))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -1.3e+111) {
		tmp = (y / -3.0) / z;
	} else if (y <= -3e+75) {
		tmp = x;
	} else if (y <= -0.018) {
		tmp = (y / z) / -3.0;
	} else if (y <= 5.2e-17) {
		tmp = t * ((0.3333333333333333 / y) / z);
	} else if (y <= 1.25e+109) {
		tmp = x;
	} else {
		tmp = y / (z / -0.3333333333333333);
	}
	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 (y <= (-1.3d+111)) then
        tmp = (y / (-3.0d0)) / z
    else if (y <= (-3d+75)) then
        tmp = x
    else if (y <= (-0.018d0)) then
        tmp = (y / z) / (-3.0d0)
    else if (y <= 5.2d-17) then
        tmp = t * ((0.3333333333333333d0 / y) / z)
    else if (y <= 1.25d+109) then
        tmp = x
    else
        tmp = y / (z / (-0.3333333333333333d0))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -1.3e+111) {
		tmp = (y / -3.0) / z;
	} else if (y <= -3e+75) {
		tmp = x;
	} else if (y <= -0.018) {
		tmp = (y / z) / -3.0;
	} else if (y <= 5.2e-17) {
		tmp = t * ((0.3333333333333333 / y) / z);
	} else if (y <= 1.25e+109) {
		tmp = x;
	} else {
		tmp = y / (z / -0.3333333333333333);
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if y <= -1.3e+111:
		tmp = (y / -3.0) / z
	elif y <= -3e+75:
		tmp = x
	elif y <= -0.018:
		tmp = (y / z) / -3.0
	elif y <= 5.2e-17:
		tmp = t * ((0.3333333333333333 / y) / z)
	elif y <= 1.25e+109:
		tmp = x
	else:
		tmp = y / (z / -0.3333333333333333)
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (y <= -1.3e+111)
		tmp = Float64(Float64(y / -3.0) / z);
	elseif (y <= -3e+75)
		tmp = x;
	elseif (y <= -0.018)
		tmp = Float64(Float64(y / z) / -3.0);
	elseif (y <= 5.2e-17)
		tmp = Float64(t * Float64(Float64(0.3333333333333333 / y) / z));
	elseif (y <= 1.25e+109)
		tmp = x;
	else
		tmp = Float64(y / Float64(z / -0.3333333333333333));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (y <= -1.3e+111)
		tmp = (y / -3.0) / z;
	elseif (y <= -3e+75)
		tmp = x;
	elseif (y <= -0.018)
		tmp = (y / z) / -3.0;
	elseif (y <= 5.2e-17)
		tmp = t * ((0.3333333333333333 / y) / z);
	elseif (y <= 1.25e+109)
		tmp = x;
	else
		tmp = y / (z / -0.3333333333333333);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[y, -1.3e+111], N[(N[(y / -3.0), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[y, -3e+75], x, If[LessEqual[y, -0.018], N[(N[(y / z), $MachinePrecision] / -3.0), $MachinePrecision], If[LessEqual[y, 5.2e-17], N[(t * N[(N[(0.3333333333333333 / y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.25e+109], x, N[(y / N[(z / -0.3333333333333333), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

1. Split input into 5 regimes

2. if y < -1.2999999999999999e111

   1. Initial program 99.8%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   11. Applied egg-rr 0

       \[\leadsto expr\]

   if -1.2999999999999999e111 < y < -3e75 or 5.20000000000000006e-17 < y < 1.25e109

   1. Initial program 99.9%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -3e75 < y < -0.0179999999999999986

   1. Initial program 95.2%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   if -0.0179999999999999986 < y < 5.20000000000000006e-17

   1. Initial program 93.5%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   12. Applied egg-rr 0

       \[\leadsto expr\]

   if 1.25e109 < y

   1. Initial program 99.9%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]
3. Recombined 5 regimes into one program.
4. Add Preprocessing

Alternative 6: 87.6% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + \frac{t}{\left(z \cdot 3\right) \cdot y}\\ \mathbf{if}\;y \leq -0.022:\\ \;\;\;\;\frac{\frac{y}{z}}{-3} + x\\ \mathbf{elif}\;y \leq -1.65 \cdot 10^{-158}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;y \leq 4.2 \cdot 10^{-263}:\\ \;\;\;\;\frac{\frac{t}{z}}{\frac{y}{0.3333333333333333}}\\ \mathbf{elif}\;y \leq 2.6 \cdot 10^{-14}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;x + \frac{y}{\frac{z}{-0.3333333333333333}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (+ x (/ t (* (* z 3.0) y)))))
   (if (<= y -0.022)
     (+ (/ (/ y z) -3.0) x)
     (if (<= y -1.65e-158)
       t_1
       (if (<= y 4.2e-263)
         (/ (/ t z) (/ y 0.3333333333333333))
         (if (<= y 2.6e-14) t_1 (+ x (/ y (/ z -0.3333333333333333)))))))))

C

double code(double x, double y, double z, double t) {
	double t_1 = x + (t / ((z * 3.0) * y));
	double tmp;
	if (y <= -0.022) {
		tmp = ((y / z) / -3.0) + x;
	} else if (y <= -1.65e-158) {
		tmp = t_1;
	} else if (y <= 4.2e-263) {
		tmp = (t / z) / (y / 0.3333333333333333);
	} else if (y <= 2.6e-14) {
		tmp = t_1;
	} else {
		tmp = x + (y / (z / -0.3333333333333333));
	}
	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 + (t / ((z * 3.0d0) * y))
    if (y <= (-0.022d0)) then
        tmp = ((y / z) / (-3.0d0)) + x
    else if (y <= (-1.65d-158)) then
        tmp = t_1
    else if (y <= 4.2d-263) then
        tmp = (t / z) / (y / 0.3333333333333333d0)
    else if (y <= 2.6d-14) then
        tmp = t_1
    else
        tmp = x + (y / (z / (-0.3333333333333333d0)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = x + (t / ((z * 3.0) * y));
	double tmp;
	if (y <= -0.022) {
		tmp = ((y / z) / -3.0) + x;
	} else if (y <= -1.65e-158) {
		tmp = t_1;
	} else if (y <= 4.2e-263) {
		tmp = (t / z) / (y / 0.3333333333333333);
	} else if (y <= 2.6e-14) {
		tmp = t_1;
	} else {
		tmp = x + (y / (z / -0.3333333333333333));
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = x + (t / ((z * 3.0) * y))
	tmp = 0
	if y <= -0.022:
		tmp = ((y / z) / -3.0) + x
	elif y <= -1.65e-158:
		tmp = t_1
	elif y <= 4.2e-263:
		tmp = (t / z) / (y / 0.3333333333333333)
	elif y <= 2.6e-14:
		tmp = t_1
	else:
		tmp = x + (y / (z / -0.3333333333333333))
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(x + Float64(t / Float64(Float64(z * 3.0) * y)))
	tmp = 0.0
	if (y <= -0.022)
		tmp = Float64(Float64(Float64(y / z) / -3.0) + x);
	elseif (y <= -1.65e-158)
		tmp = t_1;
	elseif (y <= 4.2e-263)
		tmp = Float64(Float64(t / z) / Float64(y / 0.3333333333333333));
	elseif (y <= 2.6e-14)
		tmp = t_1;
	else
		tmp = Float64(x + Float64(y / Float64(z / -0.3333333333333333)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = x + (t / ((z * 3.0) * y));
	tmp = 0.0;
	if (y <= -0.022)
		tmp = ((y / z) / -3.0) + x;
	elseif (y <= -1.65e-158)
		tmp = t_1;
	elseif (y <= 4.2e-263)
		tmp = (t / z) / (y / 0.3333333333333333);
	elseif (y <= 2.6e-14)
		tmp = t_1;
	else
		tmp = x + (y / (z / -0.3333333333333333));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(x + N[(t / N[(N[(z * 3.0), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -0.022], N[(N[(N[(y / z), $MachinePrecision] / -3.0), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[y, -1.65e-158], t$95$1, If[LessEqual[y, 4.2e-263], N[(N[(t / z), $MachinePrecision] / N[(y / 0.3333333333333333), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.6e-14], t$95$1, N[(x + N[(y / N[(z / -0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

1. Split input into 4 regimes

2. if y < -0.021999999999999999

   1. Initial program 98.3%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   if -0.021999999999999999 < y < -1.6500000000000001e-158 or 4.20000000000000005e-263 < y < 2.59999999999999997e-14

   1. Initial program 97.7%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.6500000000000001e-158 < y < 4.20000000000000005e-263

   1. Initial program 85.7%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   12. Applied egg-rr 0

       \[\leadsto expr\]

   if 2.59999999999999997e-14 < y

   1. Initial program 99.9%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 7: 87.6% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + \frac{t}{y \cdot z} \cdot 0.3333333333333333\\ \mathbf{if}\;y \leq -0.021:\\ \;\;\;\;\frac{\frac{y}{z}}{-3} + x\\ \mathbf{elif}\;y \leq -9 \cdot 10^{-155}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;y \leq 2.55 \cdot 10^{-263}:\\ \;\;\;\;\frac{\frac{t}{z}}{\frac{y}{0.3333333333333333}}\\ \mathbf{elif}\;y \leq 6.5 \cdot 10^{-15}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;x + \frac{y}{\frac{z}{-0.3333333333333333}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (+ x (* (/ t (* y z)) 0.3333333333333333))))
   (if (<= y -0.021)
     (+ (/ (/ y z) -3.0) x)
     (if (<= y -9e-155)
       t_1
       (if (<= y 2.55e-263)
         (/ (/ t z) (/ y 0.3333333333333333))
         (if (<= y 6.5e-15) t_1 (+ x (/ y (/ z -0.3333333333333333)))))))))

C

double code(double x, double y, double z, double t) {
	double t_1 = x + ((t / (y * z)) * 0.3333333333333333);
	double tmp;
	if (y <= -0.021) {
		tmp = ((y / z) / -3.0) + x;
	} else if (y <= -9e-155) {
		tmp = t_1;
	} else if (y <= 2.55e-263) {
		tmp = (t / z) / (y / 0.3333333333333333);
	} else if (y <= 6.5e-15) {
		tmp = t_1;
	} else {
		tmp = x + (y / (z / -0.3333333333333333));
	}
	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 + ((t / (y * z)) * 0.3333333333333333d0)
    if (y <= (-0.021d0)) then
        tmp = ((y / z) / (-3.0d0)) + x
    else if (y <= (-9d-155)) then
        tmp = t_1
    else if (y <= 2.55d-263) then
        tmp = (t / z) / (y / 0.3333333333333333d0)
    else if (y <= 6.5d-15) then
        tmp = t_1
    else
        tmp = x + (y / (z / (-0.3333333333333333d0)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = x + ((t / (y * z)) * 0.3333333333333333);
	double tmp;
	if (y <= -0.021) {
		tmp = ((y / z) / -3.0) + x;
	} else if (y <= -9e-155) {
		tmp = t_1;
	} else if (y <= 2.55e-263) {
		tmp = (t / z) / (y / 0.3333333333333333);
	} else if (y <= 6.5e-15) {
		tmp = t_1;
	} else {
		tmp = x + (y / (z / -0.3333333333333333));
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = x + ((t / (y * z)) * 0.3333333333333333)
	tmp = 0
	if y <= -0.021:
		tmp = ((y / z) / -3.0) + x
	elif y <= -9e-155:
		tmp = t_1
	elif y <= 2.55e-263:
		tmp = (t / z) / (y / 0.3333333333333333)
	elif y <= 6.5e-15:
		tmp = t_1
	else:
		tmp = x + (y / (z / -0.3333333333333333))
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(x + Float64(Float64(t / Float64(y * z)) * 0.3333333333333333))
	tmp = 0.0
	if (y <= -0.021)
		tmp = Float64(Float64(Float64(y / z) / -3.0) + x);
	elseif (y <= -9e-155)
		tmp = t_1;
	elseif (y <= 2.55e-263)
		tmp = Float64(Float64(t / z) / Float64(y / 0.3333333333333333));
	elseif (y <= 6.5e-15)
		tmp = t_1;
	else
		tmp = Float64(x + Float64(y / Float64(z / -0.3333333333333333)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = x + ((t / (y * z)) * 0.3333333333333333);
	tmp = 0.0;
	if (y <= -0.021)
		tmp = ((y / z) / -3.0) + x;
	elseif (y <= -9e-155)
		tmp = t_1;
	elseif (y <= 2.55e-263)
		tmp = (t / z) / (y / 0.3333333333333333);
	elseif (y <= 6.5e-15)
		tmp = t_1;
	else
		tmp = x + (y / (z / -0.3333333333333333));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(x + N[(N[(t / N[(y * z), $MachinePrecision]), $MachinePrecision] * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -0.021], N[(N[(N[(y / z), $MachinePrecision] / -3.0), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[y, -9e-155], t$95$1, If[LessEqual[y, 2.55e-263], N[(N[(t / z), $MachinePrecision] / N[(y / 0.3333333333333333), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 6.5e-15], t$95$1, N[(x + N[(y / N[(z / -0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

1. Split input into 4 regimes

2. if y < -0.0210000000000000013

   1. Initial program 98.3%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   if -0.0210000000000000013 < y < -9.0000000000000007e-155 or 2.54999999999999985e-263 < y < 6.49999999999999991e-15

   1. Initial program 97.7%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -9.0000000000000007e-155 < y < 2.54999999999999985e-263

   1. Initial program 85.7%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   12. Applied egg-rr 0

       \[\leadsto expr\]

   if 6.49999999999999991e-15 < y

   1. Initial program 99.9%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 8: 76.9% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{\frac{t}{z}}{\frac{y}{0.3333333333333333}}\\ t_2 := x + \frac{y}{\frac{z}{-0.3333333333333333}}\\ \mathbf{if}\;y \leq -1.85 \cdot 10^{-32}:\\ \;\;\;\;\frac{\frac{y}{z}}{-3} + x\\ \mathbf{elif}\;y \leq -8.5 \cdot 10^{-66}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;y \leq -3.6 \cdot 10^{-144}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;y \leq 2.55 \cdot 10^{-17}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (/ (/ t z) (/ y 0.3333333333333333)))
        (t_2 (+ x (/ y (/ z -0.3333333333333333)))))
   (if (<= y -1.85e-32)
     (+ (/ (/ y z) -3.0) x)
     (if (<= y -8.5e-66)
       t_1
       (if (<= y -3.6e-144) t_2 (if (<= y 2.55e-17) t_1 t_2))))))

C

double code(double x, double y, double z, double t) {
	double t_1 = (t / z) / (y / 0.3333333333333333);
	double t_2 = x + (y / (z / -0.3333333333333333));
	double tmp;
	if (y <= -1.85e-32) {
		tmp = ((y / z) / -3.0) + x;
	} else if (y <= -8.5e-66) {
		tmp = t_1;
	} else if (y <= -3.6e-144) {
		tmp = t_2;
	} else if (y <= 2.55e-17) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	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) :: t_2
    real(8) :: tmp
    t_1 = (t / z) / (y / 0.3333333333333333d0)
    t_2 = x + (y / (z / (-0.3333333333333333d0)))
    if (y <= (-1.85d-32)) then
        tmp = ((y / z) / (-3.0d0)) + x
    else if (y <= (-8.5d-66)) then
        tmp = t_1
    else if (y <= (-3.6d-144)) then
        tmp = t_2
    else if (y <= 2.55d-17) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = (t / z) / (y / 0.3333333333333333);
	double t_2 = x + (y / (z / -0.3333333333333333));
	double tmp;
	if (y <= -1.85e-32) {
		tmp = ((y / z) / -3.0) + x;
	} else if (y <= -8.5e-66) {
		tmp = t_1;
	} else if (y <= -3.6e-144) {
		tmp = t_2;
	} else if (y <= 2.55e-17) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = (t / z) / (y / 0.3333333333333333)
	t_2 = x + (y / (z / -0.3333333333333333))
	tmp = 0
	if y <= -1.85e-32:
		tmp = ((y / z) / -3.0) + x
	elif y <= -8.5e-66:
		tmp = t_1
	elif y <= -3.6e-144:
		tmp = t_2
	elif y <= 2.55e-17:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(Float64(t / z) / Float64(y / 0.3333333333333333))
	t_2 = Float64(x + Float64(y / Float64(z / -0.3333333333333333)))
	tmp = 0.0
	if (y <= -1.85e-32)
		tmp = Float64(Float64(Float64(y / z) / -3.0) + x);
	elseif (y <= -8.5e-66)
		tmp = t_1;
	elseif (y <= -3.6e-144)
		tmp = t_2;
	elseif (y <= 2.55e-17)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = (t / z) / (y / 0.3333333333333333);
	t_2 = x + (y / (z / -0.3333333333333333));
	tmp = 0.0;
	if (y <= -1.85e-32)
		tmp = ((y / z) / -3.0) + x;
	elseif (y <= -8.5e-66)
		tmp = t_1;
	elseif (y <= -3.6e-144)
		tmp = t_2;
	elseif (y <= 2.55e-17)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(t / z), $MachinePrecision] / N[(y / 0.3333333333333333), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(y / N[(z / -0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.85e-32], N[(N[(N[(y / z), $MachinePrecision] / -3.0), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[y, -8.5e-66], t$95$1, If[LessEqual[y, -3.6e-144], t$95$2, If[LessEqual[y, 2.55e-17], t$95$1, t$95$2]]]]]]

Derivation

1. Split input into 3 regimes

2. if y < -1.85e-32

   1. Initial program 97.2%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   if -1.85e-32 < y < -8.49999999999999966e-66 or -3.6e-144 < y < 2.5500000000000001e-17

   1. Initial program 92.6%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   12. Applied egg-rr 0

       \[\leadsto expr\]

   if -8.49999999999999966e-66 < y < -3.6e-144 or 2.5500000000000001e-17 < y

   1. Initial program 99.9%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 9: 76.9% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{t}{z} \cdot \frac{0.3333333333333333}{y}\\ t_2 := x + \frac{y}{\frac{z}{-0.3333333333333333}}\\ \mathbf{if}\;y \leq -6.5 \cdot 10^{-33}:\\ \;\;\;\;\frac{\frac{y}{z}}{-3} + x\\ \mathbf{elif}\;y \leq -4.6 \cdot 10^{-63}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;y \leq -3.6 \cdot 10^{-144}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;y \leq 6.5 \cdot 10^{-17}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (* (/ t z) (/ 0.3333333333333333 y)))
        (t_2 (+ x (/ y (/ z -0.3333333333333333)))))
   (if (<= y -6.5e-33)
     (+ (/ (/ y z) -3.0) x)
     (if (<= y -4.6e-63)
       t_1
       (if (<= y -3.6e-144) t_2 (if (<= y 6.5e-17) t_1 t_2))))))

C

double code(double x, double y, double z, double t) {
	double t_1 = (t / z) * (0.3333333333333333 / y);
	double t_2 = x + (y / (z / -0.3333333333333333));
	double tmp;
	if (y <= -6.5e-33) {
		tmp = ((y / z) / -3.0) + x;
	} else if (y <= -4.6e-63) {
		tmp = t_1;
	} else if (y <= -3.6e-144) {
		tmp = t_2;
	} else if (y <= 6.5e-17) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	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) :: t_2
    real(8) :: tmp
    t_1 = (t / z) * (0.3333333333333333d0 / y)
    t_2 = x + (y / (z / (-0.3333333333333333d0)))
    if (y <= (-6.5d-33)) then
        tmp = ((y / z) / (-3.0d0)) + x
    else if (y <= (-4.6d-63)) then
        tmp = t_1
    else if (y <= (-3.6d-144)) then
        tmp = t_2
    else if (y <= 6.5d-17) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = (t / z) * (0.3333333333333333 / y);
	double t_2 = x + (y / (z / -0.3333333333333333));
	double tmp;
	if (y <= -6.5e-33) {
		tmp = ((y / z) / -3.0) + x;
	} else if (y <= -4.6e-63) {
		tmp = t_1;
	} else if (y <= -3.6e-144) {
		tmp = t_2;
	} else if (y <= 6.5e-17) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = (t / z) * (0.3333333333333333 / y)
	t_2 = x + (y / (z / -0.3333333333333333))
	tmp = 0
	if y <= -6.5e-33:
		tmp = ((y / z) / -3.0) + x
	elif y <= -4.6e-63:
		tmp = t_1
	elif y <= -3.6e-144:
		tmp = t_2
	elif y <= 6.5e-17:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(Float64(t / z) * Float64(0.3333333333333333 / y))
	t_2 = Float64(x + Float64(y / Float64(z / -0.3333333333333333)))
	tmp = 0.0
	if (y <= -6.5e-33)
		tmp = Float64(Float64(Float64(y / z) / -3.0) + x);
	elseif (y <= -4.6e-63)
		tmp = t_1;
	elseif (y <= -3.6e-144)
		tmp = t_2;
	elseif (y <= 6.5e-17)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = (t / z) * (0.3333333333333333 / y);
	t_2 = x + (y / (z / -0.3333333333333333));
	tmp = 0.0;
	if (y <= -6.5e-33)
		tmp = ((y / z) / -3.0) + x;
	elseif (y <= -4.6e-63)
		tmp = t_1;
	elseif (y <= -3.6e-144)
		tmp = t_2;
	elseif (y <= 6.5e-17)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(t / z), $MachinePrecision] * N[(0.3333333333333333 / y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(y / N[(z / -0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -6.5e-33], N[(N[(N[(y / z), $MachinePrecision] / -3.0), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[y, -4.6e-63], t$95$1, If[LessEqual[y, -3.6e-144], t$95$2, If[LessEqual[y, 6.5e-17], t$95$1, t$95$2]]]]]]

Derivation

1. Split input into 3 regimes

2. if y < -6.4999999999999993e-33

   1. Initial program 97.2%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   if -6.4999999999999993e-33 < y < -4.6e-63 or -3.6e-144 < y < 6.4999999999999996e-17

   1. Initial program 92.6%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   12. Applied egg-rr 0

       \[\leadsto expr\]

   if -4.6e-63 < y < -3.6e-144 or 6.4999999999999996e-17 < y

   1. Initial program 99.9%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 10: 76.8% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{t}{z} \cdot \frac{0.3333333333333333}{y}\\ t_2 := x + \frac{y}{\frac{z}{-0.3333333333333333}}\\ \mathbf{if}\;y \leq -4.9 \cdot 10^{-32}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;y \leq -2.2 \cdot 10^{-63}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;y \leq -3.6 \cdot 10^{-144}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;y \leq 3.1 \cdot 10^{-17}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (* (/ t z) (/ 0.3333333333333333 y)))
        (t_2 (+ x (/ y (/ z -0.3333333333333333)))))
   (if (<= y -4.9e-32)
     t_2
     (if (<= y -2.2e-63)
       t_1
       (if (<= y -3.6e-144) t_2 (if (<= y 3.1e-17) t_1 t_2))))))

C

double code(double x, double y, double z, double t) {
	double t_1 = (t / z) * (0.3333333333333333 / y);
	double t_2 = x + (y / (z / -0.3333333333333333));
	double tmp;
	if (y <= -4.9e-32) {
		tmp = t_2;
	} else if (y <= -2.2e-63) {
		tmp = t_1;
	} else if (y <= -3.6e-144) {
		tmp = t_2;
	} else if (y <= 3.1e-17) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	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) :: t_2
    real(8) :: tmp
    t_1 = (t / z) * (0.3333333333333333d0 / y)
    t_2 = x + (y / (z / (-0.3333333333333333d0)))
    if (y <= (-4.9d-32)) then
        tmp = t_2
    else if (y <= (-2.2d-63)) then
        tmp = t_1
    else if (y <= (-3.6d-144)) then
        tmp = t_2
    else if (y <= 3.1d-17) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = (t / z) * (0.3333333333333333 / y);
	double t_2 = x + (y / (z / -0.3333333333333333));
	double tmp;
	if (y <= -4.9e-32) {
		tmp = t_2;
	} else if (y <= -2.2e-63) {
		tmp = t_1;
	} else if (y <= -3.6e-144) {
		tmp = t_2;
	} else if (y <= 3.1e-17) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = (t / z) * (0.3333333333333333 / y)
	t_2 = x + (y / (z / -0.3333333333333333))
	tmp = 0
	if y <= -4.9e-32:
		tmp = t_2
	elif y <= -2.2e-63:
		tmp = t_1
	elif y <= -3.6e-144:
		tmp = t_2
	elif y <= 3.1e-17:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(Float64(t / z) * Float64(0.3333333333333333 / y))
	t_2 = Float64(x + Float64(y / Float64(z / -0.3333333333333333)))
	tmp = 0.0
	if (y <= -4.9e-32)
		tmp = t_2;
	elseif (y <= -2.2e-63)
		tmp = t_1;
	elseif (y <= -3.6e-144)
		tmp = t_2;
	elseif (y <= 3.1e-17)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = (t / z) * (0.3333333333333333 / y);
	t_2 = x + (y / (z / -0.3333333333333333));
	tmp = 0.0;
	if (y <= -4.9e-32)
		tmp = t_2;
	elseif (y <= -2.2e-63)
		tmp = t_1;
	elseif (y <= -3.6e-144)
		tmp = t_2;
	elseif (y <= 3.1e-17)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(t / z), $MachinePrecision] * N[(0.3333333333333333 / y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(y / N[(z / -0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -4.9e-32], t$95$2, If[LessEqual[y, -2.2e-63], t$95$1, If[LessEqual[y, -3.6e-144], t$95$2, If[LessEqual[y, 3.1e-17], t$95$1, t$95$2]]]]]]

Derivation

1. Split input into 2 regimes

2. if y < -4.8999999999999998e-32 or -2.2e-63 < y < -3.6e-144 or 3.0999999999999998e-17 < y

   1. Initial program 98.5%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   if -4.8999999999999998e-32 < y < -2.2e-63 or -3.6e-144 < y < 3.0999999999999998e-17

   1. Initial program 92.6%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   12. Applied egg-rr 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 11: 98.0% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y - \frac{t}{y}\\ \mathbf{if}\;y \leq -8 \cdot 10^{-47}:\\ \;\;\;\;x + \frac{\frac{t\_1}{z}}{-3}\\ \mathbf{elif}\;y \leq 7.2 \cdot 10^{-102}:\\ \;\;\;\;x + \frac{\frac{t}{z}}{y \cdot 3}\\ \mathbf{else}:\\ \;\;\;\;x - \frac{t\_1}{z \cdot 3}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (- y (/ t y))))
   (if (<= y -8e-47)
     (+ x (/ (/ t_1 z) -3.0))
     (if (<= y 7.2e-102)
       (+ x (/ (/ t z) (* y 3.0)))
       (- x (/ t_1 (* z 3.0)))))))

C

double code(double x, double y, double z, double t) {
	double t_1 = y - (t / y);
	double tmp;
	if (y <= -8e-47) {
		tmp = x + ((t_1 / z) / -3.0);
	} else if (y <= 7.2e-102) {
		tmp = x + ((t / z) / (y * 3.0));
	} else {
		tmp = x - (t_1 / (z * 3.0));
	}
	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 = y - (t / y)
    if (y <= (-8d-47)) then
        tmp = x + ((t_1 / z) / (-3.0d0))
    else if (y <= 7.2d-102) then
        tmp = x + ((t / z) / (y * 3.0d0))
    else
        tmp = x - (t_1 / (z * 3.0d0))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = y - (t / y);
	double tmp;
	if (y <= -8e-47) {
		tmp = x + ((t_1 / z) / -3.0);
	} else if (y <= 7.2e-102) {
		tmp = x + ((t / z) / (y * 3.0));
	} else {
		tmp = x - (t_1 / (z * 3.0));
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = y - (t / y)
	tmp = 0
	if y <= -8e-47:
		tmp = x + ((t_1 / z) / -3.0)
	elif y <= 7.2e-102:
		tmp = x + ((t / z) / (y * 3.0))
	else:
		tmp = x - (t_1 / (z * 3.0))
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(y - Float64(t / y))
	tmp = 0.0
	if (y <= -8e-47)
		tmp = Float64(x + Float64(Float64(t_1 / z) / -3.0));
	elseif (y <= 7.2e-102)
		tmp = Float64(x + Float64(Float64(t / z) / Float64(y * 3.0)));
	else
		tmp = Float64(x - Float64(t_1 / Float64(z * 3.0)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = y - (t / y);
	tmp = 0.0;
	if (y <= -8e-47)
		tmp = x + ((t_1 / z) / -3.0);
	elseif (y <= 7.2e-102)
		tmp = x + ((t / z) / (y * 3.0));
	else
		tmp = x - (t_1 / (z * 3.0));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(y - N[(t / y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -8e-47], N[(x + N[(N[(t$95$1 / z), $MachinePrecision] / -3.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 7.2e-102], N[(x + N[(N[(t / z), $MachinePrecision] / N[(y * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x - N[(t$95$1 / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if y < -7.9999999999999998e-47

   1. Initial program 97.3%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   if -7.9999999999999998e-47 < y < 7.2e-102

   1. Initial program 92.7%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   if 7.2e-102 < y

   1. Initial program 99.9%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 12: 98.0% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y - \frac{t}{y}\\ \mathbf{if}\;y \leq -8 \cdot 10^{-47}:\\ \;\;\;\;x + \frac{\frac{t\_1}{z}}{-3}\\ \mathbf{elif}\;y \leq 1.9 \cdot 10^{-114}:\\ \;\;\;\;x + \frac{\frac{t}{z}}{y \cdot 3}\\ \mathbf{else}:\\ \;\;\;\;x + \frac{\frac{t\_1}{-3}}{z}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (- y (/ t y))))
   (if (<= y -8e-47)
     (+ x (/ (/ t_1 z) -3.0))
     (if (<= y 1.9e-114)
       (+ x (/ (/ t z) (* y 3.0)))
       (+ x (/ (/ t_1 -3.0) z))))))

C

double code(double x, double y, double z, double t) {
	double t_1 = y - (t / y);
	double tmp;
	if (y <= -8e-47) {
		tmp = x + ((t_1 / z) / -3.0);
	} else if (y <= 1.9e-114) {
		tmp = x + ((t / z) / (y * 3.0));
	} else {
		tmp = x + ((t_1 / -3.0) / 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) :: t_1
    real(8) :: tmp
    t_1 = y - (t / y)
    if (y <= (-8d-47)) then
        tmp = x + ((t_1 / z) / (-3.0d0))
    else if (y <= 1.9d-114) then
        tmp = x + ((t / z) / (y * 3.0d0))
    else
        tmp = x + ((t_1 / (-3.0d0)) / z)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = y - (t / y);
	double tmp;
	if (y <= -8e-47) {
		tmp = x + ((t_1 / z) / -3.0);
	} else if (y <= 1.9e-114) {
		tmp = x + ((t / z) / (y * 3.0));
	} else {
		tmp = x + ((t_1 / -3.0) / z);
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = y - (t / y)
	tmp = 0
	if y <= -8e-47:
		tmp = x + ((t_1 / z) / -3.0)
	elif y <= 1.9e-114:
		tmp = x + ((t / z) / (y * 3.0))
	else:
		tmp = x + ((t_1 / -3.0) / z)
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(y - Float64(t / y))
	tmp = 0.0
	if (y <= -8e-47)
		tmp = Float64(x + Float64(Float64(t_1 / z) / -3.0));
	elseif (y <= 1.9e-114)
		tmp = Float64(x + Float64(Float64(t / z) / Float64(y * 3.0)));
	else
		tmp = Float64(x + Float64(Float64(t_1 / -3.0) / z));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = y - (t / y);
	tmp = 0.0;
	if (y <= -8e-47)
		tmp = x + ((t_1 / z) / -3.0);
	elseif (y <= 1.9e-114)
		tmp = x + ((t / z) / (y * 3.0));
	else
		tmp = x + ((t_1 / -3.0) / z);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(y - N[(t / y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -8e-47], N[(x + N[(N[(t$95$1 / z), $MachinePrecision] / -3.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.9e-114], N[(x + N[(N[(t / z), $MachinePrecision] / N[(y * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(t$95$1 / -3.0), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if y < -7.9999999999999998e-47

   1. Initial program 97.3%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   if -7.9999999999999998e-47 < y < 1.8999999999999999e-114

   1. Initial program 92.7%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   if 1.8999999999999999e-114 < y

   1. Initial program 99.9%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 13: 98.1% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + \frac{\frac{y - \frac{t}{y}}{-3}}{z}\\ \mathbf{if}\;y \leq -5.5 \cdot 10^{-50}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;y \leq 6.8 \cdot 10^{-110}:\\ \;\;\;\;x + \frac{\frac{t}{z}}{y \cdot 3}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (+ x (/ (/ (- y (/ t y)) -3.0) z))))
   (if (<= y -5.5e-50)
     t_1
     (if (<= y 6.8e-110) (+ x (/ (/ t z) (* y 3.0))) t_1))))

C

double code(double x, double y, double z, double t) {
	double t_1 = x + (((y - (t / y)) / -3.0) / z);
	double tmp;
	if (y <= -5.5e-50) {
		tmp = t_1;
	} else if (y <= 6.8e-110) {
		tmp = x + ((t / z) / (y * 3.0));
	} 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 = x + (((y - (t / y)) / (-3.0d0)) / z)
    if (y <= (-5.5d-50)) then
        tmp = t_1
    else if (y <= 6.8d-110) then
        tmp = x + ((t / z) / (y * 3.0d0))
    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 = x + (((y - (t / y)) / -3.0) / z);
	double tmp;
	if (y <= -5.5e-50) {
		tmp = t_1;
	} else if (y <= 6.8e-110) {
		tmp = x + ((t / z) / (y * 3.0));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = x + (((y - (t / y)) / -3.0) / z)
	tmp = 0
	if y <= -5.5e-50:
		tmp = t_1
	elif y <= 6.8e-110:
		tmp = x + ((t / z) / (y * 3.0))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(x + Float64(Float64(Float64(y - Float64(t / y)) / -3.0) / z))
	tmp = 0.0
	if (y <= -5.5e-50)
		tmp = t_1;
	elseif (y <= 6.8e-110)
		tmp = Float64(x + Float64(Float64(t / z) / Float64(y * 3.0)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = x + (((y - (t / y)) / -3.0) / z);
	tmp = 0.0;
	if (y <= -5.5e-50)
		tmp = t_1;
	elseif (y <= 6.8e-110)
		tmp = x + ((t / z) / (y * 3.0));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(x + N[(N[(N[(y - N[(t / y), $MachinePrecision]), $MachinePrecision] / -3.0), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -5.5e-50], t$95$1, If[LessEqual[y, 6.8e-110], N[(x + N[(N[(t / z), $MachinePrecision] / N[(y * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]

Derivation

1. Split input into 2 regimes

2. if y < -5.49999999999999975e-50 or 6.8000000000000002e-110 < y

   1. Initial program 98.5%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   if -5.49999999999999975e-50 < y < 6.8000000000000002e-110

   1. Initial program 92.7%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 14: 92.2% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -0.022:\\ \;\;\;\;\frac{\frac{y}{z}}{-3} + x\\ \mathbf{elif}\;y \leq 5.2 \cdot 10^{-15}:\\ \;\;\;\;x + \frac{\frac{t}{z}}{y \cdot 3}\\ \mathbf{else}:\\ \;\;\;\;x + \frac{y}{\frac{z}{-0.3333333333333333}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= y -0.022)
   (+ (/ (/ y z) -3.0) x)
   (if (<= y 5.2e-15)
     (+ x (/ (/ t z) (* y 3.0)))
     (+ x (/ y (/ z -0.3333333333333333))))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -0.022) {
		tmp = ((y / z) / -3.0) + x;
	} else if (y <= 5.2e-15) {
		tmp = x + ((t / z) / (y * 3.0));
	} else {
		tmp = x + (y / (z / -0.3333333333333333));
	}
	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 (y <= (-0.022d0)) then
        tmp = ((y / z) / (-3.0d0)) + x
    else if (y <= 5.2d-15) then
        tmp = x + ((t / z) / (y * 3.0d0))
    else
        tmp = x + (y / (z / (-0.3333333333333333d0)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -0.022) {
		tmp = ((y / z) / -3.0) + x;
	} else if (y <= 5.2e-15) {
		tmp = x + ((t / z) / (y * 3.0));
	} else {
		tmp = x + (y / (z / -0.3333333333333333));
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if y <= -0.022:
		tmp = ((y / z) / -3.0) + x
	elif y <= 5.2e-15:
		tmp = x + ((t / z) / (y * 3.0))
	else:
		tmp = x + (y / (z / -0.3333333333333333))
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (y <= -0.022)
		tmp = Float64(Float64(Float64(y / z) / -3.0) + x);
	elseif (y <= 5.2e-15)
		tmp = Float64(x + Float64(Float64(t / z) / Float64(y * 3.0)));
	else
		tmp = Float64(x + Float64(y / Float64(z / -0.3333333333333333)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (y <= -0.022)
		tmp = ((y / z) / -3.0) + x;
	elseif (y <= 5.2e-15)
		tmp = x + ((t / z) / (y * 3.0));
	else
		tmp = x + (y / (z / -0.3333333333333333));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[y, -0.022], N[(N[(N[(y / z), $MachinePrecision] / -3.0), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[y, 5.2e-15], N[(x + N[(N[(t / z), $MachinePrecision] / N[(y * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(y / N[(z / -0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if y < -0.021999999999999999

   1. Initial program 98.3%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   if -0.021999999999999999 < y < 5.20000000000000009e-15

   1. Initial program 93.6%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   if 5.20000000000000009e-15 < y

   1. Initial program 99.9%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 15: 47.8% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \cdot 3 \leq -2 \cdot 10^{+35}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \cdot 3 \leq 10^{+108}:\\ \;\;\;\;\frac{\frac{y}{z}}{-3}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= (* z 3.0) -2e+35) x (if (<= (* z 3.0) 1e+108) (/ (/ y z) -3.0) x)))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if ((z * 3.0) <= -2e+35) {
		tmp = x;
	} else if ((z * 3.0) <= 1e+108) {
		tmp = (y / z) / -3.0;
	} else {
		tmp = 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 * 3.0d0) <= (-2d+35)) then
        tmp = x
    else if ((z * 3.0d0) <= 1d+108) then
        tmp = (y / z) / (-3.0d0)
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if ((z * 3.0) <= -2e+35) {
		tmp = x;
	} else if ((z * 3.0) <= 1e+108) {
		tmp = (y / z) / -3.0;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if (z * 3.0) <= -2e+35:
		tmp = x
	elif (z * 3.0) <= 1e+108:
		tmp = (y / z) / -3.0
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (Float64(z * 3.0) <= -2e+35)
		tmp = x;
	elseif (Float64(z * 3.0) <= 1e+108)
		tmp = Float64(Float64(y / z) / -3.0);
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if ((z * 3.0) <= -2e+35)
		tmp = x;
	elseif ((z * 3.0) <= 1e+108)
		tmp = (y / z) / -3.0;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[N[(z * 3.0), $MachinePrecision], -2e+35], x, If[LessEqual[N[(z * 3.0), $MachinePrecision], 1e+108], N[(N[(y / z), $MachinePrecision] / -3.0), $MachinePrecision], x]]

Derivation

1. Split input into 2 regimes

2. if (*.f64 z #s(literal 3 binary64)) < -1.9999999999999999e35 or 1e108 < (*.f64 z #s(literal 3 binary64))

   1. Initial program 99.8%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -1.9999999999999999e35 < (*.f64 z #s(literal 3 binary64)) < 1e108

   1. Initial program 94.1%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 16: 47.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -1.18 \cdot 10^{+33}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 2.25 \cdot 10^{+110}:\\ \;\;\;\;-0.3333333333333333 \cdot \frac{y}{z}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= z -1.18e+33)
   x
   (if (<= z 2.25e+110) (* -0.3333333333333333 (/ y z)) x)))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (z <= -1.18e+33) {
		tmp = x;
	} else if (z <= 2.25e+110) {
		tmp = -0.3333333333333333 * (y / z);
	} else {
		tmp = 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 <= (-1.18d+33)) then
        tmp = x
    else if (z <= 2.25d+110) then
        tmp = (-0.3333333333333333d0) * (y / z)
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (z <= -1.18e+33) {
		tmp = x;
	} else if (z <= 2.25e+110) {
		tmp = -0.3333333333333333 * (y / z);
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if z <= -1.18e+33:
		tmp = x
	elif z <= 2.25e+110:
		tmp = -0.3333333333333333 * (y / z)
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (z <= -1.18e+33)
		tmp = x;
	elseif (z <= 2.25e+110)
		tmp = Float64(-0.3333333333333333 * Float64(y / z));
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (z <= -1.18e+33)
		tmp = x;
	elseif (z <= 2.25e+110)
		tmp = -0.3333333333333333 * (y / z);
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[z, -1.18e+33], x, If[LessEqual[z, 2.25e+110], N[(-0.3333333333333333 * N[(y / z), $MachinePrecision]), $MachinePrecision], x]]

Derivation

1. Split input into 2 regimes

2. if z < -1.17999999999999993e33 or 2.2500000000000001e110 < z

   1. Initial program 99.8%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -1.17999999999999993e33 < z < 2.2500000000000001e110

   1. Initial program 94.1%

      \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 17: 30.6% accurate, 15.0× speedup

Math

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

FPCore

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

C

double code(double x, double y, double z, double t) {
	return 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 = x
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[x_, y_, z_, t_] := x

Derivation

1. Initial program 96.0%

   \[\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y} \]

3. Simplified 0

   \[\leadsto expr\]
4. Add Preprocessing

5. Taylor expanded in x around inf 0

   \[\leadsto expr\]

7. Simplified 0

   \[\leadsto expr\]
8. Add Preprocessing

Developer target: 96.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Reproduce

herbie shell --seed 2024110 
(FPCore (x y z t)
  :name "Diagrams.Solve.Polynomial:cubForm  from diagrams-solve-0.1, H"
  :precision binary64

  :alt
  (+ (- x (/ y (* z 3.0))) (/ (/ t (* z 3.0)) y))

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