Development.Shake.Progress:decay from shake-0.15.5

Percentage Accurate: 66.9% → 91.5%

Time: 19.3s

Alternatives: 19

Speedup: 1.3×

Specification

Math

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

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t, a, b)
    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), intent (in) :: b
    code = ((x * y) + (z * (t - a))) / (y + (z * (b - y)))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 66.9% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t, a, b)
    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), intent (in) :: b
    code = ((x * y) + (z * (t - a))) / (y + (z * (b - y)))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 91.5% accurate, 0.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -8.8 \cdot 10^{+104}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;z \leq 1.4 \cdot 10^{+19}:\\ \;\;\;\;\frac{x}{\frac{\mathsf{fma}\left(z, b - y, y\right)}{y}} + \frac{z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)}\\ \mathbf{else}:\\ \;\;\;\;\left(t_1 + \frac{y \cdot \frac{x}{z}}{b - y}\right) + \frac{y}{z} \cdot \frac{a - t}{{\left(b - y\right)}^{2}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ (- t a) (- b y))))
   (if (<= z -8.8e+104)
     t_1
     (if (<= z 1.4e+19)
       (+ (/ x (/ (fma z (- b y) y) y)) (/ (* z (- t a)) (+ y (* z (- b y)))))
       (+
        (+ t_1 (/ (* y (/ x z)) (- b y)))
        (* (/ y z) (/ (- a t) (pow (- b y) 2.0))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -8.8e+104) {
		tmp = t_1;
	} else if (z <= 1.4e+19) {
		tmp = (x / (fma(z, (b - y), y) / y)) + ((z * (t - a)) / (y + (z * (b - y))));
	} else {
		tmp = (t_1 + ((y * (x / z)) / (b - y))) + ((y / z) * ((a - t) / pow((b - y), 2.0)));
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -8.8e+104)
		tmp = t_1;
	elseif (z <= 1.4e+19)
		tmp = Float64(Float64(x / Float64(fma(z, Float64(b - y), y) / y)) + Float64(Float64(z * Float64(t - a)) / Float64(y + Float64(z * Float64(b - y)))));
	else
		tmp = Float64(Float64(t_1 + Float64(Float64(y * Float64(x / z)) / Float64(b - y))) + Float64(Float64(y / z) * Float64(Float64(a - t) / (Float64(b - y) ^ 2.0))));
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -8.8e+104], t$95$1, If[LessEqual[z, 1.4e+19], N[(N[(x / N[(N[(z * N[(b - y), $MachinePrecision] + y), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision] + N[(N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision] / N[(y + N[(z * N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(t$95$1 + N[(N[(y * N[(x / z), $MachinePrecision]), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(y / z), $MachinePrecision] * N[(N[(a - t), $MachinePrecision] / N[Power[N[(b - y), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 2: 90.1% accurate, 0.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -1.06 \cdot 10^{+105} \lor \neg \left(z \leq 3.3 \cdot 10^{+19}\right):\\ \;\;\;\;\frac{t - a}{b - y}\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{\frac{\mathsf{fma}\left(z, b - y, y\right)}{y}} + \frac{z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= z -1.06e+105) (not (<= z 3.3e+19)))
   (/ (- t a) (- b y))
   (+ (/ x (/ (fma z (- b y) y) y)) (/ (* z (- t a)) (+ y (* z (- b y)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -1.06e+105) || !(z <= 3.3e+19)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = (x / (fma(z, (b - y), y) / y)) + ((z * (t - a)) / (y + (z * (b - y))));
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((z <= -1.06e+105) || !(z <= 3.3e+19))
		tmp = Float64(Float64(t - a) / Float64(b - y));
	else
		tmp = Float64(Float64(x / Float64(fma(z, Float64(b - y), y) / y)) + Float64(Float64(z * Float64(t - a)) / Float64(y + Float64(z * Float64(b - y)))));
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[z, -1.06e+105], N[Not[LessEqual[z, 3.3e+19]], $MachinePrecision]], N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(N[(z * N[(b - y), $MachinePrecision] + y), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision] + N[(N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision] / N[(y + N[(z * N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 3: 83.9% accurate, 0.5× speedup

Math

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

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= z -8.2e+104) (not (<= z 5.6e+17)))
   (/ (- t a) (- b y))
   (+
    (/ (* y x) (+ y (* z (- b y))))
    (/ (* z (- t a)) (+ (* z b) (* y (- 1.0 z)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -8.2e+104) || !(z <= 5.6e+17)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = ((y * x) / (y + (z * (b - y)))) + ((z * (t - a)) / ((z * b) + (y * (1.0 - z))));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    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), intent (in) :: b
    real(8) :: tmp
    if ((z <= (-8.2d+104)) .or. (.not. (z <= 5.6d+17))) then
        tmp = (t - a) / (b - y)
    else
        tmp = ((y * x) / (y + (z * (b - y)))) + ((z * (t - a)) / ((z * b) + (y * (1.0d0 - z))))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -8.2e+104) || !(z <= 5.6e+17)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = ((y * x) / (y + (z * (b - y)))) + ((z * (t - a)) / ((z * b) + (y * (1.0 - z))));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (z <= -8.2e+104) or not (z <= 5.6e+17):
		tmp = (t - a) / (b - y)
	else:
		tmp = ((y * x) / (y + (z * (b - y)))) + ((z * (t - a)) / ((z * b) + (y * (1.0 - z))))
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((z <= -8.2e+104) || !(z <= 5.6e+17))
		tmp = Float64(Float64(t - a) / Float64(b - y));
	else
		tmp = Float64(Float64(Float64(y * x) / Float64(y + Float64(z * Float64(b - y)))) + Float64(Float64(z * Float64(t - a)) / Float64(Float64(z * b) + Float64(y * Float64(1.0 - z)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((z <= -8.2e+104) || ~((z <= 5.6e+17)))
		tmp = (t - a) / (b - y);
	else
		tmp = ((y * x) / (y + (z * (b - y)))) + ((z * (t - a)) / ((z * b) + (y * (1.0 - z))));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[z, -8.2e+104], N[Not[LessEqual[z, 5.6e+17]], $MachinePrecision]], N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision], N[(N[(N[(y * x), $MachinePrecision] / N[(y + N[(z * N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision] / N[(N[(z * b), $MachinePrecision] + N[(y * N[(1.0 - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 4: 83.9% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y + z \cdot \left(b - y\right)\\ \mathbf{if}\;z \leq -8.2 \cdot 10^{+104} \lor \neg \left(z \leq 1.5 \cdot 10^{+17}\right):\\ \;\;\;\;\frac{t - a}{b - y}\\ \mathbf{else}:\\ \;\;\;\;\frac{z \cdot \left(t - a\right)}{t_1} + \frac{y \cdot x}{t_1}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ y (* z (- b y)))))
   (if (or (<= z -8.2e+104) (not (<= z 1.5e+17)))
     (/ (- t a) (- b y))
     (+ (/ (* z (- t a)) t_1) (/ (* y x) t_1)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = y + (z * (b - y));
	double tmp;
	if ((z <= -8.2e+104) || !(z <= 1.5e+17)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = ((z * (t - a)) / t_1) + ((y * x) / t_1);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    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), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = y + (z * (b - y))
    if ((z <= (-8.2d+104)) .or. (.not. (z <= 1.5d+17))) then
        tmp = (t - a) / (b - y)
    else
        tmp = ((z * (t - a)) / t_1) + ((y * x) / t_1)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = y + (z * (b - y));
	double tmp;
	if ((z <= -8.2e+104) || !(z <= 1.5e+17)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = ((z * (t - a)) / t_1) + ((y * x) / t_1);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = y + (z * (b - y))
	tmp = 0
	if (z <= -8.2e+104) or not (z <= 1.5e+17):
		tmp = (t - a) / (b - y)
	else:
		tmp = ((z * (t - a)) / t_1) + ((y * x) / t_1)
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(y + Float64(z * Float64(b - y)))
	tmp = 0.0
	if ((z <= -8.2e+104) || !(z <= 1.5e+17))
		tmp = Float64(Float64(t - a) / Float64(b - y));
	else
		tmp = Float64(Float64(Float64(z * Float64(t - a)) / t_1) + Float64(Float64(y * x) / t_1));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = y + (z * (b - y));
	tmp = 0.0;
	if ((z <= -8.2e+104) || ~((z <= 1.5e+17)))
		tmp = (t - a) / (b - y);
	else
		tmp = ((z * (t - a)) / t_1) + ((y * x) / t_1);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y + N[(z * N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[z, -8.2e+104], N[Not[LessEqual[z, 1.5e+17]], $MachinePrecision]], N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision], N[(N[(N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision] + N[(N[(y * x), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 5: 71.8% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y + z \cdot \left(b - y\right)\\ t_2 := \frac{z \cdot \left(t - a\right)}{t_1}\\ t_3 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -15:\\ \;\;\;\;t_3\\ \mathbf{elif}\;z \leq -5.8 \cdot 10^{-174}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;z \leq 4.3 \cdot 10^{-288}:\\ \;\;\;\;x + \frac{z}{\frac{y}{t - a}}\\ \mathbf{elif}\;z \leq 1.6 \cdot 10^{-106}:\\ \;\;\;\;\frac{y \cdot x + z \cdot t}{t_1}\\ \mathbf{elif}\;z \leq 2.35 \cdot 10^{-61}:\\ \;\;\;\;x + \frac{z \cdot \left(t - \left(a + b \cdot x\right)\right)}{y}\\ \mathbf{elif}\;z \leq 580000000000:\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;t_3\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ y (* z (- b y))))
        (t_2 (/ (* z (- t a)) t_1))
        (t_3 (/ (- t a) (- b y))))
   (if (<= z -15.0)
     t_3
     (if (<= z -5.8e-174)
       t_2
       (if (<= z 4.3e-288)
         (+ x (/ z (/ y (- t a))))
         (if (<= z 1.6e-106)
           (/ (+ (* y x) (* z t)) t_1)
           (if (<= z 2.35e-61)
             (+ x (/ (* z (- t (+ a (* b x)))) y))
             (if (<= z 580000000000.0) t_2 t_3))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = y + (z * (b - y));
	double t_2 = (z * (t - a)) / t_1;
	double t_3 = (t - a) / (b - y);
	double tmp;
	if (z <= -15.0) {
		tmp = t_3;
	} else if (z <= -5.8e-174) {
		tmp = t_2;
	} else if (z <= 4.3e-288) {
		tmp = x + (z / (y / (t - a)));
	} else if (z <= 1.6e-106) {
		tmp = ((y * x) + (z * t)) / t_1;
	} else if (z <= 2.35e-61) {
		tmp = x + ((z * (t - (a + (b * x)))) / y);
	} else if (z <= 580000000000.0) {
		tmp = t_2;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    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), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_1 = y + (z * (b - y))
    t_2 = (z * (t - a)) / t_1
    t_3 = (t - a) / (b - y)
    if (z <= (-15.0d0)) then
        tmp = t_3
    else if (z <= (-5.8d-174)) then
        tmp = t_2
    else if (z <= 4.3d-288) then
        tmp = x + (z / (y / (t - a)))
    else if (z <= 1.6d-106) then
        tmp = ((y * x) + (z * t)) / t_1
    else if (z <= 2.35d-61) then
        tmp = x + ((z * (t - (a + (b * x)))) / y)
    else if (z <= 580000000000.0d0) then
        tmp = t_2
    else
        tmp = t_3
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = y + (z * (b - y));
	double t_2 = (z * (t - a)) / t_1;
	double t_3 = (t - a) / (b - y);
	double tmp;
	if (z <= -15.0) {
		tmp = t_3;
	} else if (z <= -5.8e-174) {
		tmp = t_2;
	} else if (z <= 4.3e-288) {
		tmp = x + (z / (y / (t - a)));
	} else if (z <= 1.6e-106) {
		tmp = ((y * x) + (z * t)) / t_1;
	} else if (z <= 2.35e-61) {
		tmp = x + ((z * (t - (a + (b * x)))) / y);
	} else if (z <= 580000000000.0) {
		tmp = t_2;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = y + (z * (b - y))
	t_2 = (z * (t - a)) / t_1
	t_3 = (t - a) / (b - y)
	tmp = 0
	if z <= -15.0:
		tmp = t_3
	elif z <= -5.8e-174:
		tmp = t_2
	elif z <= 4.3e-288:
		tmp = x + (z / (y / (t - a)))
	elif z <= 1.6e-106:
		tmp = ((y * x) + (z * t)) / t_1
	elif z <= 2.35e-61:
		tmp = x + ((z * (t - (a + (b * x)))) / y)
	elif z <= 580000000000.0:
		tmp = t_2
	else:
		tmp = t_3
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(y + Float64(z * Float64(b - y)))
	t_2 = Float64(Float64(z * Float64(t - a)) / t_1)
	t_3 = Float64(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -15.0)
		tmp = t_3;
	elseif (z <= -5.8e-174)
		tmp = t_2;
	elseif (z <= 4.3e-288)
		tmp = Float64(x + Float64(z / Float64(y / Float64(t - a))));
	elseif (z <= 1.6e-106)
		tmp = Float64(Float64(Float64(y * x) + Float64(z * t)) / t_1);
	elseif (z <= 2.35e-61)
		tmp = Float64(x + Float64(Float64(z * Float64(t - Float64(a + Float64(b * x)))) / y));
	elseif (z <= 580000000000.0)
		tmp = t_2;
	else
		tmp = t_3;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = y + (z * (b - y));
	t_2 = (z * (t - a)) / t_1;
	t_3 = (t - a) / (b - y);
	tmp = 0.0;
	if (z <= -15.0)
		tmp = t_3;
	elseif (z <= -5.8e-174)
		tmp = t_2;
	elseif (z <= 4.3e-288)
		tmp = x + (z / (y / (t - a)));
	elseif (z <= 1.6e-106)
		tmp = ((y * x) + (z * t)) / t_1;
	elseif (z <= 2.35e-61)
		tmp = x + ((z * (t - (a + (b * x)))) / y);
	elseif (z <= 580000000000.0)
		tmp = t_2;
	else
		tmp = t_3;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y + N[(z * N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision]}, Block[{t$95$3 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -15.0], t$95$3, If[LessEqual[z, -5.8e-174], t$95$2, If[LessEqual[z, 4.3e-288], N[(x + N[(z / N[(y / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.6e-106], N[(N[(N[(y * x), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], If[LessEqual[z, 2.35e-61], N[(x + N[(N[(z * N[(t - N[(a + N[(b * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 580000000000.0], t$95$2, t$95$3]]]]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 6: 72.4% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)}\\ t_2 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -15:\\ \;\;\;\;t_2\\ \mathbf{elif}\;z \leq -1.65 \cdot 10^{-173}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;z \leq 9.2 \cdot 10^{-65}:\\ \;\;\;\;x + \frac{z \cdot \left(t - \left(a + b \cdot x\right)\right)}{y}\\ \mathbf{elif}\;z \leq 10000000000:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ (* z (- t a)) (+ y (* z (- b y))))) (t_2 (/ (- t a) (- b y))))
   (if (<= z -15.0)
     t_2
     (if (<= z -1.65e-173)
       t_1
       (if (<= z 9.2e-65)
         (+ x (/ (* z (- t (+ a (* b x)))) y))
         (if (<= z 10000000000.0) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (z * (t - a)) / (y + (z * (b - y)));
	double t_2 = (t - a) / (b - y);
	double tmp;
	if (z <= -15.0) {
		tmp = t_2;
	} else if (z <= -1.65e-173) {
		tmp = t_1;
	} else if (z <= 9.2e-65) {
		tmp = x + ((z * (t - (a + (b * x)))) / y);
	} else if (z <= 10000000000.0) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    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), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (z * (t - a)) / (y + (z * (b - y)))
    t_2 = (t - a) / (b - y)
    if (z <= (-15.0d0)) then
        tmp = t_2
    else if (z <= (-1.65d-173)) then
        tmp = t_1
    else if (z <= 9.2d-65) then
        tmp = x + ((z * (t - (a + (b * x)))) / y)
    else if (z <= 10000000000.0d0) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (z * (t - a)) / (y + (z * (b - y)));
	double t_2 = (t - a) / (b - y);
	double tmp;
	if (z <= -15.0) {
		tmp = t_2;
	} else if (z <= -1.65e-173) {
		tmp = t_1;
	} else if (z <= 9.2e-65) {
		tmp = x + ((z * (t - (a + (b * x)))) / y);
	} else if (z <= 10000000000.0) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (z * (t - a)) / (y + (z * (b - y)))
	t_2 = (t - a) / (b - y)
	tmp = 0
	if z <= -15.0:
		tmp = t_2
	elif z <= -1.65e-173:
		tmp = t_1
	elif z <= 9.2e-65:
		tmp = x + ((z * (t - (a + (b * x)))) / y)
	elif z <= 10000000000.0:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(z * Float64(t - a)) / Float64(y + Float64(z * Float64(b - y))))
	t_2 = Float64(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -15.0)
		tmp = t_2;
	elseif (z <= -1.65e-173)
		tmp = t_1;
	elseif (z <= 9.2e-65)
		tmp = Float64(x + Float64(Float64(z * Float64(t - Float64(a + Float64(b * x)))) / y));
	elseif (z <= 10000000000.0)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (z * (t - a)) / (y + (z * (b - y)));
	t_2 = (t - a) / (b - y);
	tmp = 0.0;
	if (z <= -15.0)
		tmp = t_2;
	elseif (z <= -1.65e-173)
		tmp = t_1;
	elseif (z <= 9.2e-65)
		tmp = x + ((z * (t - (a + (b * x)))) / y);
	elseif (z <= 10000000000.0)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision] / N[(y + N[(z * N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -15.0], t$95$2, If[LessEqual[z, -1.65e-173], t$95$1, If[LessEqual[z, 9.2e-65], N[(x + N[(N[(z * N[(t - N[(a + N[(b * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 10000000000.0], t$95$1, t$95$2]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 7: 83.9% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -2.6 \cdot 10^{+105} \lor \neg \left(z \leq 3.8 \cdot 10^{+19}\right):\\ \;\;\;\;\frac{t - a}{b - y}\\ \mathbf{else}:\\ \;\;\;\;\frac{z \cdot \left(t - a\right) + y \cdot x}{y + z \cdot \left(b - y\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= z -2.6e+105) (not (<= z 3.8e+19)))
   (/ (- t a) (- b y))
   (/ (+ (* z (- t a)) (* y x)) (+ y (* z (- b y))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -2.6e+105) || !(z <= 3.8e+19)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = ((z * (t - a)) + (y * x)) / (y + (z * (b - y)));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    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), intent (in) :: b
    real(8) :: tmp
    if ((z <= (-2.6d+105)) .or. (.not. (z <= 3.8d+19))) then
        tmp = (t - a) / (b - y)
    else
        tmp = ((z * (t - a)) + (y * x)) / (y + (z * (b - y)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -2.6e+105) || !(z <= 3.8e+19)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = ((z * (t - a)) + (y * x)) / (y + (z * (b - y)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (z <= -2.6e+105) or not (z <= 3.8e+19):
		tmp = (t - a) / (b - y)
	else:
		tmp = ((z * (t - a)) + (y * x)) / (y + (z * (b - y)))
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((z <= -2.6e+105) || !(z <= 3.8e+19))
		tmp = Float64(Float64(t - a) / Float64(b - y));
	else
		tmp = Float64(Float64(Float64(z * Float64(t - a)) + Float64(y * x)) / Float64(y + Float64(z * Float64(b - y))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((z <= -2.6e+105) || ~((z <= 3.8e+19)))
		tmp = (t - a) / (b - y);
	else
		tmp = ((z * (t - a)) + (y * x)) / (y + (z * (b - y)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[z, -2.6e+105], N[Not[LessEqual[z, 3.8e+19]], $MachinePrecision]], N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision], N[(N[(N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision] + N[(y * x), $MachinePrecision]), $MachinePrecision] / N[(y + N[(z * N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 8: 68.6% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -15800000000000:\\ \;\;\;\;t_1\\ \mathbf{elif}\;z \leq -4.5 \cdot 10^{-173}:\\ \;\;\;\;\frac{t - a}{b} + \frac{x}{b \cdot \frac{z}{y}}\\ \mathbf{elif}\;z \leq 3.6 \cdot 10^{-61}:\\ \;\;\;\;x + \frac{z \cdot \left(t - \left(a + b \cdot x\right)\right)}{y}\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ (- t a) (- b y))))
   (if (<= z -15800000000000.0)
     t_1
     (if (<= z -4.5e-173)
       (+ (/ (- t a) b) (/ x (* b (/ z y))))
       (if (<= z 3.6e-61) (+ x (/ (* z (- t (+ a (* b x)))) y)) t_1)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -15800000000000.0) {
		tmp = t_1;
	} else if (z <= -4.5e-173) {
		tmp = ((t - a) / b) + (x / (b * (z / y)));
	} else if (z <= 3.6e-61) {
		tmp = x + ((z * (t - (a + (b * x)))) / y);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    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), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (t - a) / (b - y)
    if (z <= (-15800000000000.0d0)) then
        tmp = t_1
    else if (z <= (-4.5d-173)) then
        tmp = ((t - a) / b) + (x / (b * (z / y)))
    else if (z <= 3.6d-61) then
        tmp = x + ((z * (t - (a + (b * x)))) / y)
    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 b) {
	double t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -15800000000000.0) {
		tmp = t_1;
	} else if (z <= -4.5e-173) {
		tmp = ((t - a) / b) + (x / (b * (z / y)));
	} else if (z <= 3.6e-61) {
		tmp = x + ((z * (t - (a + (b * x)))) / y);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (t - a) / (b - y)
	tmp = 0
	if z <= -15800000000000.0:
		tmp = t_1
	elif z <= -4.5e-173:
		tmp = ((t - a) / b) + (x / (b * (z / y)))
	elif z <= 3.6e-61:
		tmp = x + ((z * (t - (a + (b * x)))) / y)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -15800000000000.0)
		tmp = t_1;
	elseif (z <= -4.5e-173)
		tmp = Float64(Float64(Float64(t - a) / b) + Float64(x / Float64(b * Float64(z / y))));
	elseif (z <= 3.6e-61)
		tmp = Float64(x + Float64(Float64(z * Float64(t - Float64(a + Float64(b * x)))) / y));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (t - a) / (b - y);
	tmp = 0.0;
	if (z <= -15800000000000.0)
		tmp = t_1;
	elseif (z <= -4.5e-173)
		tmp = ((t - a) / b) + (x / (b * (z / y)));
	elseif (z <= 3.6e-61)
		tmp = x + ((z * (t - (a + (b * x)))) / y);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -15800000000000.0], t$95$1, If[LessEqual[z, -4.5e-173], N[(N[(N[(t - a), $MachinePrecision] / b), $MachinePrecision] + N[(x / N[(b * N[(z / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.6e-61], N[(x + N[(N[(z * N[(t - N[(a + N[(b * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 9: 68.6% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -14500000000000:\\ \;\;\;\;t_1\\ \mathbf{elif}\;z \leq -4.7 \cdot 10^{-173}:\\ \;\;\;\;\frac{x}{\frac{z \cdot b}{y}} + \frac{t - a}{b}\\ \mathbf{elif}\;z \leq 4.8 \cdot 10^{-60}:\\ \;\;\;\;x + \frac{z \cdot \left(t - \left(a + b \cdot x\right)\right)}{y}\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ (- t a) (- b y))))
   (if (<= z -14500000000000.0)
     t_1
     (if (<= z -4.7e-173)
       (+ (/ x (/ (* z b) y)) (/ (- t a) b))
       (if (<= z 4.8e-60) (+ x (/ (* z (- t (+ a (* b x)))) y)) t_1)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -14500000000000.0) {
		tmp = t_1;
	} else if (z <= -4.7e-173) {
		tmp = (x / ((z * b) / y)) + ((t - a) / b);
	} else if (z <= 4.8e-60) {
		tmp = x + ((z * (t - (a + (b * x)))) / y);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    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), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (t - a) / (b - y)
    if (z <= (-14500000000000.0d0)) then
        tmp = t_1
    else if (z <= (-4.7d-173)) then
        tmp = (x / ((z * b) / y)) + ((t - a) / b)
    else if (z <= 4.8d-60) then
        tmp = x + ((z * (t - (a + (b * x)))) / y)
    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 b) {
	double t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -14500000000000.0) {
		tmp = t_1;
	} else if (z <= -4.7e-173) {
		tmp = (x / ((z * b) / y)) + ((t - a) / b);
	} else if (z <= 4.8e-60) {
		tmp = x + ((z * (t - (a + (b * x)))) / y);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (t - a) / (b - y)
	tmp = 0
	if z <= -14500000000000.0:
		tmp = t_1
	elif z <= -4.7e-173:
		tmp = (x / ((z * b) / y)) + ((t - a) / b)
	elif z <= 4.8e-60:
		tmp = x + ((z * (t - (a + (b * x)))) / y)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -14500000000000.0)
		tmp = t_1;
	elseif (z <= -4.7e-173)
		tmp = Float64(Float64(x / Float64(Float64(z * b) / y)) + Float64(Float64(t - a) / b));
	elseif (z <= 4.8e-60)
		tmp = Float64(x + Float64(Float64(z * Float64(t - Float64(a + Float64(b * x)))) / y));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (t - a) / (b - y);
	tmp = 0.0;
	if (z <= -14500000000000.0)
		tmp = t_1;
	elseif (z <= -4.7e-173)
		tmp = (x / ((z * b) / y)) + ((t - a) / b);
	elseif (z <= 4.8e-60)
		tmp = x + ((z * (t - (a + (b * x)))) / y);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -14500000000000.0], t$95$1, If[LessEqual[z, -4.7e-173], N[(N[(x / N[(N[(z * b), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision] + N[(N[(t - a), $MachinePrecision] / b), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.8e-60], N[(x + N[(N[(z * N[(t - N[(a + N[(b * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 10: 83.1% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -8800000000000 \lor \neg \left(z \leq 10.5\right):\\ \;\;\;\;\frac{t - a}{b - y}\\ \mathbf{else}:\\ \;\;\;\;\frac{z \cdot \left(t - a\right) + y \cdot x}{y + z \cdot b}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= z -8800000000000.0) (not (<= z 10.5)))
   (/ (- t a) (- b y))
   (/ (+ (* z (- t a)) (* y x)) (+ y (* z b)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -8800000000000.0) || !(z <= 10.5)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = ((z * (t - a)) + (y * x)) / (y + (z * b));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    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), intent (in) :: b
    real(8) :: tmp
    if ((z <= (-8800000000000.0d0)) .or. (.not. (z <= 10.5d0))) then
        tmp = (t - a) / (b - y)
    else
        tmp = ((z * (t - a)) + (y * x)) / (y + (z * b))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -8800000000000.0) || !(z <= 10.5)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = ((z * (t - a)) + (y * x)) / (y + (z * b));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (z <= -8800000000000.0) or not (z <= 10.5):
		tmp = (t - a) / (b - y)
	else:
		tmp = ((z * (t - a)) + (y * x)) / (y + (z * b))
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((z <= -8800000000000.0) || !(z <= 10.5))
		tmp = Float64(Float64(t - a) / Float64(b - y));
	else
		tmp = Float64(Float64(Float64(z * Float64(t - a)) + Float64(y * x)) / Float64(y + Float64(z * b)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((z <= -8800000000000.0) || ~((z <= 10.5)))
		tmp = (t - a) / (b - y);
	else
		tmp = ((z * (t - a)) + (y * x)) / (y + (z * b));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[z, -8800000000000.0], N[Not[LessEqual[z, 10.5]], $MachinePrecision]], N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision], N[(N[(N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision] + N[(y * x), $MachinePrecision]), $MachinePrecision] / N[(y + N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 11: 67.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -4.7 \cdot 10^{-173} \lor \neg \left(z \leq 5.4 \cdot 10^{-60}\right):\\ \;\;\;\;\frac{t - a}{b - y}\\ \mathbf{else}:\\ \;\;\;\;x + \frac{z \cdot \left(t - \left(a + b \cdot x\right)\right)}{y}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= z -4.7e-173) (not (<= z 5.4e-60)))
   (/ (- t a) (- b y))
   (+ x (/ (* z (- t (+ a (* b x)))) y))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -4.7e-173) || !(z <= 5.4e-60)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = x + ((z * (t - (a + (b * x)))) / y);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    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), intent (in) :: b
    real(8) :: tmp
    if ((z <= (-4.7d-173)) .or. (.not. (z <= 5.4d-60))) then
        tmp = (t - a) / (b - y)
    else
        tmp = x + ((z * (t - (a + (b * x)))) / y)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -4.7e-173) || !(z <= 5.4e-60)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = x + ((z * (t - (a + (b * x)))) / y);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (z <= -4.7e-173) or not (z <= 5.4e-60):
		tmp = (t - a) / (b - y)
	else:
		tmp = x + ((z * (t - (a + (b * x)))) / y)
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((z <= -4.7e-173) || !(z <= 5.4e-60))
		tmp = Float64(Float64(t - a) / Float64(b - y));
	else
		tmp = Float64(x + Float64(Float64(z * Float64(t - Float64(a + Float64(b * x)))) / y));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((z <= -4.7e-173) || ~((z <= 5.4e-60)))
		tmp = (t - a) / (b - y);
	else
		tmp = x + ((z * (t - (a + (b * x)))) / y);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[z, -4.7e-173], N[Not[LessEqual[z, 5.4e-60]], $MachinePrecision]], N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(z * N[(t - N[(a + N[(b * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 12: 40.5% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{-a}{b}\\ t_2 := \frac{x}{1 - z}\\ \mathbf{if}\;y \leq -1.34 \cdot 10^{-76}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y \leq 6.2 \cdot 10^{-180}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq 5.7 \cdot 10^{-52}:\\ \;\;\;\;x + z \cdot x\\ \mathbf{elif}\;y \leq 8.5 \cdot 10^{+47}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (/ (- a) b)) (t_2 (/ x (- 1.0 z))))
   (if (<= y -1.34e-76)
     t_2
     (if (<= y 6.2e-180)
       t_1
       (if (<= y 5.7e-52) (+ x (* z x)) (if (<= y 8.5e+47) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = -a / b;
	double t_2 = x / (1.0 - z);
	double tmp;
	if (y <= -1.34e-76) {
		tmp = t_2;
	} else if (y <= 6.2e-180) {
		tmp = t_1;
	} else if (y <= 5.7e-52) {
		tmp = x + (z * x);
	} else if (y <= 8.5e+47) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    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), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = -a / b
    t_2 = x / (1.0d0 - z)
    if (y <= (-1.34d-76)) then
        tmp = t_2
    else if (y <= 6.2d-180) then
        tmp = t_1
    else if (y <= 5.7d-52) then
        tmp = x + (z * x)
    else if (y <= 8.5d+47) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = -a / b;
	double t_2 = x / (1.0 - z);
	double tmp;
	if (y <= -1.34e-76) {
		tmp = t_2;
	} else if (y <= 6.2e-180) {
		tmp = t_1;
	} else if (y <= 5.7e-52) {
		tmp = x + (z * x);
	} else if (y <= 8.5e+47) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = -a / b
	t_2 = x / (1.0 - z)
	tmp = 0
	if y <= -1.34e-76:
		tmp = t_2
	elif y <= 6.2e-180:
		tmp = t_1
	elif y <= 5.7e-52:
		tmp = x + (z * x)
	elif y <= 8.5e+47:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(-a) / b)
	t_2 = Float64(x / Float64(1.0 - z))
	tmp = 0.0
	if (y <= -1.34e-76)
		tmp = t_2;
	elseif (y <= 6.2e-180)
		tmp = t_1;
	elseif (y <= 5.7e-52)
		tmp = Float64(x + Float64(z * x));
	elseif (y <= 8.5e+47)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = -a / b;
	t_2 = x / (1.0 - z);
	tmp = 0.0;
	if (y <= -1.34e-76)
		tmp = t_2;
	elseif (y <= 6.2e-180)
		tmp = t_1;
	elseif (y <= 5.7e-52)
		tmp = x + (z * x);
	elseif (y <= 8.5e+47)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[((-a) / b), $MachinePrecision]}, Block[{t$95$2 = N[(x / N[(1.0 - z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.34e-76], t$95$2, If[LessEqual[y, 6.2e-180], t$95$1, If[LessEqual[y, 5.7e-52], N[(x + N[(z * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 8.5e+47], t$95$1, t$95$2]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 13: 67.2% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -4.6 \cdot 10^{-173} \lor \neg \left(z \leq 2.35 \cdot 10^{-63}\right):\\ \;\;\;\;\frac{t - a}{b - y}\\ \mathbf{else}:\\ \;\;\;\;x + \frac{z}{\frac{y}{t - a}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= z -4.6e-173) (not (<= z 2.35e-63)))
   (/ (- t a) (- b y))
   (+ x (/ z (/ y (- t a))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -4.6e-173) || !(z <= 2.35e-63)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = x + (z / (y / (t - a)));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    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), intent (in) :: b
    real(8) :: tmp
    if ((z <= (-4.6d-173)) .or. (.not. (z <= 2.35d-63))) then
        tmp = (t - a) / (b - y)
    else
        tmp = x + (z / (y / (t - a)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -4.6e-173) || !(z <= 2.35e-63)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = x + (z / (y / (t - a)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (z <= -4.6e-173) or not (z <= 2.35e-63):
		tmp = (t - a) / (b - y)
	else:
		tmp = x + (z / (y / (t - a)))
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((z <= -4.6e-173) || !(z <= 2.35e-63))
		tmp = Float64(Float64(t - a) / Float64(b - y));
	else
		tmp = Float64(x + Float64(z / Float64(y / Float64(t - a))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((z <= -4.6e-173) || ~((z <= 2.35e-63)))
		tmp = (t - a) / (b - y);
	else
		tmp = x + (z / (y / (t - a)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[z, -4.6e-173], N[Not[LessEqual[z, 2.35e-63]], $MachinePrecision]], N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision], N[(x + N[(z / N[(y / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 14: 49.8% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -4.7 \cdot 10^{-173} \lor \neg \left(z \leq 5 \cdot 10^{-60}\right):\\ \;\;\;\;\frac{t - a}{b}\\ \mathbf{else}:\\ \;\;\;\;x + \frac{t}{\frac{y}{z}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= z -4.7e-173) (not (<= z 5e-60)))
   (/ (- t a) b)
   (+ x (/ t (/ y z)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -4.7e-173) || !(z <= 5e-60)) {
		tmp = (t - a) / b;
	} else {
		tmp = x + (t / (y / z));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    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), intent (in) :: b
    real(8) :: tmp
    if ((z <= (-4.7d-173)) .or. (.not. (z <= 5d-60))) then
        tmp = (t - a) / b
    else
        tmp = x + (t / (y / z))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -4.7e-173) || !(z <= 5e-60)) {
		tmp = (t - a) / b;
	} else {
		tmp = x + (t / (y / z));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (z <= -4.7e-173) or not (z <= 5e-60):
		tmp = (t - a) / b
	else:
		tmp = x + (t / (y / z))
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((z <= -4.7e-173) || !(z <= 5e-60))
		tmp = Float64(Float64(t - a) / b);
	else
		tmp = Float64(x + Float64(t / Float64(y / z)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((z <= -4.7e-173) || ~((z <= 5e-60)))
		tmp = (t - a) / b;
	else
		tmp = x + (t / (y / z));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[z, -4.7e-173], N[Not[LessEqual[z, 5e-60]], $MachinePrecision]], N[(N[(t - a), $MachinePrecision] / b), $MachinePrecision], N[(x + N[(t / N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 15: 50.3% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -4.7 \cdot 10^{-173} \lor \neg \left(z \leq 3.9 \cdot 10^{-60}\right):\\ \;\;\;\;\frac{t - a}{b}\\ \mathbf{else}:\\ \;\;\;\;x + \frac{z \cdot t}{y}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= z -4.7e-173) (not (<= z 3.9e-60)))
   (/ (- t a) b)
   (+ x (/ (* z t) y))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -4.7e-173) || !(z <= 3.9e-60)) {
		tmp = (t - a) / b;
	} else {
		tmp = x + ((z * t) / y);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    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), intent (in) :: b
    real(8) :: tmp
    if ((z <= (-4.7d-173)) .or. (.not. (z <= 3.9d-60))) then
        tmp = (t - a) / b
    else
        tmp = x + ((z * t) / y)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -4.7e-173) || !(z <= 3.9e-60)) {
		tmp = (t - a) / b;
	} else {
		tmp = x + ((z * t) / y);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (z <= -4.7e-173) or not (z <= 3.9e-60):
		tmp = (t - a) / b
	else:
		tmp = x + ((z * t) / y)
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((z <= -4.7e-173) || !(z <= 3.9e-60))
		tmp = Float64(Float64(t - a) / b);
	else
		tmp = Float64(x + Float64(Float64(z * t) / y));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((z <= -4.7e-173) || ~((z <= 3.9e-60)))
		tmp = (t - a) / b;
	else
		tmp = x + ((z * t) / y);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[z, -4.7e-173], N[Not[LessEqual[z, 3.9e-60]], $MachinePrecision]], N[(N[(t - a), $MachinePrecision] / b), $MachinePrecision], N[(x + N[(N[(z * t), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 16: 66.4% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -4.7 \cdot 10^{-173} \lor \neg \left(z \leq 7.2 \cdot 10^{-62}\right):\\ \;\;\;\;\frac{t - a}{b - y}\\ \mathbf{else}:\\ \;\;\;\;x + \frac{z \cdot t}{y}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= z -4.7e-173) (not (<= z 7.2e-62)))
   (/ (- t a) (- b y))
   (+ x (/ (* z t) y))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -4.7e-173) || !(z <= 7.2e-62)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = x + ((z * t) / y);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    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), intent (in) :: b
    real(8) :: tmp
    if ((z <= (-4.7d-173)) .or. (.not. (z <= 7.2d-62))) then
        tmp = (t - a) / (b - y)
    else
        tmp = x + ((z * t) / y)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -4.7e-173) || !(z <= 7.2e-62)) {
		tmp = (t - a) / (b - y);
	} else {
		tmp = x + ((z * t) / y);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (z <= -4.7e-173) or not (z <= 7.2e-62):
		tmp = (t - a) / (b - y)
	else:
		tmp = x + ((z * t) / y)
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((z <= -4.7e-173) || !(z <= 7.2e-62))
		tmp = Float64(Float64(t - a) / Float64(b - y));
	else
		tmp = Float64(x + Float64(Float64(z * t) / y));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((z <= -4.7e-173) || ~((z <= 7.2e-62)))
		tmp = (t - a) / (b - y);
	else
		tmp = x + ((z * t) / y);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[z, -4.7e-173], N[Not[LessEqual[z, 7.2e-62]], $MachinePrecision]], N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(z * t), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 17: 54.6% accurate, 1.9× speedup

Math

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

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= y -50000000.0) (not (<= y 3.4e+48)))
   (/ x (- 1.0 z))
   (/ (- t a) b)))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((y <= -50000000.0) || !(y <= 3.4e+48)) {
		tmp = x / (1.0 - z);
	} else {
		tmp = (t - a) / b;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    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), intent (in) :: b
    real(8) :: tmp
    if ((y <= (-50000000.0d0)) .or. (.not. (y <= 3.4d+48))) then
        tmp = x / (1.0d0 - z)
    else
        tmp = (t - a) / b
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((y <= -50000000.0) || !(y <= 3.4e+48)) {
		tmp = x / (1.0 - z);
	} else {
		tmp = (t - a) / b;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (y <= -50000000.0) or not (y <= 3.4e+48):
		tmp = x / (1.0 - z)
	else:
		tmp = (t - a) / b
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((y <= -50000000.0) || !(y <= 3.4e+48))
		tmp = Float64(x / Float64(1.0 - z));
	else
		tmp = Float64(Float64(t - a) / b);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((y <= -50000000.0) || ~((y <= 3.4e+48)))
		tmp = x / (1.0 - z);
	else
		tmp = (t - a) / b;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[y, -50000000.0], N[Not[LessEqual[y, 3.4e+48]], $MachinePrecision]], N[(x / N[(1.0 - z), $MachinePrecision]), $MachinePrecision], N[(N[(t - a), $MachinePrecision] / b), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 18: 34.2% accurate, 2.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -4.7 \cdot 10^{-173} \lor \neg \left(z \leq 1.65 \cdot 10^{-41}\right):\\ \;\;\;\;\frac{-a}{b}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= z -4.7e-173) (not (<= z 1.65e-41))) (/ (- a) b) x))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -4.7e-173) || !(z <= 1.65e-41)) {
		tmp = -a / b;
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    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), intent (in) :: b
    real(8) :: tmp
    if ((z <= (-4.7d-173)) .or. (.not. (z <= 1.65d-41))) then
        tmp = -a / b
    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 b) {
	double tmp;
	if ((z <= -4.7e-173) || !(z <= 1.65e-41)) {
		tmp = -a / b;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (z <= -4.7e-173) or not (z <= 1.65e-41):
		tmp = -a / b
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((z <= -4.7e-173) || !(z <= 1.65e-41))
		tmp = Float64(Float64(-a) / b);
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((z <= -4.7e-173) || ~((z <= 1.65e-41)))
		tmp = -a / b;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[z, -4.7e-173], N[Not[LessEqual[z, 1.65e-41]], $MachinePrecision]], N[((-a) / b), $MachinePrecision], x]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 19: 26.1% accurate, 17.0× speedup

Math

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

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t, a, b)
    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), intent (in) :: b
    code = x
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Developer target: 73.8% accurate, 0.7× speedup

Math

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

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t, a, b)
    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), intent (in) :: b
    code = (((z * t) + (y * x)) / (y + (z * (b - y)))) - (a / ((b - y) + (y / z)))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Reproduce

herbie shell --seed 2023350 
(FPCore (x y z t a b)
  :name "Development.Shake.Progress:decay from shake-0.15.5"
  :precision binary64

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

  (/ (+ (* x y) (* z (- t a))) (+ y (* z (- b y)))))