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

Percentage Accurate: 97.0% → 99.7%

Time: 10.3s

Alternatives: 12

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

Math

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

FPCore

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

C

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

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 95.7%

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

   1. associate-/r/ 99.6%

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

3. Simplified 99.6%

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

4. Final simplification 99.6%

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

Alternative 2: 88.0% accurate, 0.9× speedup

Math

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

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (or (<= z -9e-29) (not (<= z 1.05e-11)))
   (+ x (/ a (/ (+ (- t z) 1.0) z)))
   (- x (* a (/ y (+ t 1.0))))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((z <= -9e-29) || !(z <= 1.05e-11)) {
		tmp = x + (a / (((t - z) + 1.0) / z));
	} else {
		tmp = x - (a * (y / (t + 1.0)));
	}
	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 <= (-9d-29)) .or. (.not. (z <= 1.05d-11))) then
        tmp = x + (a / (((t - z) + 1.0d0) / z))
    else
        tmp = x - (a * (y / (t + 1.0d0)))
    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 <= -9e-29) || !(z <= 1.05e-11)) {
		tmp = x + (a / (((t - z) + 1.0) / z));
	} else {
		tmp = x - (a * (y / (t + 1.0)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if (z <= -9e-29) or not (z <= 1.05e-11):
		tmp = x + (a / (((t - z) + 1.0) / z))
	else:
		tmp = x - (a * (y / (t + 1.0)))
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if ((z <= -9e-29) || !(z <= 1.05e-11))
		tmp = Float64(x + Float64(a / Float64(Float64(Float64(t - z) + 1.0) / z)));
	else
		tmp = Float64(x - Float64(a * Float64(y / Float64(t + 1.0))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if ((z <= -9e-29) || ~((z <= 1.05e-11)))
		tmp = x + (a / (((t - z) + 1.0) / z));
	else
		tmp = x - (a * (y / (t + 1.0)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -9e-29], N[Not[LessEqual[z, 1.05e-11]], $MachinePrecision]], N[(x + N[(a / N[(N[(N[(t - z), $MachinePrecision] + 1.0), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x - N[(a * N[(y / N[(t + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if z < -8.9999999999999996e-29 or 1.0499999999999999e-11 < z

   1. Initial program 91.9%

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

      1. associate-/r/ 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in y around 0 67.5%

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

      1. sub-neg 67.5%

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

      2. mul-1-neg 67.5%

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

      3. *-commutative 67.5%

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

      4. associate--l+ 67.5%

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

      5. +-commutative 67.5%

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

      6. associate-*r/ 81.0%

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

      7. remove-double-neg 81.0%

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

      8. associate-*r/ 67.5%

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

      9. *-commutative 67.5%

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

      10. +-commutative 67.5%

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

      11. associate--l+ 67.5%

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

      12. associate-/l* 87.2%

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

      13. associate--l+ 87.2%

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

   6. Simplified 87.2%

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

   if -8.9999999999999996e-29 < z < 1.0499999999999999e-11

   1. Initial program 99.9%

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

      1. associate-/r/ 99.2%

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

   3. Simplified 99.2%

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

   4. Taylor expanded in z around 0 96.9%

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

4. Final simplification 91.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -9 \cdot 10^{-29} \lor \neg \left(z \leq 1.05 \cdot 10^{-11}\right):\\ \;\;\;\;x + \frac{a}{\frac{\left(t - z\right) + 1}{z}}\\ \mathbf{else}:\\ \;\;\;\;x - a \cdot \frac{y}{t + 1}\\ \end{array} \]

Alternative 3: 89.0% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(t - z\right) + 1\\ \mathbf{if}\;z \leq -2.4 \cdot 10^{+38} \lor \neg \left(z \leq 3.7 \cdot 10^{+76}\right):\\ \;\;\;\;x + \frac{a}{\frac{t_1}{z}}\\ \mathbf{else}:\\ \;\;\;\;x - y \cdot \frac{a}{t_1}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (let* ((t_1 (+ (- t z) 1.0)))
   (if (or (<= z -2.4e+38) (not (<= z 3.7e+76)))
     (+ x (/ a (/ t_1 z)))
     (- x (* y (/ a t_1))))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = (t - z) + 1.0;
	double tmp;
	if ((z <= -2.4e+38) || !(z <= 3.7e+76)) {
		tmp = x + (a / (t_1 / z));
	} else {
		tmp = x - (y * (a / 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 = (t - z) + 1.0d0
    if ((z <= (-2.4d+38)) .or. (.not. (z <= 3.7d+76))) then
        tmp = x + (a / (t_1 / z))
    else
        tmp = x - (y * (a / 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 = (t - z) + 1.0;
	double tmp;
	if ((z <= -2.4e+38) || !(z <= 3.7e+76)) {
		tmp = x + (a / (t_1 / z));
	} else {
		tmp = x - (y * (a / t_1));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = (t - z) + 1.0
	tmp = 0
	if (z <= -2.4e+38) or not (z <= 3.7e+76):
		tmp = x + (a / (t_1 / z))
	else:
		tmp = x - (y * (a / t_1))
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(Float64(t - z) + 1.0)
	tmp = 0.0
	if ((z <= -2.4e+38) || !(z <= 3.7e+76))
		tmp = Float64(x + Float64(a / Float64(t_1 / z)));
	else
		tmp = Float64(x - Float64(y * Float64(a / t_1)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = (t - z) + 1.0;
	tmp = 0.0;
	if ((z <= -2.4e+38) || ~((z <= 3.7e+76)))
		tmp = x + (a / (t_1 / z));
	else
		tmp = x - (y * (a / t_1));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if z < -2.40000000000000017e38 or 3.6999999999999999e76 < z

   1. Initial program 90.5%

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

      1. associate-/r/ 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in y around 0 66.3%

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

      1. sub-neg 66.3%

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

      2. mul-1-neg 66.3%

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

      3. *-commutative 66.3%

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

      4. associate--l+ 66.3%

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

      5. +-commutative 66.3%

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

      6. associate-*r/ 83.1%

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

      7. remove-double-neg 83.1%

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

      8. associate-*r/ 66.3%

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

      9. *-commutative 66.3%

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

      10. +-commutative 66.3%

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

      11. associate--l+ 66.3%

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

      12. associate-/l* 90.8%

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

      13. associate--l+ 90.8%

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

   6. Simplified 90.8%

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

   if -2.40000000000000017e38 < z < 3.6999999999999999e76

   1. Initial program 99.4%

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

      1. associate-/r/ 99.3%

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

   3. Simplified 99.3%

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

   4. Taylor expanded in y around inf 91.4%

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

      1. *-commutative 91.4%

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

      2. associate--l+ 91.4%

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

      3. +-commutative 91.4%

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

      4. associate-*r/ 93.6%

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

      5. +-commutative 93.6%

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

   6. Simplified 93.6%

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

4. Final simplification 92.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -2.4 \cdot 10^{+38} \lor \neg \left(z \leq 3.7 \cdot 10^{+76}\right):\\ \;\;\;\;x + \frac{a}{\frac{\left(t - z\right) + 1}{z}}\\ \mathbf{else}:\\ \;\;\;\;x - y \cdot \frac{a}{\left(t - z\right) + 1}\\ \end{array} \]

Alternative 4: 89.2% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -1.95 \cdot 10^{-32} \lor \neg \left(z \leq 1.75 \cdot 10^{+56}\right):\\ \;\;\;\;x + a \cdot \frac{z - y}{1 - z}\\ \mathbf{else}:\\ \;\;\;\;x - y \cdot \frac{a}{\left(t - z\right) + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (or (<= z -1.95e-32) (not (<= z 1.75e+56)))
   (+ x (* a (/ (- z y) (- 1.0 z))))
   (- x (* y (/ a (+ (- t z) 1.0))))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((z <= -1.95e-32) || !(z <= 1.75e+56)) {
		tmp = x + (a * ((z - y) / (1.0 - z)));
	} else {
		tmp = x - (y * (a / ((t - z) + 1.0)));
	}
	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 <= (-1.95d-32)) .or. (.not. (z <= 1.75d+56))) then
        tmp = x + (a * ((z - y) / (1.0d0 - z)))
    else
        tmp = x - (y * (a / ((t - z) + 1.0d0)))
    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 <= -1.95e-32) || !(z <= 1.75e+56)) {
		tmp = x + (a * ((z - y) / (1.0 - z)));
	} else {
		tmp = x - (y * (a / ((t - z) + 1.0)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if (z <= -1.95e-32) or not (z <= 1.75e+56):
		tmp = x + (a * ((z - y) / (1.0 - z)))
	else:
		tmp = x - (y * (a / ((t - z) + 1.0)))
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if ((z <= -1.95e-32) || !(z <= 1.75e+56))
		tmp = Float64(x + Float64(a * Float64(Float64(z - y) / Float64(1.0 - z))));
	else
		tmp = Float64(x - Float64(y * Float64(a / Float64(Float64(t - z) + 1.0))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if ((z <= -1.95e-32) || ~((z <= 1.75e+56)))
		tmp = x + (a * ((z - y) / (1.0 - z)));
	else
		tmp = x - (y * (a / ((t - z) + 1.0)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -1.95e-32], N[Not[LessEqual[z, 1.75e+56]], $MachinePrecision]], N[(x + N[(a * N[(N[(z - y), $MachinePrecision] / N[(1.0 - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x - N[(y * N[(a / N[(N[(t - z), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if z < -1.9500000000000001e-32 or 1.75e56 < z

   1. Initial program 91.7%

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

      1. associate-/r/ 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in t around 0 95.4%

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

   if -1.9500000000000001e-32 < z < 1.75e56

   1. Initial program 99.4%

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

      1. associate-/r/ 99.2%

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

   3. Simplified 99.2%

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

   4. Taylor expanded in y around inf 93.6%

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

      1. *-commutative 93.6%

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

      2. associate--l+ 93.6%

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

      3. +-commutative 93.6%

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

      4. associate-*r/ 95.3%

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

      5. +-commutative 95.3%

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

   6. Simplified 95.3%

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

4. Final simplification 95.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -1.95 \cdot 10^{-32} \lor \neg \left(z \leq 1.75 \cdot 10^{+56}\right):\\ \;\;\;\;x + a \cdot \frac{z - y}{1 - z}\\ \mathbf{else}:\\ \;\;\;\;x - y \cdot \frac{a}{\left(t - z\right) + 1}\\ \end{array} \]

Alternative 5: 87.1% accurate, 0.9× speedup

Math

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

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (or (<= z -920.0) (not (<= z 2e+24)))
   (+ x (/ (- z y) (/ (- z) a)))
   (- x (* a (/ y (+ t 1.0))))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((z <= -920.0) || !(z <= 2e+24)) {
		tmp = x + ((z - y) / (-z / a));
	} else {
		tmp = x - (a * (y / (t + 1.0)));
	}
	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 <= (-920.0d0)) .or. (.not. (z <= 2d+24))) then
        tmp = x + ((z - y) / (-z / a))
    else
        tmp = x - (a * (y / (t + 1.0d0)))
    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 <= -920.0) || !(z <= 2e+24)) {
		tmp = x + ((z - y) / (-z / a));
	} else {
		tmp = x - (a * (y / (t + 1.0)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if (z <= -920.0) or not (z <= 2e+24):
		tmp = x + ((z - y) / (-z / a))
	else:
		tmp = x - (a * (y / (t + 1.0)))
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if ((z <= -920.0) || !(z <= 2e+24))
		tmp = Float64(x + Float64(Float64(z - y) / Float64(Float64(-z) / a)));
	else
		tmp = Float64(x - Float64(a * Float64(y / Float64(t + 1.0))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if ((z <= -920.0) || ~((z <= 2e+24)))
		tmp = x + ((z - y) / (-z / a));
	else
		tmp = x - (a * (y / (t + 1.0)));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if z < -920 or 2e24 < z

   1. Initial program 91.2%

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

   2. Taylor expanded in z around inf 85.3%

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

      1. mul-1-neg 85.3%

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

      2. distribute-neg-frac 85.3%

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

   4. Simplified 85.3%

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

   if -920 < z < 2e24

   1. Initial program 99.9%

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

      1. associate-/r/ 99.2%

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

   3. Simplified 99.2%

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

   4. Taylor expanded in z around 0 93.8%

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

4. Final simplification 89.8%

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

Alternative 6: 73.5% accurate, 1.0× speedup

Math

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

FPCore

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

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((z <= -6.2e-34) || !(z <= 0.024)) {
		tmp = x + (a / ((1.0 - z) / z));
	} else {
		tmp = x - (y * 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.2d-34)) .or. (.not. (z <= 0.024d0))) then
        tmp = x + (a / ((1.0d0 - z) / z))
    else
        tmp = x - (y * 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.2e-34) || !(z <= 0.024)) {
		tmp = x + (a / ((1.0 - z) / z));
	} else {
		tmp = x - (y * a);
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if z < -6.1999999999999996e-34 or 0.024 < z

   1. Initial program 91.8%

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

      1. associate-/r/ 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in t around 0 92.9%

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

   5. Taylor expanded in y around 0 64.3%

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

      1. sub-neg 64.3%

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

      2. mul-1-neg 64.3%

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

      3. remove-double-neg 64.3%

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

      4. associate-/l* 82.7%

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

   7. Simplified 82.7%

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

   if -6.1999999999999996e-34 < z < 0.024

   1. Initial program 99.9%

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

      1. associate-/r/ 99.2%

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

   3. Simplified 99.2%

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

   4. Taylor expanded in t around 0 85.0%

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

   5. Taylor expanded in z around 0 83.8%

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

4. Final simplification 83.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -6.2 \cdot 10^{-34} \lor \neg \left(z \leq 0.024\right):\\ \;\;\;\;x + \frac{a}{\frac{1 - z}{z}}\\ \mathbf{else}:\\ \;\;\;\;x - y \cdot a\\ \end{array} \]

Alternative 7: 83.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -2.2 \cdot 10^{-29} \lor \neg \left(z \leq 0.0095\right):\\ \;\;\;\;x + \frac{a}{\frac{1 - z}{z}}\\ \mathbf{else}:\\ \;\;\;\;x - a \cdot \frac{y}{t + 1}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (or (<= z -2.2e-29) (not (<= z 0.0095)))
   (+ x (/ a (/ (- 1.0 z) z)))
   (- x (* a (/ y (+ t 1.0))))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((z <= -2.2e-29) || !(z <= 0.0095)) {
		tmp = x + (a / ((1.0 - z) / z));
	} else {
		tmp = x - (a * (y / (t + 1.0)));
	}
	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.2d-29)) .or. (.not. (z <= 0.0095d0))) then
        tmp = x + (a / ((1.0d0 - z) / z))
    else
        tmp = x - (a * (y / (t + 1.0d0)))
    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.2e-29) || !(z <= 0.0095)) {
		tmp = x + (a / ((1.0 - z) / z));
	} else {
		tmp = x - (a * (y / (t + 1.0)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if (z <= -2.2e-29) or not (z <= 0.0095):
		tmp = x + (a / ((1.0 - z) / z))
	else:
		tmp = x - (a * (y / (t + 1.0)))
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if ((z <= -2.2e-29) || !(z <= 0.0095))
		tmp = Float64(x + Float64(a / Float64(Float64(1.0 - z) / z)));
	else
		tmp = Float64(x - Float64(a * Float64(y / Float64(t + 1.0))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if ((z <= -2.2e-29) || ~((z <= 0.0095)))
		tmp = x + (a / ((1.0 - z) / z));
	else
		tmp = x - (a * (y / (t + 1.0)));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if z < -2.1999999999999999e-29 or 0.00949999999999999976 < z

   1. Initial program 91.7%

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

      1. associate-/r/ 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in t around 0 93.5%

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

   5. Taylor expanded in y around 0 64.0%

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

      1. sub-neg 64.0%

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

      2. mul-1-neg 64.0%

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

      3. remove-double-neg 64.0%

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

      4. associate-/l* 82.5%

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

   7. Simplified 82.5%

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

   if -2.1999999999999999e-29 < z < 0.00949999999999999976

   1. Initial program 99.9%

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

      1. associate-/r/ 99.2%

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

   3. Simplified 99.2%

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

   4. Taylor expanded in z around 0 97.0%

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

4. Final simplification 89.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -2.2 \cdot 10^{-29} \lor \neg \left(z \leq 0.0095\right):\\ \;\;\;\;x + \frac{a}{\frac{1 - z}{z}}\\ \mathbf{else}:\\ \;\;\;\;x - a \cdot \frac{y}{t + 1}\\ \end{array} \]

Alternative 8: 73.2% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -6.8 \cdot 10^{-34}:\\ \;\;\;\;x - a\\ \mathbf{elif}\;z \leq 0.034:\\ \;\;\;\;x - y \cdot a\\ \mathbf{else}:\\ \;\;\;\;\left(x - a\right) - \frac{a}{z}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (<= z -6.8e-34)
   (- x a)
   (if (<= z 0.034) (- x (* y a)) (- (- x a) (/ a z)))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -6.8e-34) {
		tmp = x - a;
	} else if (z <= 0.034) {
		tmp = x - (y * a);
	} else {
		tmp = (x - a) - (a / 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.8d-34)) then
        tmp = x - a
    else if (z <= 0.034d0) then
        tmp = x - (y * a)
    else
        tmp = (x - a) - (a / 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.8e-34) {
		tmp = x - a;
	} else if (z <= 0.034) {
		tmp = x - (y * a);
	} else {
		tmp = (x - a) - (a / z);
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if z <= -6.8e-34:
		tmp = x - a
	elif z <= 0.034:
		tmp = x - (y * a)
	else:
		tmp = (x - a) - (a / z)
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (z <= -6.8e-34)
		tmp = Float64(x - a);
	elseif (z <= 0.034)
		tmp = Float64(x - Float64(y * a));
	else
		tmp = Float64(Float64(x - a) - Float64(a / z));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (z <= -6.8e-34)
		tmp = x - a;
	elseif (z <= 0.034)
		tmp = x - (y * a);
	else
		tmp = (x - a) - (a / z);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[z, -6.8e-34], N[(x - a), $MachinePrecision], If[LessEqual[z, 0.034], N[(x - N[(y * a), $MachinePrecision]), $MachinePrecision], N[(N[(x - a), $MachinePrecision] - N[(a / z), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if z < -6.8000000000000001e-34

   1. Initial program 92.2%

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

      1. associate-/r/ 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in z around inf 81.4%

      \[\leadsto x - \color{blue}{a} \]

   if -6.8000000000000001e-34 < z < 0.034000000000000002

   1. Initial program 99.9%

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

      1. associate-/r/ 99.2%

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

   3. Simplified 99.2%

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

   4. Taylor expanded in t around 0 85.0%

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

   5. Taylor expanded in z around 0 83.8%

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

   if 0.034000000000000002 < z

   1. Initial program 91.3%

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

   2. Taylor expanded in t around 0 83.3%

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

   3. Taylor expanded in y around 0 68.4%

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

      1. *-commutative 68.4%

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

      2. associate-*r/ 74.9%

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

      3. neg-mul-1 74.9%

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

      4. distribute-lft-neg-in 74.9%

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

      5. cancel-sign-sub 74.9%

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

   5. Simplified 74.9%

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

   6. Taylor expanded in z around inf 82.3%

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

      1. neg-mul-1 82.3%

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

      2. associate-+r+ 82.3%

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

      3. sub-neg 82.3%

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

      4. mul-1-neg 82.3%

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

      5. unsub-neg 82.3%

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

   8. Simplified 82.3%

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

4. Final simplification 82.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -6.8 \cdot 10^{-34}:\\ \;\;\;\;x - a\\ \mathbf{elif}\;z \leq 0.034:\\ \;\;\;\;x - y \cdot a\\ \mathbf{else}:\\ \;\;\;\;\left(x - a\right) - \frac{a}{z}\\ \end{array} \]

Alternative 9: 66.4% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -10000000000 \lor \neg \left(z \leq 7.5 \cdot 10^{-41}\right):\\ \;\;\;\;x - a\\ \mathbf{else}:\\ \;\;\;\;x + z \cdot a\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (or (<= z -10000000000.0) (not (<= z 7.5e-41))) (- x a) (+ x (* z a))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((z <= -10000000000.0) || !(z <= 7.5e-41)) {
		tmp = x - a;
	} else {
		tmp = x + (z * 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 <= (-10000000000.0d0)) .or. (.not. (z <= 7.5d-41))) then
        tmp = x - a
    else
        tmp = x + (z * 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 <= -10000000000.0) || !(z <= 7.5e-41)) {
		tmp = x - a;
	} else {
		tmp = x + (z * a);
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if (z <= -10000000000.0) or not (z <= 7.5e-41):
		tmp = x - a
	else:
		tmp = x + (z * a)
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if ((z <= -10000000000.0) || !(z <= 7.5e-41))
		tmp = Float64(x - a);
	else
		tmp = Float64(x + Float64(z * a));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if ((z <= -10000000000.0) || ~((z <= 7.5e-41)))
		tmp = x - a;
	else
		tmp = x + (z * a);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -10000000000.0], N[Not[LessEqual[z, 7.5e-41]], $MachinePrecision]], N[(x - a), $MachinePrecision], N[(x + N[(z * a), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if z < -1e10 or 7.50000000000000049e-41 < z

   1. Initial program 91.9%

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

      1. associate-/r/ 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in z around inf 80.6%

      \[\leadsto x - \color{blue}{a} \]

   if -1e10 < z < 7.50000000000000049e-41

   1. Initial program 99.9%

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

   2. Taylor expanded in t around 0 86.8%

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

   3. Taylor expanded in y around 0 64.5%

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

      1. *-commutative 64.5%

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

      2. associate-*r/ 64.5%

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

      3. neg-mul-1 64.5%

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

      4. distribute-lft-neg-in 64.5%

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

      5. cancel-sign-sub 64.5%

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

   5. Simplified 64.5%

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

   6. Taylor expanded in z around 0 64.5%

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

4. Final simplification 72.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -10000000000 \lor \neg \left(z \leq 7.5 \cdot 10^{-41}\right):\\ \;\;\;\;x - a\\ \mathbf{else}:\\ \;\;\;\;x + z \cdot a\\ \end{array} \]

Alternative 10: 73.1% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -6.8 \cdot 10^{-34} \lor \neg \left(z \leq 0.034\right):\\ \;\;\;\;x - a\\ \mathbf{else}:\\ \;\;\;\;x - y \cdot a\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (or (<= z -6.8e-34) (not (<= z 0.034))) (- x a) (- x (* y a))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((z <= -6.8e-34) || !(z <= 0.034)) {
		tmp = x - a;
	} else {
		tmp = x - (y * 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.8d-34)) .or. (.not. (z <= 0.034d0))) then
        tmp = x - a
    else
        tmp = x - (y * 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.8e-34) || !(z <= 0.034)) {
		tmp = x - a;
	} else {
		tmp = x - (y * a);
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if (z <= -6.8e-34) or not (z <= 0.034):
		tmp = x - a
	else:
		tmp = x - (y * a)
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if ((z <= -6.8e-34) || !(z <= 0.034))
		tmp = Float64(x - a);
	else
		tmp = Float64(x - Float64(y * a));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if ((z <= -6.8e-34) || ~((z <= 0.034)))
		tmp = x - a;
	else
		tmp = x - (y * a);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -6.8e-34], N[Not[LessEqual[z, 0.034]], $MachinePrecision]], N[(x - a), $MachinePrecision], N[(x - N[(y * a), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if z < -6.8000000000000001e-34 or 0.034000000000000002 < z

   1. Initial program 91.8%

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

      1. associate-/r/ 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in z around inf 81.6%

      \[\leadsto x - \color{blue}{a} \]

   if -6.8000000000000001e-34 < z < 0.034000000000000002

   1. Initial program 99.9%

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

      1. associate-/r/ 99.2%

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

   3. Simplified 99.2%

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

   4. Taylor expanded in t around 0 85.0%

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

   5. Taylor expanded in z around 0 83.8%

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

4. Final simplification 82.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -6.8 \cdot 10^{-34} \lor \neg \left(z \leq 0.034\right):\\ \;\;\;\;x - a\\ \mathbf{else}:\\ \;\;\;\;x - y \cdot a\\ \end{array} \]

Alternative 11: 65.7% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -7.2 \cdot 10^{+48} \lor \neg \left(z \leq 1.42 \cdot 10^{+50}\right):\\ \;\;\;\;x - a\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a)
 :precision binary64
 (if (or (<= z -7.2e+48) (not (<= z 1.42e+50))) (- x a) x))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if ((z <= -7.2e+48) || !(z <= 1.42e+50)) {
		tmp = x - 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 ((z <= (-7.2d+48)) .or. (.not. (z <= 1.42d+50))) then
        tmp = x - 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 ((z <= -7.2e+48) || !(z <= 1.42e+50)) {
		tmp = x - a;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if (z <= -7.2e+48) or not (z <= 1.42e+50):
		tmp = x - a
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if ((z <= -7.2e+48) || !(z <= 1.42e+50))
		tmp = Float64(x - a);
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if ((z <= -7.2e+48) || ~((z <= 1.42e+50)))
		tmp = x - a;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -7.2e+48], N[Not[LessEqual[z, 1.42e+50]], $MachinePrecision]], N[(x - a), $MachinePrecision], x]

Derivation

1. Split input into 2 regimes

2. if z < -7.19999999999999967e48 or 1.41999999999999994e50 < z

   1. Initial program 90.4%

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

      1. associate-/r/ 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in z around inf 87.0%

      \[\leadsto x - \color{blue}{a} \]

   if -7.19999999999999967e48 < z < 1.41999999999999994e50

   1. Initial program 99.5%

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

      1. associate-/r/ 99.3%

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

   3. Simplified 99.3%

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

   4. Taylor expanded in x around inf 62.6%

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

4. Final simplification 72.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -7.2 \cdot 10^{+48} \lor \neg \left(z \leq 1.42 \cdot 10^{+50}\right):\\ \;\;\;\;x - a\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]

Alternative 12: 53.6% 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 95.7%

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

   1. associate-/r/ 99.6%

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

3. Simplified 99.6%

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

4. Taylor expanded in x around inf 54.3%

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

5. Final simplification 54.3%

   \[\leadsto x \]

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 2023312 
(FPCore (x y z t a)
  :name "Graphics.Rendering.Chart.SparkLine:renderSparkLine from Chart-1.5.3"
  :precision binary64

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

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