Graphics.Rendering.Chart.SparkLine:renderSparkLine from Chart-1.5.3

Percentage Accurate: 96.9% → 98.1%

Time: 14.3s

Alternatives: 15

Speedup: 1.0×

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 96.9% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 98.1% accurate, 0.6× speedup

Math

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

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (- x (* (/ (- y z) (+ t (- z))) a))))
   (if (<= z -8e-43)
     t_1
     (if (<= z 1.0) (- x (/ (- y z) (/ (+ 1.0 t) a))) t_1))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = x - (((y - z) / (t + -z)) * a);
	double tmp;
	if (z <= -8e-43) {
		tmp = t_1;
	} else if (z <= 1.0) {
		tmp = x - ((y - z) / ((1.0 + t) / a));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8) :: t_1
    real(8) :: tmp
    t_1 = x - (((y - z) / (t + -z)) * a)
    if (z <= (-8d-43)) then
        tmp = t_1
    else if (z <= 1.0d0) then
        tmp = x - ((y - z) / ((1.0d0 + t) / a))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double t_1 = x - (((y - z) / (t + -z)) * a);
	double tmp;
	if (z <= -8e-43) {
		tmp = t_1;
	} else if (z <= 1.0) {
		tmp = x - ((y - z) / ((1.0 + t) / a));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = x - (((y - z) / (t + -z)) * a)
	tmp = 0
	if z <= -8e-43:
		tmp = t_1
	elif z <= 1.0:
		tmp = x - ((y - z) / ((1.0 + t) / a))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(x - Float64(Float64(Float64(y - z) / Float64(t + Float64(-z))) * a))
	tmp = 0.0
	if (z <= -8e-43)
		tmp = t_1;
	elseif (z <= 1.0)
		tmp = Float64(x - Float64(Float64(y - z) / Float64(Float64(1.0 + t) / a)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = x - (((y - z) / (t + -z)) * a);
	tmp = 0.0;
	if (z <= -8e-43)
		tmp = t_1;
	elseif (z <= 1.0)
		tmp = x - ((y - z) / ((1.0 + t) / a));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if z < -8.00000000000000062e-43 or 1 < z

   1. Initial program 95.2%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   if -8.00000000000000062e-43 < z < 1

   1. Initial program 99.9%

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

   3. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 2: 71.4% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x - a \cdot y\\ t_2 := x - \frac{a}{t} \cdot y\\ \mathbf{if}\;z \leq -1.3 \cdot 10^{+97}:\\ \;\;\;\;x - a\\ \mathbf{elif}\;z \leq -2.25 \cdot 10^{+30}:\\ \;\;\;\;x - \frac{y}{-z} \cdot a\\ \mathbf{elif}\;z \leq -4 \cdot 10^{+25}:\\ \;\;\;\;a \cdot \frac{z}{t}\\ \mathbf{elif}\;z \leq -1.9 \cdot 10^{-62}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;z \leq -8.2 \cdot 10^{-271}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 5.5 \cdot 10^{-223}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;z \leq 5.1 \cdot 10^{+57}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;x - a\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (- x (* a y))) (t_2 (- x (* (/ a t) y))))
   (if (<= z -1.3e+97)
     (- x a)
     (if (<= z -2.25e+30)
       (- x (* (/ y (- z)) a))
       (if (<= z -4e+25)
         (* a (/ z t))
         (if (<= z -1.9e-62)
           t_2
           (if (<= z -8.2e-271)
             t_1
             (if (<= z 5.5e-223) t_2 (if (<= z 5.1e+57) t_1 (- x a))))))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = x - (a * y);
	double t_2 = x - ((a / t) * y);
	double tmp;
	if (z <= -1.3e+97) {
		tmp = x - a;
	} else if (z <= -2.25e+30) {
		tmp = x - ((y / -z) * a);
	} else if (z <= -4e+25) {
		tmp = a * (z / t);
	} else if (z <= -1.9e-62) {
		tmp = t_2;
	} else if (z <= -8.2e-271) {
		tmp = t_1;
	} else if (z <= 5.5e-223) {
		tmp = t_2;
	} else if (z <= 5.1e+57) {
		tmp = t_1;
	} else {
		tmp = x - a;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = x - (a * y)
    t_2 = x - ((a / t) * y)
    if (z <= (-1.3d+97)) then
        tmp = x - a
    else if (z <= (-2.25d+30)) then
        tmp = x - ((y / -z) * a)
    else if (z <= (-4d+25)) then
        tmp = a * (z / t)
    else if (z <= (-1.9d-62)) then
        tmp = t_2
    else if (z <= (-8.2d-271)) then
        tmp = t_1
    else if (z <= 5.5d-223) then
        tmp = t_2
    else if (z <= 5.1d+57) then
        tmp = t_1
    else
        tmp = x - a
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double t_1 = x - (a * y);
	double t_2 = x - ((a / t) * y);
	double tmp;
	if (z <= -1.3e+97) {
		tmp = x - a;
	} else if (z <= -2.25e+30) {
		tmp = x - ((y / -z) * a);
	} else if (z <= -4e+25) {
		tmp = a * (z / t);
	} else if (z <= -1.9e-62) {
		tmp = t_2;
	} else if (z <= -8.2e-271) {
		tmp = t_1;
	} else if (z <= 5.5e-223) {
		tmp = t_2;
	} else if (z <= 5.1e+57) {
		tmp = t_1;
	} else {
		tmp = x - a;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = x - (a * y)
	t_2 = x - ((a / t) * y)
	tmp = 0
	if z <= -1.3e+97:
		tmp = x - a
	elif z <= -2.25e+30:
		tmp = x - ((y / -z) * a)
	elif z <= -4e+25:
		tmp = a * (z / t)
	elif z <= -1.9e-62:
		tmp = t_2
	elif z <= -8.2e-271:
		tmp = t_1
	elif z <= 5.5e-223:
		tmp = t_2
	elif z <= 5.1e+57:
		tmp = t_1
	else:
		tmp = x - a
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(x - Float64(a * y))
	t_2 = Float64(x - Float64(Float64(a / t) * y))
	tmp = 0.0
	if (z <= -1.3e+97)
		tmp = Float64(x - a);
	elseif (z <= -2.25e+30)
		tmp = Float64(x - Float64(Float64(y / Float64(-z)) * a));
	elseif (z <= -4e+25)
		tmp = Float64(a * Float64(z / t));
	elseif (z <= -1.9e-62)
		tmp = t_2;
	elseif (z <= -8.2e-271)
		tmp = t_1;
	elseif (z <= 5.5e-223)
		tmp = t_2;
	elseif (z <= 5.1e+57)
		tmp = t_1;
	else
		tmp = Float64(x - a);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = x - (a * y);
	t_2 = x - ((a / t) * y);
	tmp = 0.0;
	if (z <= -1.3e+97)
		tmp = x - a;
	elseif (z <= -2.25e+30)
		tmp = x - ((y / -z) * a);
	elseif (z <= -4e+25)
		tmp = a * (z / t);
	elseif (z <= -1.9e-62)
		tmp = t_2;
	elseif (z <= -8.2e-271)
		tmp = t_1;
	elseif (z <= 5.5e-223)
		tmp = t_2;
	elseif (z <= 5.1e+57)
		tmp = t_1;
	else
		tmp = x - a;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x - N[(a * y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x - N[(N[(a / t), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.3e+97], N[(x - a), $MachinePrecision], If[LessEqual[z, -2.25e+30], N[(x - N[(N[(y / (-z)), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -4e+25], N[(a * N[(z / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.9e-62], t$95$2, If[LessEqual[z, -8.2e-271], t$95$1, If[LessEqual[z, 5.5e-223], t$95$2, If[LessEqual[z, 5.1e+57], t$95$1, N[(x - a), $MachinePrecision]]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if z < -1.3e97 or 5.10000000000000023e57 < z

   1. Initial program 94.7%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -1.3e97 < z < -2.24999999999999997e30

   1. Initial program 93.3%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   10. Taylor expanded in y around inf 0

       \[\leadsto expr\]

   12. Simplified 0

       \[\leadsto expr\]

   if -2.24999999999999997e30 < z < -4.00000000000000036e25

   1. Initial program 99.2%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in z around inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -4.00000000000000036e25 < z < -1.90000000000000003e-62 or -8.2000000000000005e-271 < z < 5.5e-223

   1. Initial program 99.9%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   12. Applied egg-rr 0

       \[\leadsto expr\]

   if -1.90000000000000003e-62 < z < -8.2000000000000005e-271 or 5.5e-223 < z < 5.10000000000000023e57

   1. Initial program 98.8%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

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

Alternative 3: 71.2% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x - \frac{a}{t} \cdot \left(y - z\right)\\ \mathbf{if}\;t \leq -310000000:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq -9.5 \cdot 10^{-193}:\\ \;\;\;\;x + \frac{a \cdot z}{1 - z}\\ \mathbf{elif}\;t \leq 1.35 \cdot 10^{-145}:\\ \;\;\;\;x - a\\ \mathbf{elif}\;t \leq 4.6 \cdot 10^{-39}:\\ \;\;\;\;x - a \cdot y\\ \mathbf{elif}\;t \leq 2 \cdot 10^{-7}:\\ \;\;\;\;x - a\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (- x (* (/ a t) (- y z)))))
   (if (<= t -310000000.0)
     t_1
     (if (<= t -9.5e-193)
       (+ x (/ (* a z) (- 1.0 z)))
       (if (<= t 1.35e-145)
         (- x a)
         (if (<= t 4.6e-39) (- x (* a y)) (if (<= t 2e-7) (- x a) t_1)))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = x - ((a / t) * (y - z));
	double tmp;
	if (t <= -310000000.0) {
		tmp = t_1;
	} else if (t <= -9.5e-193) {
		tmp = x + ((a * z) / (1.0 - z));
	} else if (t <= 1.35e-145) {
		tmp = x - a;
	} else if (t <= 4.6e-39) {
		tmp = x - (a * y);
	} else if (t <= 2e-7) {
		tmp = x - a;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8) :: t_1
    real(8) :: tmp
    t_1 = x - ((a / t) * (y - z))
    if (t <= (-310000000.0d0)) then
        tmp = t_1
    else if (t <= (-9.5d-193)) then
        tmp = x + ((a * z) / (1.0d0 - z))
    else if (t <= 1.35d-145) then
        tmp = x - a
    else if (t <= 4.6d-39) then
        tmp = x - (a * y)
    else if (t <= 2d-7) then
        tmp = x - a
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double t_1 = x - ((a / t) * (y - z));
	double tmp;
	if (t <= -310000000.0) {
		tmp = t_1;
	} else if (t <= -9.5e-193) {
		tmp = x + ((a * z) / (1.0 - z));
	} else if (t <= 1.35e-145) {
		tmp = x - a;
	} else if (t <= 4.6e-39) {
		tmp = x - (a * y);
	} else if (t <= 2e-7) {
		tmp = x - a;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = x - ((a / t) * (y - z))
	tmp = 0
	if t <= -310000000.0:
		tmp = t_1
	elif t <= -9.5e-193:
		tmp = x + ((a * z) / (1.0 - z))
	elif t <= 1.35e-145:
		tmp = x - a
	elif t <= 4.6e-39:
		tmp = x - (a * y)
	elif t <= 2e-7:
		tmp = x - a
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(x - Float64(Float64(a / t) * Float64(y - z)))
	tmp = 0.0
	if (t <= -310000000.0)
		tmp = t_1;
	elseif (t <= -9.5e-193)
		tmp = Float64(x + Float64(Float64(a * z) / Float64(1.0 - z)));
	elseif (t <= 1.35e-145)
		tmp = Float64(x - a);
	elseif (t <= 4.6e-39)
		tmp = Float64(x - Float64(a * y));
	elseif (t <= 2e-7)
		tmp = Float64(x - a);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = x - ((a / t) * (y - z));
	tmp = 0.0;
	if (t <= -310000000.0)
		tmp = t_1;
	elseif (t <= -9.5e-193)
		tmp = x + ((a * z) / (1.0 - z));
	elseif (t <= 1.35e-145)
		tmp = x - a;
	elseif (t <= 4.6e-39)
		tmp = x - (a * y);
	elseif (t <= 2e-7)
		tmp = x - a;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x - N[(N[(a / t), $MachinePrecision] * N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -310000000.0], t$95$1, If[LessEqual[t, -9.5e-193], N[(x + N[(N[(a * z), $MachinePrecision] / N[(1.0 - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.35e-145], N[(x - a), $MachinePrecision], If[LessEqual[t, 4.6e-39], N[(x - N[(a * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2e-7], N[(x - a), $MachinePrecision], t$95$1]]]]]]

Derivation

1. Split input into 4 regimes

2. if t < -3.1e8 or 1.9999999999999999e-7 < t

   1. Initial program 99.1%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   if -3.1e8 < t < -9.5000000000000003e-193

   1. Initial program 92.1%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t 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\]

   if -9.5000000000000003e-193 < t < 1.35e-145 or 4.60000000000000016e-39 < t < 1.9999999999999999e-7

   1. Initial program 98.6%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if 1.35e-145 < t < 4.60000000000000016e-39

   1. Initial program 89.7%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

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

Alternative 4: 84.6% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -2.3 \cdot 10^{+97}:\\ \;\;\;\;x - a\\ \mathbf{elif}\;z \leq -1.5 \cdot 10^{+35}:\\ \;\;\;\;x - \frac{y}{-z} \cdot a\\ \mathbf{elif}\;z \leq -4 \cdot 10^{+25}:\\ \;\;\;\;x - \frac{a}{t} \cdot \left(y - z\right)\\ \mathbf{elif}\;z \leq 5.5 \cdot 10^{+57}:\\ \;\;\;\;x - \frac{y}{1 + t} \cdot a\\ \mathbf{else}:\\ \;\;\;\;x - a\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= z -2.3e+97)
   (- x a)
   (if (<= z -1.5e+35)
     (- x (* (/ y (- z)) a))
     (if (<= z -4e+25)
       (- x (* (/ a t) (- y z)))
       (if (<= z 5.5e+57) (- x (* (/ y (+ 1.0 t)) a)) (- x a))))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -2.3e+97) {
		tmp = x - a;
	} else if (z <= -1.5e+35) {
		tmp = x - ((y / -z) * a);
	} else if (z <= -4e+25) {
		tmp = x - ((a / t) * (y - z));
	} else if (z <= 5.5e+57) {
		tmp = x - ((y / (1.0 + t)) * a);
	} else {
		tmp = x - a;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8) :: tmp
    if (z <= (-2.3d+97)) then
        tmp = x - a
    else if (z <= (-1.5d+35)) then
        tmp = x - ((y / -z) * a)
    else if (z <= (-4d+25)) then
        tmp = x - ((a / t) * (y - z))
    else if (z <= 5.5d+57) then
        tmp = x - ((y / (1.0d0 + t)) * a)
    else
        tmp = x - a
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -2.3e+97) {
		tmp = x - a;
	} else if (z <= -1.5e+35) {
		tmp = x - ((y / -z) * a);
	} else if (z <= -4e+25) {
		tmp = x - ((a / t) * (y - z));
	} else if (z <= 5.5e+57) {
		tmp = x - ((y / (1.0 + t)) * a);
	} else {
		tmp = x - a;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if z <= -2.3e+97:
		tmp = x - a
	elif z <= -1.5e+35:
		tmp = x - ((y / -z) * a)
	elif z <= -4e+25:
		tmp = x - ((a / t) * (y - z))
	elif z <= 5.5e+57:
		tmp = x - ((y / (1.0 + t)) * a)
	else:
		tmp = x - a
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (z <= -2.3e+97)
		tmp = Float64(x - a);
	elseif (z <= -1.5e+35)
		tmp = Float64(x - Float64(Float64(y / Float64(-z)) * a));
	elseif (z <= -4e+25)
		tmp = Float64(x - Float64(Float64(a / t) * Float64(y - z)));
	elseif (z <= 5.5e+57)
		tmp = Float64(x - Float64(Float64(y / Float64(1.0 + t)) * a));
	else
		tmp = Float64(x - a);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (z <= -2.3e+97)
		tmp = x - a;
	elseif (z <= -1.5e+35)
		tmp = x - ((y / -z) * a);
	elseif (z <= -4e+25)
		tmp = x - ((a / t) * (y - z));
	elseif (z <= 5.5e+57)
		tmp = x - ((y / (1.0 + t)) * a);
	else
		tmp = x - a;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.3e+97], N[(x - a), $MachinePrecision], If[LessEqual[z, -1.5e+35], N[(x - N[(N[(y / (-z)), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -4e+25], N[(x - N[(N[(a / t), $MachinePrecision] * N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 5.5e+57], N[(x - N[(N[(y / N[(1.0 + t), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision], N[(x - a), $MachinePrecision]]]]]

Derivation

1. Split input into 4 regimes

2. if z < -2.30000000000000006e97 or 5.5000000000000002e57 < z

   1. Initial program 94.7%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -2.30000000000000006e97 < z < -1.49999999999999995e35

   1. Initial program 92.8%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   10. Taylor expanded in y around inf 0

       \[\leadsto expr\]

   12. Simplified 0

       \[\leadsto expr\]

   if -1.49999999999999995e35 < z < -4.00000000000000036e25

   1. Initial program 99.5%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   if -4.00000000000000036e25 < z < 5.5000000000000002e57

   1. Initial program 99.2%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

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

Alternative 5: 70.7% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x - a \cdot y\\ \mathbf{if}\;z \leq -6.4 \cdot 10^{+96}:\\ \;\;\;\;x - a\\ \mathbf{elif}\;z \leq -8.8 \cdot 10^{-271}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 4.2 \cdot 10^{-223}:\\ \;\;\;\;x - \frac{a}{t} \cdot y\\ \mathbf{elif}\;z \leq 1.08 \cdot 10^{+58}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;x - a\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (- x (* a y))))
   (if (<= z -6.4e+96)
     (- x a)
     (if (<= z -8.8e-271)
       t_1
       (if (<= z 4.2e-223)
         (- x (* (/ a t) y))
         (if (<= z 1.08e+58) t_1 (- x a)))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = x - (a * y);
	double tmp;
	if (z <= -6.4e+96) {
		tmp = x - a;
	} else if (z <= -8.8e-271) {
		tmp = t_1;
	} else if (z <= 4.2e-223) {
		tmp = x - ((a / t) * y);
	} else if (z <= 1.08e+58) {
		tmp = t_1;
	} else {
		tmp = x - a;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8) :: t_1
    real(8) :: tmp
    t_1 = x - (a * y)
    if (z <= (-6.4d+96)) then
        tmp = x - a
    else if (z <= (-8.8d-271)) then
        tmp = t_1
    else if (z <= 4.2d-223) then
        tmp = x - ((a / t) * y)
    else if (z <= 1.08d+58) then
        tmp = t_1
    else
        tmp = x - a
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double t_1 = x - (a * y);
	double tmp;
	if (z <= -6.4e+96) {
		tmp = x - a;
	} else if (z <= -8.8e-271) {
		tmp = t_1;
	} else if (z <= 4.2e-223) {
		tmp = x - ((a / t) * y);
	} else if (z <= 1.08e+58) {
		tmp = t_1;
	} else {
		tmp = x - a;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = x - (a * y)
	tmp = 0
	if z <= -6.4e+96:
		tmp = x - a
	elif z <= -8.8e-271:
		tmp = t_1
	elif z <= 4.2e-223:
		tmp = x - ((a / t) * y)
	elif z <= 1.08e+58:
		tmp = t_1
	else:
		tmp = x - a
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(x - Float64(a * y))
	tmp = 0.0
	if (z <= -6.4e+96)
		tmp = Float64(x - a);
	elseif (z <= -8.8e-271)
		tmp = t_1;
	elseif (z <= 4.2e-223)
		tmp = Float64(x - Float64(Float64(a / t) * y));
	elseif (z <= 1.08e+58)
		tmp = t_1;
	else
		tmp = Float64(x - a);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = x - (a * y);
	tmp = 0.0;
	if (z <= -6.4e+96)
		tmp = x - a;
	elseif (z <= -8.8e-271)
		tmp = t_1;
	elseif (z <= 4.2e-223)
		tmp = x - ((a / t) * y);
	elseif (z <= 1.08e+58)
		tmp = t_1;
	else
		tmp = x - a;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x - N[(a * y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -6.4e+96], N[(x - a), $MachinePrecision], If[LessEqual[z, -8.8e-271], t$95$1, If[LessEqual[z, 4.2e-223], N[(x - N[(N[(a / t), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.08e+58], t$95$1, N[(x - a), $MachinePrecision]]]]]]

Derivation

1. Split input into 3 regimes

2. if z < -6.40000000000000013e96 or 1.0799999999999999e58 < z

   1. Initial program 94.7%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -6.40000000000000013e96 < z < -8.7999999999999998e-271 or 4.19999999999999965e-223 < z < 1.0799999999999999e58

   1. Initial program 98.4%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -8.7999999999999998e-271 < z < 4.19999999999999965e-223

   1. Initial program 99.9%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   12. Applied egg-rr 0

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

Alternative 6: 88.8% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x - \frac{-z}{t - z} \cdot a\\ \mathbf{if}\;z \leq -4 \cdot 10^{+25}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 2.2:\\ \;\;\;\;x - \frac{y}{1 + t} \cdot a\\ \mathbf{elif}\;z \leq 8.5 \cdot 10^{+118}:\\ \;\;\;\;x - \frac{y - z}{-z} \cdot a\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (- x (* (/ (- z) (- t z)) a))))
   (if (<= z -4e+25)
     t_1
     (if (<= z 2.2)
       (- x (* (/ y (+ 1.0 t)) a))
       (if (<= z 8.5e+118) (- x (* (/ (- y z) (- z)) a)) t_1)))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = x - ((-z / (t - z)) * a);
	double tmp;
	if (z <= -4e+25) {
		tmp = t_1;
	} else if (z <= 2.2) {
		tmp = x - ((y / (1.0 + t)) * a);
	} else if (z <= 8.5e+118) {
		tmp = x - (((y - z) / -z) * a);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8) :: t_1
    real(8) :: tmp
    t_1 = x - ((-z / (t - z)) * a)
    if (z <= (-4d+25)) then
        tmp = t_1
    else if (z <= 2.2d0) then
        tmp = x - ((y / (1.0d0 + t)) * a)
    else if (z <= 8.5d+118) then
        tmp = x - (((y - z) / -z) * a)
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double t_1 = x - ((-z / (t - z)) * a);
	double tmp;
	if (z <= -4e+25) {
		tmp = t_1;
	} else if (z <= 2.2) {
		tmp = x - ((y / (1.0 + t)) * a);
	} else if (z <= 8.5e+118) {
		tmp = x - (((y - z) / -z) * a);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = x - ((-z / (t - z)) * a)
	tmp = 0
	if z <= -4e+25:
		tmp = t_1
	elif z <= 2.2:
		tmp = x - ((y / (1.0 + t)) * a)
	elif z <= 8.5e+118:
		tmp = x - (((y - z) / -z) * a)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(x - Float64(Float64(Float64(-z) / Float64(t - z)) * a))
	tmp = 0.0
	if (z <= -4e+25)
		tmp = t_1;
	elseif (z <= 2.2)
		tmp = Float64(x - Float64(Float64(y / Float64(1.0 + t)) * a));
	elseif (z <= 8.5e+118)
		tmp = Float64(x - Float64(Float64(Float64(y - z) / Float64(-z)) * a));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = x - ((-z / (t - z)) * a);
	tmp = 0.0;
	if (z <= -4e+25)
		tmp = t_1;
	elseif (z <= 2.2)
		tmp = x - ((y / (1.0 + t)) * a);
	elseif (z <= 8.5e+118)
		tmp = x - (((y - z) / -z) * a);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x - N[(N[((-z) / N[(t - z), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -4e+25], t$95$1, If[LessEqual[z, 2.2], N[(x - N[(N[(y / N[(1.0 + t), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 8.5e+118], N[(x - N[(N[(N[(y - z), $MachinePrecision] / (-z)), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

Derivation

1. Split input into 3 regimes

2. if z < -4.00000000000000036e25 or 8.50000000000000033e118 < z

   1. Initial program 94.6%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   10. Taylor expanded in y around 0 0

       \[\leadsto expr\]

   12. Simplified 0

       \[\leadsto expr\]

   if -4.00000000000000036e25 < z < 2.2000000000000002

   1. Initial program 99.9%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   if 2.2000000000000002 < z < 8.50000000000000033e118

   1. Initial program 94.3%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   9. Simplified 0

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

Alternative 7: 94.4% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -6.2 \cdot 10^{+68}:\\ \;\;\;\;x - \frac{y - z}{-z} \cdot a\\ \mathbf{elif}\;z \leq 1:\\ \;\;\;\;x - \frac{y - z}{\frac{1 + t}{a}}\\ \mathbf{else}:\\ \;\;\;\;x - \frac{a}{t - z} \cdot \left(y - z\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= z -6.2e+68)
   (- x (* (/ (- y z) (- z)) a))
   (if (<= z 1.0)
     (- x (/ (- y z) (/ (+ 1.0 t) a)))
     (- x (* (/ a (- t z)) (- y z))))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -6.2e+68) {
		tmp = x - (((y - z) / -z) * a);
	} else if (z <= 1.0) {
		tmp = x - ((y - z) / ((1.0 + t) / a));
	} else {
		tmp = x - ((a / (t - z)) * (y - z));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8) :: tmp
    if (z <= (-6.2d+68)) then
        tmp = x - (((y - z) / -z) * a)
    else if (z <= 1.0d0) then
        tmp = x - ((y - z) / ((1.0d0 + t) / a))
    else
        tmp = x - ((a / (t - z)) * (y - z))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -6.2e+68) {
		tmp = x - (((y - z) / -z) * a);
	} else if (z <= 1.0) {
		tmp = x - ((y - z) / ((1.0 + t) / a));
	} else {
		tmp = x - ((a / (t - z)) * (y - z));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if z <= -6.2e+68:
		tmp = x - (((y - z) / -z) * a)
	elif z <= 1.0:
		tmp = x - ((y - z) / ((1.0 + t) / a))
	else:
		tmp = x - ((a / (t - z)) * (y - z))
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (z <= -6.2e+68)
		tmp = Float64(x - Float64(Float64(Float64(y - z) / Float64(-z)) * a));
	elseif (z <= 1.0)
		tmp = Float64(x - Float64(Float64(y - z) / Float64(Float64(1.0 + t) / a)));
	else
		tmp = Float64(x - Float64(Float64(a / Float64(t - z)) * Float64(y - z)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (z <= -6.2e+68)
		tmp = x - (((y - z) / -z) * a);
	elseif (z <= 1.0)
		tmp = x - ((y - z) / ((1.0 + t) / a));
	else
		tmp = x - ((a / (t - z)) * (y - z));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[z, -6.2e+68], N[(x - N[(N[(N[(y - z), $MachinePrecision] / (-z)), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.0], N[(x - N[(N[(y - z), $MachinePrecision] / N[(N[(1.0 + t), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x - N[(N[(a / N[(t - z), $MachinePrecision]), $MachinePrecision] * N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if z < -6.1999999999999997e68

   1. Initial program 93.1%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   if -6.1999999999999997e68 < z < 1

   1. Initial program 99.9%

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

   3. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 1 < z

   1. Initial program 94.7%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   11. Applied egg-rr 0

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

Alternative 8: 93.2% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x - \frac{a}{t - z} \cdot \left(y - z\right)\\ \mathbf{if}\;z \leq -1.05 \cdot 10^{-43}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 0.0048:\\ \;\;\;\;x - \frac{y}{1 + t} \cdot a\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (- x (* (/ a (- t z)) (- y z)))))
   (if (<= z -1.05e-43)
     t_1
     (if (<= z 0.0048) (- x (* (/ y (+ 1.0 t)) a)) t_1))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = x - ((a / (t - z)) * (y - z));
	double tmp;
	if (z <= -1.05e-43) {
		tmp = t_1;
	} else if (z <= 0.0048) {
		tmp = x - ((y / (1.0 + t)) * a);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8) :: t_1
    real(8) :: tmp
    t_1 = x - ((a / (t - z)) * (y - z))
    if (z <= (-1.05d-43)) then
        tmp = t_1
    else if (z <= 0.0048d0) then
        tmp = x - ((y / (1.0d0 + t)) * a)
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double t_1 = x - ((a / (t - z)) * (y - z));
	double tmp;
	if (z <= -1.05e-43) {
		tmp = t_1;
	} else if (z <= 0.0048) {
		tmp = x - ((y / (1.0 + t)) * a);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = x - ((a / (t - z)) * (y - z))
	tmp = 0
	if z <= -1.05e-43:
		tmp = t_1
	elif z <= 0.0048:
		tmp = x - ((y / (1.0 + t)) * a)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(x - Float64(Float64(a / Float64(t - z)) * Float64(y - z)))
	tmp = 0.0
	if (z <= -1.05e-43)
		tmp = t_1;
	elseif (z <= 0.0048)
		tmp = Float64(x - Float64(Float64(y / Float64(1.0 + t)) * a));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = x - ((a / (t - z)) * (y - z));
	tmp = 0.0;
	if (z <= -1.05e-43)
		tmp = t_1;
	elseif (z <= 0.0048)
		tmp = x - ((y / (1.0 + t)) * a);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x - N[(N[(a / N[(t - z), $MachinePrecision]), $MachinePrecision] * N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.05e-43], t$95$1, If[LessEqual[z, 0.0048], N[(x - N[(N[(y / N[(1.0 + t), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision], t$95$1]]]

Derivation

1. Split input into 2 regimes

2. if z < -1.05e-43 or 0.00479999999999999958 < z

   1. Initial program 95.2%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   11. Applied egg-rr 0

       \[\leadsto expr\]

   if -1.05e-43 < z < 0.00479999999999999958

   1. Initial program 99.9%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

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

Alternative 9: 88.6% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x - \frac{-z}{t - z} \cdot a\\ \mathbf{if}\;z \leq -4 \cdot 10^{+25}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 2.45 \cdot 10^{-8}:\\ \;\;\;\;x - \frac{y}{1 + t} \cdot a\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (- x (* (/ (- z) (- t z)) a))))
   (if (<= z -4e+25) t_1 (if (<= z 2.45e-8) (- x (* (/ y (+ 1.0 t)) a)) t_1))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = x - ((-z / (t - z)) * a);
	double tmp;
	if (z <= -4e+25) {
		tmp = t_1;
	} else if (z <= 2.45e-8) {
		tmp = x - ((y / (1.0 + t)) * a);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8) :: t_1
    real(8) :: tmp
    t_1 = x - ((-z / (t - z)) * a)
    if (z <= (-4d+25)) then
        tmp = t_1
    else if (z <= 2.45d-8) then
        tmp = x - ((y / (1.0d0 + t)) * a)
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double t_1 = x - ((-z / (t - z)) * a);
	double tmp;
	if (z <= -4e+25) {
		tmp = t_1;
	} else if (z <= 2.45e-8) {
		tmp = x - ((y / (1.0 + t)) * a);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = x - ((-z / (t - z)) * a)
	tmp = 0
	if z <= -4e+25:
		tmp = t_1
	elif z <= 2.45e-8:
		tmp = x - ((y / (1.0 + t)) * a)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(x - Float64(Float64(Float64(-z) / Float64(t - z)) * a))
	tmp = 0.0
	if (z <= -4e+25)
		tmp = t_1;
	elseif (z <= 2.45e-8)
		tmp = Float64(x - Float64(Float64(y / Float64(1.0 + t)) * a));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = x - ((-z / (t - z)) * a);
	tmp = 0.0;
	if (z <= -4e+25)
		tmp = t_1;
	elseif (z <= 2.45e-8)
		tmp = x - ((y / (1.0 + t)) * a);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x - N[(N[((-z) / N[(t - z), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -4e+25], t$95$1, If[LessEqual[z, 2.45e-8], N[(x - N[(N[(y / N[(1.0 + t), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision], t$95$1]]]

Derivation

1. Split input into 2 regimes

2. if z < -4.00000000000000036e25 or 2.4500000000000001e-8 < z

   1. Initial program 94.6%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   10. Taylor expanded in y around 0 0

       \[\leadsto expr\]

   12. Simplified 0

       \[\leadsto expr\]

   if -4.00000000000000036e25 < z < 2.4500000000000001e-8

   1. Initial program 99.9%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

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

Alternative 10: 71.8% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -6.4 \cdot 10^{+96}:\\ \;\;\;\;x - a\\ \mathbf{elif}\;z \leq 5.1 \cdot 10^{+57}:\\ \;\;\;\;x - a \cdot y\\ \mathbf{else}:\\ \;\;\;\;x - a\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= z -6.4e+96) (- x a) (if (<= z 5.1e+57) (- x (* a y)) (- x a))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -6.4e+96) {
		tmp = x - a;
	} else if (z <= 5.1e+57) {
		tmp = x - (a * y);
	} else {
		tmp = x - a;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8) :: tmp
    if (z <= (-6.4d+96)) then
        tmp = x - a
    else if (z <= 5.1d+57) then
        tmp = x - (a * y)
    else
        tmp = x - a
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -6.4e+96) {
		tmp = x - a;
	} else if (z <= 5.1e+57) {
		tmp = x - (a * y);
	} else {
		tmp = x - a;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if z <= -6.4e+96:
		tmp = x - a
	elif z <= 5.1e+57:
		tmp = x - (a * y)
	else:
		tmp = x - a
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (z <= -6.4e+96)
		tmp = Float64(x - a);
	elseif (z <= 5.1e+57)
		tmp = Float64(x - Float64(a * y));
	else
		tmp = Float64(x - a);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (z <= -6.4e+96)
		tmp = x - a;
	elseif (z <= 5.1e+57)
		tmp = x - (a * y);
	else
		tmp = x - a;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[z, -6.4e+96], N[(x - a), $MachinePrecision], If[LessEqual[z, 5.1e+57], N[(x - N[(a * y), $MachinePrecision]), $MachinePrecision], N[(x - a), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if z < -6.40000000000000013e96 or 5.10000000000000023e57 < z

   1. Initial program 94.7%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -6.40000000000000013e96 < z < 5.10000000000000023e57

   1. Initial program 98.7%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

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

Alternative 11: 65.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -3900000000:\\ \;\;\;\;x - a\\ \mathbf{elif}\;z \leq 5.1 \cdot 10^{+57}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;x - a\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= z -3900000000.0) (- x a) (if (<= z 5.1e+57) x (- x a))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -3900000000.0) {
		tmp = x - a;
	} else if (z <= 5.1e+57) {
		tmp = x;
	} else {
		tmp = x - a;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8) :: tmp
    if (z <= (-3900000000.0d0)) then
        tmp = x - a
    else if (z <= 5.1d+57) then
        tmp = x
    else
        tmp = x - a
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -3900000000.0) {
		tmp = x - a;
	} else if (z <= 5.1e+57) {
		tmp = x;
	} else {
		tmp = x - a;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if z <= -3900000000.0:
		tmp = x - a
	elif z <= 5.1e+57:
		tmp = x
	else:
		tmp = x - a
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (z <= -3900000000.0)
		tmp = Float64(x - a);
	elseif (z <= 5.1e+57)
		tmp = x;
	else
		tmp = Float64(x - a);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (z <= -3900000000.0)
		tmp = x - a;
	elseif (z <= 5.1e+57)
		tmp = x;
	else
		tmp = x - a;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[z, -3900000000.0], N[(x - a), $MachinePrecision], If[LessEqual[z, 5.1e+57], x, N[(x - a), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if z < -3.9e9 or 5.10000000000000023e57 < z

   1. Initial program 94.7%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -3.9e9 < z < 5.10000000000000023e57

   1. Initial program 99.2%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

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

Alternative 12: 99.7% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 97.3%

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

3. Simplified 0

   \[\leadsto expr\]
4. Add Preprocessing

6. Applied egg-rr 0

   \[\leadsto expr\]
7. Add Preprocessing

Alternative 13: 97.1% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 97.3%

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

3. Simplified 0

   \[\leadsto expr\]
4. Add Preprocessing

6. Applied egg-rr 0

   \[\leadsto expr\]
7. Add Preprocessing

Alternative 14: 54.9% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -1.35 \cdot 10^{-207}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 6.8 \cdot 10^{-186}:\\ \;\;\;\;-a\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= x -1.35e-207) x (if (<= x 6.8e-186) (- a) x)))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (x <= -1.35e-207) {
		tmp = x;
	} else if (x <= 6.8e-186) {
		tmp = -a;
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8) :: tmp
    if (x <= (-1.35d-207)) then
        tmp = x
    else if (x <= 6.8d-186) then
        tmp = -a
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (x <= -1.35e-207) {
		tmp = x;
	} else if (x <= 6.8e-186) {
		tmp = -a;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if x <= -1.35e-207:
		tmp = x
	elif x <= 6.8e-186:
		tmp = -a
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (x <= -1.35e-207)
		tmp = x;
	elseif (x <= 6.8e-186)
		tmp = Float64(-a);
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (x <= -1.35e-207)
		tmp = x;
	elseif (x <= 6.8e-186)
		tmp = -a;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[x, -1.35e-207], x, If[LessEqual[x, 6.8e-186], (-a), x]]

Derivation

1. Split input into 2 regimes

2. if x < -1.35e-207 or 6.7999999999999999e-186 < x

   1. Initial program 99.4%

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

   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.35e-207 < x < 6.7999999999999999e-186

   1. Initial program 90.0%

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

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x 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 15: 53.0% accurate, 13.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 97.3%

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

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: 99.7% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Reproduce

herbie shell --seed 2024110 
(FPCore (x y z t a)
  :name "Graphics.Rendering.Chart.SparkLine:renderSparkLine from Chart-1.5.3"
  :precision binary64

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

  (- x (/ (- y z) (/ (+ (- t z) 1.0) a))))