Statistics.Distribution.Beta:$centropy from math-functions-0.1.5.2

Percentage Accurate: 95.4% → 98.1%

Time: 16.5s

Alternatives: 22

Speedup: 0.5×

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

Specification

Math

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

FPCore

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

C

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

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 95.4% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 98.1% accurate, 0.5× speedup

Math

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

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1
         (+ (+ (+ x (* z (- 1.0 y))) (* a (- 1.0 t))) (* b (- (+ y t) 2.0)))))
   (if (<= t_1 INFINITY) t_1 (* y (- b z)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = ((x + (z * (1.0 - y))) + (a * (1.0 - t))) + (b * ((y + t) - 2.0));
	double tmp;
	if (t_1 <= ((double) INFINITY)) {
		tmp = t_1;
	} else {
		tmp = y * (b - z);
	}
	return tmp;
}

Java

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

Python

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

Julia

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

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = ((x + (z * (1.0 - y))) + (a * (1.0 - t))) + (b * ((y + t) - 2.0));
	tmp = 0.0;
	if (t_1 <= Inf)
		tmp = t_1;
	else
		tmp = y * (b - z);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

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

Alternative 2: 97.7% accurate, 0.1× speedup

Math

\[\begin{array}{l} \\ \mathsf{fma}\left(y + \left(t + -2\right), b, x - \mathsf{fma}\left(y + -1, z, a \cdot \left(t + -1\right)\right)\right) \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (fma (+ y (+ t -2.0)) b (- x (fma (+ y -1.0) z (* a (+ t -1.0))))))

C

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

Julia

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

Wolfram

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

Derivation

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

Alternative 3: 52.9% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x - t \cdot a\\ t_2 := b \cdot \left(\left(y + t\right) - 2\right)\\ t_3 := z \cdot \left(1 - y\right)\\ \mathbf{if}\;b \leq -6.5 \cdot 10^{+43}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;b \leq -1.18 \cdot 10^{-46}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq -7.8 \cdot 10^{-55}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;b \leq -1.55 \cdot 10^{-135}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;b \leq -5.4 \cdot 10^{-250}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq 7.8 \cdot 10^{-290}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;b \leq 2.75 \cdot 10^{-155}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq 7.6 \cdot 10^{-25}:\\ \;\;\;\;x + z\\ \mathbf{elif}\;b \leq 3.5 \cdot 10^{+30}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (- x (* t a))) (t_2 (* b (- (+ y t) 2.0))) (t_3 (* z (- 1.0 y))))
   (if (<= b -6.5e+43)
     t_2
     (if (<= b -1.18e-46)
       t_1
       (if (<= b -7.8e-55)
         t_2
         (if (<= b -1.55e-135)
           t_3
           (if (<= b -5.4e-250)
             t_1
             (if (<= b 7.8e-290)
               t_3
               (if (<= b 2.75e-155)
                 t_1
                 (if (<= b 7.6e-25)
                   (+ x z)
                   (if (<= b 3.5e+30) t_1 t_2)))))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x - (t * a);
	double t_2 = b * ((y + t) - 2.0);
	double t_3 = z * (1.0 - y);
	double tmp;
	if (b <= -6.5e+43) {
		tmp = t_2;
	} else if (b <= -1.18e-46) {
		tmp = t_1;
	} else if (b <= -7.8e-55) {
		tmp = t_2;
	} else if (b <= -1.55e-135) {
		tmp = t_3;
	} else if (b <= -5.4e-250) {
		tmp = t_1;
	} else if (b <= 7.8e-290) {
		tmp = t_3;
	} else if (b <= 2.75e-155) {
		tmp = t_1;
	} else if (b <= 7.6e-25) {
		tmp = x + z;
	} else if (b <= 3.5e+30) {
		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) :: t_3
    real(8) :: tmp
    t_1 = x - (t * a)
    t_2 = b * ((y + t) - 2.0d0)
    t_3 = z * (1.0d0 - y)
    if (b <= (-6.5d+43)) then
        tmp = t_2
    else if (b <= (-1.18d-46)) then
        tmp = t_1
    else if (b <= (-7.8d-55)) then
        tmp = t_2
    else if (b <= (-1.55d-135)) then
        tmp = t_3
    else if (b <= (-5.4d-250)) then
        tmp = t_1
    else if (b <= 7.8d-290) then
        tmp = t_3
    else if (b <= 2.75d-155) then
        tmp = t_1
    else if (b <= 7.6d-25) then
        tmp = x + z
    else if (b <= 3.5d+30) 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 = x - (t * a);
	double t_2 = b * ((y + t) - 2.0);
	double t_3 = z * (1.0 - y);
	double tmp;
	if (b <= -6.5e+43) {
		tmp = t_2;
	} else if (b <= -1.18e-46) {
		tmp = t_1;
	} else if (b <= -7.8e-55) {
		tmp = t_2;
	} else if (b <= -1.55e-135) {
		tmp = t_3;
	} else if (b <= -5.4e-250) {
		tmp = t_1;
	} else if (b <= 7.8e-290) {
		tmp = t_3;
	} else if (b <= 2.75e-155) {
		tmp = t_1;
	} else if (b <= 7.6e-25) {
		tmp = x + z;
	} else if (b <= 3.5e+30) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x - (t * a)
	t_2 = b * ((y + t) - 2.0)
	t_3 = z * (1.0 - y)
	tmp = 0
	if b <= -6.5e+43:
		tmp = t_2
	elif b <= -1.18e-46:
		tmp = t_1
	elif b <= -7.8e-55:
		tmp = t_2
	elif b <= -1.55e-135:
		tmp = t_3
	elif b <= -5.4e-250:
		tmp = t_1
	elif b <= 7.8e-290:
		tmp = t_3
	elif b <= 2.75e-155:
		tmp = t_1
	elif b <= 7.6e-25:
		tmp = x + z
	elif b <= 3.5e+30:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x - Float64(t * a))
	t_2 = Float64(b * Float64(Float64(y + t) - 2.0))
	t_3 = Float64(z * Float64(1.0 - y))
	tmp = 0.0
	if (b <= -6.5e+43)
		tmp = t_2;
	elseif (b <= -1.18e-46)
		tmp = t_1;
	elseif (b <= -7.8e-55)
		tmp = t_2;
	elseif (b <= -1.55e-135)
		tmp = t_3;
	elseif (b <= -5.4e-250)
		tmp = t_1;
	elseif (b <= 7.8e-290)
		tmp = t_3;
	elseif (b <= 2.75e-155)
		tmp = t_1;
	elseif (b <= 7.6e-25)
		tmp = Float64(x + z);
	elseif (b <= 3.5e+30)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x - (t * a);
	t_2 = b * ((y + t) - 2.0);
	t_3 = z * (1.0 - y);
	tmp = 0.0;
	if (b <= -6.5e+43)
		tmp = t_2;
	elseif (b <= -1.18e-46)
		tmp = t_1;
	elseif (b <= -7.8e-55)
		tmp = t_2;
	elseif (b <= -1.55e-135)
		tmp = t_3;
	elseif (b <= -5.4e-250)
		tmp = t_1;
	elseif (b <= 7.8e-290)
		tmp = t_3;
	elseif (b <= 2.75e-155)
		tmp = t_1;
	elseif (b <= 7.6e-25)
		tmp = x + z;
	elseif (b <= 3.5e+30)
		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[(x - N[(t * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -6.5e+43], t$95$2, If[LessEqual[b, -1.18e-46], t$95$1, If[LessEqual[b, -7.8e-55], t$95$2, If[LessEqual[b, -1.55e-135], t$95$3, If[LessEqual[b, -5.4e-250], t$95$1, If[LessEqual[b, 7.8e-290], t$95$3, If[LessEqual[b, 2.75e-155], t$95$1, If[LessEqual[b, 7.6e-25], N[(x + z), $MachinePrecision], If[LessEqual[b, 3.5e+30], t$95$1, t$95$2]]]]]]]]]]]]

Derivation

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

Alternative 4: 49.2% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := t \cdot \left(b - a\right)\\ t_2 := x - t \cdot a\\ t_3 := y \cdot \left(b - z\right)\\ \mathbf{if}\;y \leq -1 \cdot 10^{+86}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;y \leq -1.8 \cdot 10^{+40}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y \leq -1.4 \cdot 10^{+20}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;y \leq -1.25 \cdot 10^{-78}:\\ \;\;\;\;x + z\\ \mathbf{elif}\;y \leq -1.95 \cdot 10^{-119}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq -2.1 \cdot 10^{-182}:\\ \;\;\;\;x + z\\ \mathbf{elif}\;y \leq 5.5 \cdot 10^{-234}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq 1.9 \cdot 10^{-23}:\\ \;\;\;\;x + z\\ \mathbf{elif}\;y \leq 4.1 \cdot 10^{+117}:\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;t_3\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* t (- b a))) (t_2 (- x (* t a))) (t_3 (* y (- b z))))
   (if (<= y -1e+86)
     t_3
     (if (<= y -1.8e+40)
       t_2
       (if (<= y -1.4e+20)
         t_3
         (if (<= y -1.25e-78)
           (+ x z)
           (if (<= y -1.95e-119)
             t_1
             (if (<= y -2.1e-182)
               (+ x z)
               (if (<= y 5.5e-234)
                 t_1
                 (if (<= y 1.9e-23)
                   (+ x z)
                   (if (<= y 4.1e+117) t_2 t_3)))))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = t * (b - a);
	double t_2 = x - (t * a);
	double t_3 = y * (b - z);
	double tmp;
	if (y <= -1e+86) {
		tmp = t_3;
	} else if (y <= -1.8e+40) {
		tmp = t_2;
	} else if (y <= -1.4e+20) {
		tmp = t_3;
	} else if (y <= -1.25e-78) {
		tmp = x + z;
	} else if (y <= -1.95e-119) {
		tmp = t_1;
	} else if (y <= -2.1e-182) {
		tmp = x + z;
	} else if (y <= 5.5e-234) {
		tmp = t_1;
	} else if (y <= 1.9e-23) {
		tmp = x + z;
	} else if (y <= 4.1e+117) {
		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 = t * (b - a)
    t_2 = x - (t * a)
    t_3 = y * (b - z)
    if (y <= (-1d+86)) then
        tmp = t_3
    else if (y <= (-1.8d+40)) then
        tmp = t_2
    else if (y <= (-1.4d+20)) then
        tmp = t_3
    else if (y <= (-1.25d-78)) then
        tmp = x + z
    else if (y <= (-1.95d-119)) then
        tmp = t_1
    else if (y <= (-2.1d-182)) then
        tmp = x + z
    else if (y <= 5.5d-234) then
        tmp = t_1
    else if (y <= 1.9d-23) then
        tmp = x + z
    else if (y <= 4.1d+117) 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 = t * (b - a);
	double t_2 = x - (t * a);
	double t_3 = y * (b - z);
	double tmp;
	if (y <= -1e+86) {
		tmp = t_3;
	} else if (y <= -1.8e+40) {
		tmp = t_2;
	} else if (y <= -1.4e+20) {
		tmp = t_3;
	} else if (y <= -1.25e-78) {
		tmp = x + z;
	} else if (y <= -1.95e-119) {
		tmp = t_1;
	} else if (y <= -2.1e-182) {
		tmp = x + z;
	} else if (y <= 5.5e-234) {
		tmp = t_1;
	} else if (y <= 1.9e-23) {
		tmp = x + z;
	} else if (y <= 4.1e+117) {
		tmp = t_2;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = t * (b - a)
	t_2 = x - (t * a)
	t_3 = y * (b - z)
	tmp = 0
	if y <= -1e+86:
		tmp = t_3
	elif y <= -1.8e+40:
		tmp = t_2
	elif y <= -1.4e+20:
		tmp = t_3
	elif y <= -1.25e-78:
		tmp = x + z
	elif y <= -1.95e-119:
		tmp = t_1
	elif y <= -2.1e-182:
		tmp = x + z
	elif y <= 5.5e-234:
		tmp = t_1
	elif y <= 1.9e-23:
		tmp = x + z
	elif y <= 4.1e+117:
		tmp = t_2
	else:
		tmp = t_3
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(t * Float64(b - a))
	t_2 = Float64(x - Float64(t * a))
	t_3 = Float64(y * Float64(b - z))
	tmp = 0.0
	if (y <= -1e+86)
		tmp = t_3;
	elseif (y <= -1.8e+40)
		tmp = t_2;
	elseif (y <= -1.4e+20)
		tmp = t_3;
	elseif (y <= -1.25e-78)
		tmp = Float64(x + z);
	elseif (y <= -1.95e-119)
		tmp = t_1;
	elseif (y <= -2.1e-182)
		tmp = Float64(x + z);
	elseif (y <= 5.5e-234)
		tmp = t_1;
	elseif (y <= 1.9e-23)
		tmp = Float64(x + z);
	elseif (y <= 4.1e+117)
		tmp = t_2;
	else
		tmp = t_3;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = t * (b - a);
	t_2 = x - (t * a);
	t_3 = y * (b - z);
	tmp = 0.0;
	if (y <= -1e+86)
		tmp = t_3;
	elseif (y <= -1.8e+40)
		tmp = t_2;
	elseif (y <= -1.4e+20)
		tmp = t_3;
	elseif (y <= -1.25e-78)
		tmp = x + z;
	elseif (y <= -1.95e-119)
		tmp = t_1;
	elseif (y <= -2.1e-182)
		tmp = x + z;
	elseif (y <= 5.5e-234)
		tmp = t_1;
	elseif (y <= 1.9e-23)
		tmp = x + z;
	elseif (y <= 4.1e+117)
		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[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x - N[(t * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1e+86], t$95$3, If[LessEqual[y, -1.8e+40], t$95$2, If[LessEqual[y, -1.4e+20], t$95$3, If[LessEqual[y, -1.25e-78], N[(x + z), $MachinePrecision], If[LessEqual[y, -1.95e-119], t$95$1, If[LessEqual[y, -2.1e-182], N[(x + z), $MachinePrecision], If[LessEqual[y, 5.5e-234], t$95$1, If[LessEqual[y, 1.9e-23], N[(x + z), $MachinePrecision], If[LessEqual[y, 4.1e+117], t$95$2, t$95$3]]]]]]]]]]]]

Derivation

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

Alternative 5: 48.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := b \cdot \left(y - 2\right)\\ t_2 := t \cdot \left(b - a\right)\\ \mathbf{if}\;t \leq -7.8 \cdot 10^{+16}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;t \leq -2.3 \cdot 10^{-21}:\\ \;\;\;\;x + z\\ \mathbf{elif}\;t \leq -9.3 \cdot 10^{-122}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;t \leq -4.9 \cdot 10^{-151}:\\ \;\;\;\;x + z\\ \mathbf{elif}\;t \leq -3.45 \cdot 10^{-277}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;t \leq 4.5 \cdot 10^{-124}:\\ \;\;\;\;x + z\\ \mathbf{elif}\;t \leq 5.5 \cdot 10^{-37}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;t \leq 2 \cdot 10^{+38}:\\ \;\;\;\;x + z\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* b (- y 2.0))) (t_2 (* t (- b a))))
   (if (<= t -7.8e+16)
     t_2
     (if (<= t -2.3e-21)
       (+ x z)
       (if (<= t -9.3e-122)
         t_1
         (if (<= t -4.9e-151)
           (+ x z)
           (if (<= t -3.45e-277)
             t_1
             (if (<= t 4.5e-124)
               (+ x z)
               (if (<= t 5.5e-37) t_1 (if (<= t 2e+38) (+ x z) t_2))))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = b * (y - 2.0);
	double t_2 = t * (b - a);
	double tmp;
	if (t <= -7.8e+16) {
		tmp = t_2;
	} else if (t <= -2.3e-21) {
		tmp = x + z;
	} else if (t <= -9.3e-122) {
		tmp = t_1;
	} else if (t <= -4.9e-151) {
		tmp = x + z;
	} else if (t <= -3.45e-277) {
		tmp = t_1;
	} else if (t <= 4.5e-124) {
		tmp = x + z;
	} else if (t <= 5.5e-37) {
		tmp = t_1;
	} else if (t <= 2e+38) {
		tmp = x + z;
	} 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 = b * (y - 2.0d0)
    t_2 = t * (b - a)
    if (t <= (-7.8d+16)) then
        tmp = t_2
    else if (t <= (-2.3d-21)) then
        tmp = x + z
    else if (t <= (-9.3d-122)) then
        tmp = t_1
    else if (t <= (-4.9d-151)) then
        tmp = x + z
    else if (t <= (-3.45d-277)) then
        tmp = t_1
    else if (t <= 4.5d-124) then
        tmp = x + z
    else if (t <= 5.5d-37) then
        tmp = t_1
    else if (t <= 2d+38) then
        tmp = x + z
    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 = b * (y - 2.0);
	double t_2 = t * (b - a);
	double tmp;
	if (t <= -7.8e+16) {
		tmp = t_2;
	} else if (t <= -2.3e-21) {
		tmp = x + z;
	} else if (t <= -9.3e-122) {
		tmp = t_1;
	} else if (t <= -4.9e-151) {
		tmp = x + z;
	} else if (t <= -3.45e-277) {
		tmp = t_1;
	} else if (t <= 4.5e-124) {
		tmp = x + z;
	} else if (t <= 5.5e-37) {
		tmp = t_1;
	} else if (t <= 2e+38) {
		tmp = x + z;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = b * (y - 2.0)
	t_2 = t * (b - a)
	tmp = 0
	if t <= -7.8e+16:
		tmp = t_2
	elif t <= -2.3e-21:
		tmp = x + z
	elif t <= -9.3e-122:
		tmp = t_1
	elif t <= -4.9e-151:
		tmp = x + z
	elif t <= -3.45e-277:
		tmp = t_1
	elif t <= 4.5e-124:
		tmp = x + z
	elif t <= 5.5e-37:
		tmp = t_1
	elif t <= 2e+38:
		tmp = x + z
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(b * Float64(y - 2.0))
	t_2 = Float64(t * Float64(b - a))
	tmp = 0.0
	if (t <= -7.8e+16)
		tmp = t_2;
	elseif (t <= -2.3e-21)
		tmp = Float64(x + z);
	elseif (t <= -9.3e-122)
		tmp = t_1;
	elseif (t <= -4.9e-151)
		tmp = Float64(x + z);
	elseif (t <= -3.45e-277)
		tmp = t_1;
	elseif (t <= 4.5e-124)
		tmp = Float64(x + z);
	elseif (t <= 5.5e-37)
		tmp = t_1;
	elseif (t <= 2e+38)
		tmp = Float64(x + z);
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = b * (y - 2.0);
	t_2 = t * (b - a);
	tmp = 0.0;
	if (t <= -7.8e+16)
		tmp = t_2;
	elseif (t <= -2.3e-21)
		tmp = x + z;
	elseif (t <= -9.3e-122)
		tmp = t_1;
	elseif (t <= -4.9e-151)
		tmp = x + z;
	elseif (t <= -3.45e-277)
		tmp = t_1;
	elseif (t <= 4.5e-124)
		tmp = x + z;
	elseif (t <= 5.5e-37)
		tmp = t_1;
	elseif (t <= 2e+38)
		tmp = x + z;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(b * N[(y - 2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -7.8e+16], t$95$2, If[LessEqual[t, -2.3e-21], N[(x + z), $MachinePrecision], If[LessEqual[t, -9.3e-122], t$95$1, If[LessEqual[t, -4.9e-151], N[(x + z), $MachinePrecision], If[LessEqual[t, -3.45e-277], t$95$1, If[LessEqual[t, 4.5e-124], N[(x + z), $MachinePrecision], If[LessEqual[t, 5.5e-37], t$95$1, If[LessEqual[t, 2e+38], N[(x + z), $MachinePrecision], t$95$2]]]]]]]]]]

Derivation

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

Alternative 6: 56.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + a \cdot \left(1 - t\right)\\ t_2 := y \cdot \left(b - z\right)\\ t_3 := x + \left(z + -2 \cdot b\right)\\ \mathbf{if}\;y \leq -5 \cdot 10^{+87}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y \leq -1.25 \cdot 10^{+39}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq -1.4 \cdot 10^{+20}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y \leq -4.9 \cdot 10^{-217}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;y \leq -3.5 \cdot 10^{-275}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq 1.2 \cdot 10^{-22}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;y \leq 2.3 \cdot 10^{+117}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ x (* a (- 1.0 t))))
        (t_2 (* y (- b z)))
        (t_3 (+ x (+ z (* -2.0 b)))))
   (if (<= y -5e+87)
     t_2
     (if (<= y -1.25e+39)
       t_1
       (if (<= y -1.4e+20)
         t_2
         (if (<= y -4.9e-217)
           t_3
           (if (<= y -3.5e-275)
             t_1
             (if (<= y 1.2e-22) t_3 (if (<= y 2.3e+117) t_1 t_2)))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x + (a * (1.0 - t));
	double t_2 = y * (b - z);
	double t_3 = x + (z + (-2.0 * b));
	double tmp;
	if (y <= -5e+87) {
		tmp = t_2;
	} else if (y <= -1.25e+39) {
		tmp = t_1;
	} else if (y <= -1.4e+20) {
		tmp = t_2;
	} else if (y <= -4.9e-217) {
		tmp = t_3;
	} else if (y <= -3.5e-275) {
		tmp = t_1;
	} else if (y <= 1.2e-22) {
		tmp = t_3;
	} else if (y <= 2.3e+117) {
		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) :: t_3
    real(8) :: tmp
    t_1 = x + (a * (1.0d0 - t))
    t_2 = y * (b - z)
    t_3 = x + (z + ((-2.0d0) * b))
    if (y <= (-5d+87)) then
        tmp = t_2
    else if (y <= (-1.25d+39)) then
        tmp = t_1
    else if (y <= (-1.4d+20)) then
        tmp = t_2
    else if (y <= (-4.9d-217)) then
        tmp = t_3
    else if (y <= (-3.5d-275)) then
        tmp = t_1
    else if (y <= 1.2d-22) then
        tmp = t_3
    else if (y <= 2.3d+117) 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 = x + (a * (1.0 - t));
	double t_2 = y * (b - z);
	double t_3 = x + (z + (-2.0 * b));
	double tmp;
	if (y <= -5e+87) {
		tmp = t_2;
	} else if (y <= -1.25e+39) {
		tmp = t_1;
	} else if (y <= -1.4e+20) {
		tmp = t_2;
	} else if (y <= -4.9e-217) {
		tmp = t_3;
	} else if (y <= -3.5e-275) {
		tmp = t_1;
	} else if (y <= 1.2e-22) {
		tmp = t_3;
	} else if (y <= 2.3e+117) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x + (a * (1.0 - t))
	t_2 = y * (b - z)
	t_3 = x + (z + (-2.0 * b))
	tmp = 0
	if y <= -5e+87:
		tmp = t_2
	elif y <= -1.25e+39:
		tmp = t_1
	elif y <= -1.4e+20:
		tmp = t_2
	elif y <= -4.9e-217:
		tmp = t_3
	elif y <= -3.5e-275:
		tmp = t_1
	elif y <= 1.2e-22:
		tmp = t_3
	elif y <= 2.3e+117:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x + Float64(a * Float64(1.0 - t)))
	t_2 = Float64(y * Float64(b - z))
	t_3 = Float64(x + Float64(z + Float64(-2.0 * b)))
	tmp = 0.0
	if (y <= -5e+87)
		tmp = t_2;
	elseif (y <= -1.25e+39)
		tmp = t_1;
	elseif (y <= -1.4e+20)
		tmp = t_2;
	elseif (y <= -4.9e-217)
		tmp = t_3;
	elseif (y <= -3.5e-275)
		tmp = t_1;
	elseif (y <= 1.2e-22)
		tmp = t_3;
	elseif (y <= 2.3e+117)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x + (a * (1.0 - t));
	t_2 = y * (b - z);
	t_3 = x + (z + (-2.0 * b));
	tmp = 0.0;
	if (y <= -5e+87)
		tmp = t_2;
	elseif (y <= -1.25e+39)
		tmp = t_1;
	elseif (y <= -1.4e+20)
		tmp = t_2;
	elseif (y <= -4.9e-217)
		tmp = t_3;
	elseif (y <= -3.5e-275)
		tmp = t_1;
	elseif (y <= 1.2e-22)
		tmp = t_3;
	elseif (y <= 2.3e+117)
		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[(x + N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(x + N[(z + N[(-2.0 * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -5e+87], t$95$2, If[LessEqual[y, -1.25e+39], t$95$1, If[LessEqual[y, -1.4e+20], t$95$2, If[LessEqual[y, -4.9e-217], t$95$3, If[LessEqual[y, -3.5e-275], t$95$1, If[LessEqual[y, 1.2e-22], t$95$3, If[LessEqual[y, 2.3e+117], t$95$1, t$95$2]]]]]]]]]]

Derivation

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

Alternative 7: 64.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + a \cdot \left(1 - t\right)\\ t_2 := y \cdot \left(b - z\right)\\ t_3 := x + \left(z + \left(t + -2\right) \cdot b\right)\\ \mathbf{if}\;y \leq -1.76 \cdot 10^{+89}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y \leq -6 \cdot 10^{+39}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq -1.6 \cdot 10^{+20}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y \leq -2.25 \cdot 10^{-217}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;y \leq -6.2 \cdot 10^{-260}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq 10^{-22}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;y \leq 2.3 \cdot 10^{+117}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ x (* a (- 1.0 t))))
        (t_2 (* y (- b z)))
        (t_3 (+ x (+ z (* (+ t -2.0) b)))))
   (if (<= y -1.76e+89)
     t_2
     (if (<= y -6e+39)
       t_1
       (if (<= y -1.6e+20)
         t_2
         (if (<= y -2.25e-217)
           t_3
           (if (<= y -6.2e-260)
             t_1
             (if (<= y 1e-22) t_3 (if (<= y 2.3e+117) t_1 t_2)))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x + (a * (1.0 - t));
	double t_2 = y * (b - z);
	double t_3 = x + (z + ((t + -2.0) * b));
	double tmp;
	if (y <= -1.76e+89) {
		tmp = t_2;
	} else if (y <= -6e+39) {
		tmp = t_1;
	} else if (y <= -1.6e+20) {
		tmp = t_2;
	} else if (y <= -2.25e-217) {
		tmp = t_3;
	} else if (y <= -6.2e-260) {
		tmp = t_1;
	} else if (y <= 1e-22) {
		tmp = t_3;
	} else if (y <= 2.3e+117) {
		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) :: t_3
    real(8) :: tmp
    t_1 = x + (a * (1.0d0 - t))
    t_2 = y * (b - z)
    t_3 = x + (z + ((t + (-2.0d0)) * b))
    if (y <= (-1.76d+89)) then
        tmp = t_2
    else if (y <= (-6d+39)) then
        tmp = t_1
    else if (y <= (-1.6d+20)) then
        tmp = t_2
    else if (y <= (-2.25d-217)) then
        tmp = t_3
    else if (y <= (-6.2d-260)) then
        tmp = t_1
    else if (y <= 1d-22) then
        tmp = t_3
    else if (y <= 2.3d+117) 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 = x + (a * (1.0 - t));
	double t_2 = y * (b - z);
	double t_3 = x + (z + ((t + -2.0) * b));
	double tmp;
	if (y <= -1.76e+89) {
		tmp = t_2;
	} else if (y <= -6e+39) {
		tmp = t_1;
	} else if (y <= -1.6e+20) {
		tmp = t_2;
	} else if (y <= -2.25e-217) {
		tmp = t_3;
	} else if (y <= -6.2e-260) {
		tmp = t_1;
	} else if (y <= 1e-22) {
		tmp = t_3;
	} else if (y <= 2.3e+117) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x + (a * (1.0 - t))
	t_2 = y * (b - z)
	t_3 = x + (z + ((t + -2.0) * b))
	tmp = 0
	if y <= -1.76e+89:
		tmp = t_2
	elif y <= -6e+39:
		tmp = t_1
	elif y <= -1.6e+20:
		tmp = t_2
	elif y <= -2.25e-217:
		tmp = t_3
	elif y <= -6.2e-260:
		tmp = t_1
	elif y <= 1e-22:
		tmp = t_3
	elif y <= 2.3e+117:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x + Float64(a * Float64(1.0 - t)))
	t_2 = Float64(y * Float64(b - z))
	t_3 = Float64(x + Float64(z + Float64(Float64(t + -2.0) * b)))
	tmp = 0.0
	if (y <= -1.76e+89)
		tmp = t_2;
	elseif (y <= -6e+39)
		tmp = t_1;
	elseif (y <= -1.6e+20)
		tmp = t_2;
	elseif (y <= -2.25e-217)
		tmp = t_3;
	elseif (y <= -6.2e-260)
		tmp = t_1;
	elseif (y <= 1e-22)
		tmp = t_3;
	elseif (y <= 2.3e+117)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x + (a * (1.0 - t));
	t_2 = y * (b - z);
	t_3 = x + (z + ((t + -2.0) * b));
	tmp = 0.0;
	if (y <= -1.76e+89)
		tmp = t_2;
	elseif (y <= -6e+39)
		tmp = t_1;
	elseif (y <= -1.6e+20)
		tmp = t_2;
	elseif (y <= -2.25e-217)
		tmp = t_3;
	elseif (y <= -6.2e-260)
		tmp = t_1;
	elseif (y <= 1e-22)
		tmp = t_3;
	elseif (y <= 2.3e+117)
		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[(x + N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(x + N[(z + N[(N[(t + -2.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.76e+89], t$95$2, If[LessEqual[y, -6e+39], t$95$1, If[LessEqual[y, -1.6e+20], t$95$2, If[LessEqual[y, -2.25e-217], t$95$3, If[LessEqual[y, -6.2e-260], t$95$1, If[LessEqual[y, 1e-22], t$95$3, If[LessEqual[y, 2.3e+117], t$95$1, t$95$2]]]]]]]]]]

Derivation

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

Alternative 8: 64.3% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := z \cdot \left(1 - y\right)\\ t_2 := x + t_1\\ t_3 := x + b \cdot \left(\left(y + t\right) - 2\right)\\ t_4 := x + a \cdot \left(1 - t\right)\\ \mathbf{if}\;b \leq -2.15 \cdot 10^{+26}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;b \leq -5.2 \cdot 10^{-203}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;b \leq -1.5 \cdot 10^{-266}:\\ \;\;\;\;t_4\\ \mathbf{elif}\;b \leq 9.5 \cdot 10^{-290}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq 1.48 \cdot 10^{-151}:\\ \;\;\;\;t_4\\ \mathbf{elif}\;b \leq 3.5 \cdot 10^{+36}:\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;t_3\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* z (- 1.0 y)))
        (t_2 (+ x t_1))
        (t_3 (+ x (* b (- (+ y t) 2.0))))
        (t_4 (+ x (* a (- 1.0 t)))))
   (if (<= b -2.15e+26)
     t_3
     (if (<= b -5.2e-203)
       t_2
       (if (<= b -1.5e-266)
         t_4
         (if (<= b 9.5e-290)
           t_1
           (if (<= b 1.48e-151) t_4 (if (<= b 3.5e+36) t_2 t_3))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = z * (1.0 - y);
	double t_2 = x + t_1;
	double t_3 = x + (b * ((y + t) - 2.0));
	double t_4 = x + (a * (1.0 - t));
	double tmp;
	if (b <= -2.15e+26) {
		tmp = t_3;
	} else if (b <= -5.2e-203) {
		tmp = t_2;
	} else if (b <= -1.5e-266) {
		tmp = t_4;
	} else if (b <= 9.5e-290) {
		tmp = t_1;
	} else if (b <= 1.48e-151) {
		tmp = t_4;
	} else if (b <= 3.5e+36) {
		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) :: t_4
    real(8) :: tmp
    t_1 = z * (1.0d0 - y)
    t_2 = x + t_1
    t_3 = x + (b * ((y + t) - 2.0d0))
    t_4 = x + (a * (1.0d0 - t))
    if (b <= (-2.15d+26)) then
        tmp = t_3
    else if (b <= (-5.2d-203)) then
        tmp = t_2
    else if (b <= (-1.5d-266)) then
        tmp = t_4
    else if (b <= 9.5d-290) then
        tmp = t_1
    else if (b <= 1.48d-151) then
        tmp = t_4
    else if (b <= 3.5d+36) 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 = z * (1.0 - y);
	double t_2 = x + t_1;
	double t_3 = x + (b * ((y + t) - 2.0));
	double t_4 = x + (a * (1.0 - t));
	double tmp;
	if (b <= -2.15e+26) {
		tmp = t_3;
	} else if (b <= -5.2e-203) {
		tmp = t_2;
	} else if (b <= -1.5e-266) {
		tmp = t_4;
	} else if (b <= 9.5e-290) {
		tmp = t_1;
	} else if (b <= 1.48e-151) {
		tmp = t_4;
	} else if (b <= 3.5e+36) {
		tmp = t_2;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = z * (1.0 - y)
	t_2 = x + t_1
	t_3 = x + (b * ((y + t) - 2.0))
	t_4 = x + (a * (1.0 - t))
	tmp = 0
	if b <= -2.15e+26:
		tmp = t_3
	elif b <= -5.2e-203:
		tmp = t_2
	elif b <= -1.5e-266:
		tmp = t_4
	elif b <= 9.5e-290:
		tmp = t_1
	elif b <= 1.48e-151:
		tmp = t_4
	elif b <= 3.5e+36:
		tmp = t_2
	else:
		tmp = t_3
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(z * Float64(1.0 - y))
	t_2 = Float64(x + t_1)
	t_3 = Float64(x + Float64(b * Float64(Float64(y + t) - 2.0)))
	t_4 = Float64(x + Float64(a * Float64(1.0 - t)))
	tmp = 0.0
	if (b <= -2.15e+26)
		tmp = t_3;
	elseif (b <= -5.2e-203)
		tmp = t_2;
	elseif (b <= -1.5e-266)
		tmp = t_4;
	elseif (b <= 9.5e-290)
		tmp = t_1;
	elseif (b <= 1.48e-151)
		tmp = t_4;
	elseif (b <= 3.5e+36)
		tmp = t_2;
	else
		tmp = t_3;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = z * (1.0 - y);
	t_2 = x + t_1;
	t_3 = x + (b * ((y + t) - 2.0));
	t_4 = x + (a * (1.0 - t));
	tmp = 0.0;
	if (b <= -2.15e+26)
		tmp = t_3;
	elseif (b <= -5.2e-203)
		tmp = t_2;
	elseif (b <= -1.5e-266)
		tmp = t_4;
	elseif (b <= 9.5e-290)
		tmp = t_1;
	elseif (b <= 1.48e-151)
		tmp = t_4;
	elseif (b <= 3.5e+36)
		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[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + t$95$1), $MachinePrecision]}, Block[{t$95$3 = N[(x + N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(x + N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -2.15e+26], t$95$3, If[LessEqual[b, -5.2e-203], t$95$2, If[LessEqual[b, -1.5e-266], t$95$4, If[LessEqual[b, 9.5e-290], t$95$1, If[LessEqual[b, 1.48e-151], t$95$4, If[LessEqual[b, 3.5e+36], t$95$2, t$95$3]]]]]]]]]]

Derivation

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

Alternative 9: 34.8% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := a \cdot \left(1 - t\right)\\ \mathbf{if}\;y \leq -1.6 \cdot 10^{+86}:\\ \;\;\;\;y \cdot \left(-z\right)\\ \mathbf{elif}\;y \leq -1.5 \cdot 10^{+40}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq -1.6 \cdot 10^{+33}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;y \leq -6 \cdot 10^{-182}:\\ \;\;\;\;x + z\\ \mathbf{elif}\;y \leq -1.06 \cdot 10^{-304}:\\ \;\;\;\;-2 \cdot b\\ \mathbf{elif}\;y \leq 1.65 \cdot 10^{+32}:\\ \;\;\;\;x + z\\ \mathbf{elif}\;y \leq 5.6 \cdot 10^{+143}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;y \cdot b\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* a (- 1.0 t))))
   (if (<= y -1.6e+86)
     (* y (- z))
     (if (<= y -1.5e+40)
       t_1
       (if (<= y -1.6e+33)
         (* y b)
         (if (<= y -6e-182)
           (+ x z)
           (if (<= y -1.06e-304)
             (* -2.0 b)
             (if (<= y 1.65e+32)
               (+ x z)
               (if (<= y 5.6e+143) t_1 (* y b))))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = a * (1.0 - t);
	double tmp;
	if (y <= -1.6e+86) {
		tmp = y * -z;
	} else if (y <= -1.5e+40) {
		tmp = t_1;
	} else if (y <= -1.6e+33) {
		tmp = y * b;
	} else if (y <= -6e-182) {
		tmp = x + z;
	} else if (y <= -1.06e-304) {
		tmp = -2.0 * b;
	} else if (y <= 1.65e+32) {
		tmp = x + z;
	} else if (y <= 5.6e+143) {
		tmp = t_1;
	} else {
		tmp = y * 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) :: t_1
    real(8) :: tmp
    t_1 = a * (1.0d0 - t)
    if (y <= (-1.6d+86)) then
        tmp = y * -z
    else if (y <= (-1.5d+40)) then
        tmp = t_1
    else if (y <= (-1.6d+33)) then
        tmp = y * b
    else if (y <= (-6d-182)) then
        tmp = x + z
    else if (y <= (-1.06d-304)) then
        tmp = (-2.0d0) * b
    else if (y <= 1.65d+32) then
        tmp = x + z
    else if (y <= 5.6d+143) then
        tmp = t_1
    else
        tmp = y * 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 t_1 = a * (1.0 - t);
	double tmp;
	if (y <= -1.6e+86) {
		tmp = y * -z;
	} else if (y <= -1.5e+40) {
		tmp = t_1;
	} else if (y <= -1.6e+33) {
		tmp = y * b;
	} else if (y <= -6e-182) {
		tmp = x + z;
	} else if (y <= -1.06e-304) {
		tmp = -2.0 * b;
	} else if (y <= 1.65e+32) {
		tmp = x + z;
	} else if (y <= 5.6e+143) {
		tmp = t_1;
	} else {
		tmp = y * b;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = a * (1.0 - t)
	tmp = 0
	if y <= -1.6e+86:
		tmp = y * -z
	elif y <= -1.5e+40:
		tmp = t_1
	elif y <= -1.6e+33:
		tmp = y * b
	elif y <= -6e-182:
		tmp = x + z
	elif y <= -1.06e-304:
		tmp = -2.0 * b
	elif y <= 1.65e+32:
		tmp = x + z
	elif y <= 5.6e+143:
		tmp = t_1
	else:
		tmp = y * b
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(a * Float64(1.0 - t))
	tmp = 0.0
	if (y <= -1.6e+86)
		tmp = Float64(y * Float64(-z));
	elseif (y <= -1.5e+40)
		tmp = t_1;
	elseif (y <= -1.6e+33)
		tmp = Float64(y * b);
	elseif (y <= -6e-182)
		tmp = Float64(x + z);
	elseif (y <= -1.06e-304)
		tmp = Float64(-2.0 * b);
	elseif (y <= 1.65e+32)
		tmp = Float64(x + z);
	elseif (y <= 5.6e+143)
		tmp = t_1;
	else
		tmp = Float64(y * b);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = a * (1.0 - t);
	tmp = 0.0;
	if (y <= -1.6e+86)
		tmp = y * -z;
	elseif (y <= -1.5e+40)
		tmp = t_1;
	elseif (y <= -1.6e+33)
		tmp = y * b;
	elseif (y <= -6e-182)
		tmp = x + z;
	elseif (y <= -1.06e-304)
		tmp = -2.0 * b;
	elseif (y <= 1.65e+32)
		tmp = x + z;
	elseif (y <= 5.6e+143)
		tmp = t_1;
	else
		tmp = y * b;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.6e+86], N[(y * (-z)), $MachinePrecision], If[LessEqual[y, -1.5e+40], t$95$1, If[LessEqual[y, -1.6e+33], N[(y * b), $MachinePrecision], If[LessEqual[y, -6e-182], N[(x + z), $MachinePrecision], If[LessEqual[y, -1.06e-304], N[(-2.0 * b), $MachinePrecision], If[LessEqual[y, 1.65e+32], N[(x + z), $MachinePrecision], If[LessEqual[y, 5.6e+143], t$95$1, N[(y * b), $MachinePrecision]]]]]]]]]

Derivation

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

Alternative 10: 37.4% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := b \cdot \left(y - 2\right)\\ \mathbf{if}\;b \leq -5.1 \cdot 10^{+42}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq -7.2 \cdot 10^{-35}:\\ \;\;\;\;x + z\\ \mathbf{elif}\;b \leq -6.4 \cdot 10^{-106}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq -8.2 \cdot 10^{-159}:\\ \;\;\;\;y \cdot \left(-z\right)\\ \mathbf{elif}\;b \leq -1.5 \cdot 10^{-249}:\\ \;\;\;\;x + z\\ \mathbf{elif}\;b \leq 4.6 \cdot 10^{-150}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{elif}\;b \leq 4.4 \cdot 10^{+78}:\\ \;\;\;\;x + z\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* b (- y 2.0))))
   (if (<= b -5.1e+42)
     t_1
     (if (<= b -7.2e-35)
       (+ x z)
       (if (<= b -6.4e-106)
         t_1
         (if (<= b -8.2e-159)
           (* y (- z))
           (if (<= b -1.5e-249)
             (+ x z)
             (if (<= b 4.6e-150)
               (* a (- 1.0 t))
               (if (<= b 4.4e+78) (+ x z) t_1)))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = b * (y - 2.0);
	double tmp;
	if (b <= -5.1e+42) {
		tmp = t_1;
	} else if (b <= -7.2e-35) {
		tmp = x + z;
	} else if (b <= -6.4e-106) {
		tmp = t_1;
	} else if (b <= -8.2e-159) {
		tmp = y * -z;
	} else if (b <= -1.5e-249) {
		tmp = x + z;
	} else if (b <= 4.6e-150) {
		tmp = a * (1.0 - t);
	} else if (b <= 4.4e+78) {
		tmp = x + z;
	} 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 = b * (y - 2.0d0)
    if (b <= (-5.1d+42)) then
        tmp = t_1
    else if (b <= (-7.2d-35)) then
        tmp = x + z
    else if (b <= (-6.4d-106)) then
        tmp = t_1
    else if (b <= (-8.2d-159)) then
        tmp = y * -z
    else if (b <= (-1.5d-249)) then
        tmp = x + z
    else if (b <= 4.6d-150) then
        tmp = a * (1.0d0 - t)
    else if (b <= 4.4d+78) then
        tmp = x + z
    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 = b * (y - 2.0);
	double tmp;
	if (b <= -5.1e+42) {
		tmp = t_1;
	} else if (b <= -7.2e-35) {
		tmp = x + z;
	} else if (b <= -6.4e-106) {
		tmp = t_1;
	} else if (b <= -8.2e-159) {
		tmp = y * -z;
	} else if (b <= -1.5e-249) {
		tmp = x + z;
	} else if (b <= 4.6e-150) {
		tmp = a * (1.0 - t);
	} else if (b <= 4.4e+78) {
		tmp = x + z;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = b * (y - 2.0)
	tmp = 0
	if b <= -5.1e+42:
		tmp = t_1
	elif b <= -7.2e-35:
		tmp = x + z
	elif b <= -6.4e-106:
		tmp = t_1
	elif b <= -8.2e-159:
		tmp = y * -z
	elif b <= -1.5e-249:
		tmp = x + z
	elif b <= 4.6e-150:
		tmp = a * (1.0 - t)
	elif b <= 4.4e+78:
		tmp = x + z
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(b * Float64(y - 2.0))
	tmp = 0.0
	if (b <= -5.1e+42)
		tmp = t_1;
	elseif (b <= -7.2e-35)
		tmp = Float64(x + z);
	elseif (b <= -6.4e-106)
		tmp = t_1;
	elseif (b <= -8.2e-159)
		tmp = Float64(y * Float64(-z));
	elseif (b <= -1.5e-249)
		tmp = Float64(x + z);
	elseif (b <= 4.6e-150)
		tmp = Float64(a * Float64(1.0 - t));
	elseif (b <= 4.4e+78)
		tmp = Float64(x + z);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = b * (y - 2.0);
	tmp = 0.0;
	if (b <= -5.1e+42)
		tmp = t_1;
	elseif (b <= -7.2e-35)
		tmp = x + z;
	elseif (b <= -6.4e-106)
		tmp = t_1;
	elseif (b <= -8.2e-159)
		tmp = y * -z;
	elseif (b <= -1.5e-249)
		tmp = x + z;
	elseif (b <= 4.6e-150)
		tmp = a * (1.0 - t);
	elseif (b <= 4.4e+78)
		tmp = x + z;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(b * N[(y - 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -5.1e+42], t$95$1, If[LessEqual[b, -7.2e-35], N[(x + z), $MachinePrecision], If[LessEqual[b, -6.4e-106], t$95$1, If[LessEqual[b, -8.2e-159], N[(y * (-z)), $MachinePrecision], If[LessEqual[b, -1.5e-249], N[(x + z), $MachinePrecision], If[LessEqual[b, 4.6e-150], N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 4.4e+78], N[(x + z), $MachinePrecision], t$95$1]]]]]]]]

Derivation

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

Alternative 11: 48.7% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := t \cdot \left(b - a\right)\\ t_2 := y \cdot \left(b - z\right)\\ \mathbf{if}\;y \leq -2.7 \cdot 10^{+20}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y \leq -3.1 \cdot 10^{-78}:\\ \;\;\;\;x + z\\ \mathbf{elif}\;y \leq -2.7 \cdot 10^{-120}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq -2.2 \cdot 10^{-182}:\\ \;\;\;\;x + z\\ \mathbf{elif}\;y \leq 3.8 \cdot 10^{-235}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq 3.1 \cdot 10^{+30}:\\ \;\;\;\;x + z\\ \mathbf{elif}\;y \leq 2.3 \cdot 10^{+117}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* t (- b a))) (t_2 (* y (- b z))))
   (if (<= y -2.7e+20)
     t_2
     (if (<= y -3.1e-78)
       (+ x z)
       (if (<= y -2.7e-120)
         t_1
         (if (<= y -2.2e-182)
           (+ x z)
           (if (<= y 3.8e-235)
             t_1
             (if (<= y 3.1e+30)
               (+ x z)
               (if (<= y 2.3e+117) (* a (- 1.0 t)) t_2)))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = t * (b - a);
	double t_2 = y * (b - z);
	double tmp;
	if (y <= -2.7e+20) {
		tmp = t_2;
	} else if (y <= -3.1e-78) {
		tmp = x + z;
	} else if (y <= -2.7e-120) {
		tmp = t_1;
	} else if (y <= -2.2e-182) {
		tmp = x + z;
	} else if (y <= 3.8e-235) {
		tmp = t_1;
	} else if (y <= 3.1e+30) {
		tmp = x + z;
	} else if (y <= 2.3e+117) {
		tmp = a * (1.0 - t);
	} 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 = t * (b - a)
    t_2 = y * (b - z)
    if (y <= (-2.7d+20)) then
        tmp = t_2
    else if (y <= (-3.1d-78)) then
        tmp = x + z
    else if (y <= (-2.7d-120)) then
        tmp = t_1
    else if (y <= (-2.2d-182)) then
        tmp = x + z
    else if (y <= 3.8d-235) then
        tmp = t_1
    else if (y <= 3.1d+30) then
        tmp = x + z
    else if (y <= 2.3d+117) then
        tmp = a * (1.0d0 - t)
    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 = t * (b - a);
	double t_2 = y * (b - z);
	double tmp;
	if (y <= -2.7e+20) {
		tmp = t_2;
	} else if (y <= -3.1e-78) {
		tmp = x + z;
	} else if (y <= -2.7e-120) {
		tmp = t_1;
	} else if (y <= -2.2e-182) {
		tmp = x + z;
	} else if (y <= 3.8e-235) {
		tmp = t_1;
	} else if (y <= 3.1e+30) {
		tmp = x + z;
	} else if (y <= 2.3e+117) {
		tmp = a * (1.0 - t);
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = t * (b - a)
	t_2 = y * (b - z)
	tmp = 0
	if y <= -2.7e+20:
		tmp = t_2
	elif y <= -3.1e-78:
		tmp = x + z
	elif y <= -2.7e-120:
		tmp = t_1
	elif y <= -2.2e-182:
		tmp = x + z
	elif y <= 3.8e-235:
		tmp = t_1
	elif y <= 3.1e+30:
		tmp = x + z
	elif y <= 2.3e+117:
		tmp = a * (1.0 - t)
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(t * Float64(b - a))
	t_2 = Float64(y * Float64(b - z))
	tmp = 0.0
	if (y <= -2.7e+20)
		tmp = t_2;
	elseif (y <= -3.1e-78)
		tmp = Float64(x + z);
	elseif (y <= -2.7e-120)
		tmp = t_1;
	elseif (y <= -2.2e-182)
		tmp = Float64(x + z);
	elseif (y <= 3.8e-235)
		tmp = t_1;
	elseif (y <= 3.1e+30)
		tmp = Float64(x + z);
	elseif (y <= 2.3e+117)
		tmp = Float64(a * Float64(1.0 - t));
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = t * (b - a);
	t_2 = y * (b - z);
	tmp = 0.0;
	if (y <= -2.7e+20)
		tmp = t_2;
	elseif (y <= -3.1e-78)
		tmp = x + z;
	elseif (y <= -2.7e-120)
		tmp = t_1;
	elseif (y <= -2.2e-182)
		tmp = x + z;
	elseif (y <= 3.8e-235)
		tmp = t_1;
	elseif (y <= 3.1e+30)
		tmp = x + z;
	elseif (y <= 2.3e+117)
		tmp = a * (1.0 - t);
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2.7e+20], t$95$2, If[LessEqual[y, -3.1e-78], N[(x + z), $MachinePrecision], If[LessEqual[y, -2.7e-120], t$95$1, If[LessEqual[y, -2.2e-182], N[(x + z), $MachinePrecision], If[LessEqual[y, 3.8e-235], t$95$1, If[LessEqual[y, 3.1e+30], N[(x + z), $MachinePrecision], If[LessEqual[y, 2.3e+117], N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]

Derivation

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

Alternative 12: 61.2% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := z \cdot \left(1 - y\right)\\ t_2 := x + t_1\\ t_3 := b \cdot \left(\left(y + t\right) - 2\right)\\ t_4 := x + a \cdot \left(1 - t\right)\\ \mathbf{if}\;b \leq -3.2 \cdot 10^{+26}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;b \leq -7.8 \cdot 10^{-203}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;b \leq -8.5 \cdot 10^{-266}:\\ \;\;\;\;t_4\\ \mathbf{elif}\;b \leq 5.6 \cdot 10^{-290}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq 2.7 \cdot 10^{-150}:\\ \;\;\;\;t_4\\ \mathbf{elif}\;b \leq 3.8 \cdot 10^{+78}:\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;t_3\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* z (- 1.0 y)))
        (t_2 (+ x t_1))
        (t_3 (* b (- (+ y t) 2.0)))
        (t_4 (+ x (* a (- 1.0 t)))))
   (if (<= b -3.2e+26)
     t_3
     (if (<= b -7.8e-203)
       t_2
       (if (<= b -8.5e-266)
         t_4
         (if (<= b 5.6e-290)
           t_1
           (if (<= b 2.7e-150) t_4 (if (<= b 3.8e+78) t_2 t_3))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = z * (1.0 - y);
	double t_2 = x + t_1;
	double t_3 = b * ((y + t) - 2.0);
	double t_4 = x + (a * (1.0 - t));
	double tmp;
	if (b <= -3.2e+26) {
		tmp = t_3;
	} else if (b <= -7.8e-203) {
		tmp = t_2;
	} else if (b <= -8.5e-266) {
		tmp = t_4;
	} else if (b <= 5.6e-290) {
		tmp = t_1;
	} else if (b <= 2.7e-150) {
		tmp = t_4;
	} else if (b <= 3.8e+78) {
		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) :: t_4
    real(8) :: tmp
    t_1 = z * (1.0d0 - y)
    t_2 = x + t_1
    t_3 = b * ((y + t) - 2.0d0)
    t_4 = x + (a * (1.0d0 - t))
    if (b <= (-3.2d+26)) then
        tmp = t_3
    else if (b <= (-7.8d-203)) then
        tmp = t_2
    else if (b <= (-8.5d-266)) then
        tmp = t_4
    else if (b <= 5.6d-290) then
        tmp = t_1
    else if (b <= 2.7d-150) then
        tmp = t_4
    else if (b <= 3.8d+78) 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 = z * (1.0 - y);
	double t_2 = x + t_1;
	double t_3 = b * ((y + t) - 2.0);
	double t_4 = x + (a * (1.0 - t));
	double tmp;
	if (b <= -3.2e+26) {
		tmp = t_3;
	} else if (b <= -7.8e-203) {
		tmp = t_2;
	} else if (b <= -8.5e-266) {
		tmp = t_4;
	} else if (b <= 5.6e-290) {
		tmp = t_1;
	} else if (b <= 2.7e-150) {
		tmp = t_4;
	} else if (b <= 3.8e+78) {
		tmp = t_2;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = z * (1.0 - y)
	t_2 = x + t_1
	t_3 = b * ((y + t) - 2.0)
	t_4 = x + (a * (1.0 - t))
	tmp = 0
	if b <= -3.2e+26:
		tmp = t_3
	elif b <= -7.8e-203:
		tmp = t_2
	elif b <= -8.5e-266:
		tmp = t_4
	elif b <= 5.6e-290:
		tmp = t_1
	elif b <= 2.7e-150:
		tmp = t_4
	elif b <= 3.8e+78:
		tmp = t_2
	else:
		tmp = t_3
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(z * Float64(1.0 - y))
	t_2 = Float64(x + t_1)
	t_3 = Float64(b * Float64(Float64(y + t) - 2.0))
	t_4 = Float64(x + Float64(a * Float64(1.0 - t)))
	tmp = 0.0
	if (b <= -3.2e+26)
		tmp = t_3;
	elseif (b <= -7.8e-203)
		tmp = t_2;
	elseif (b <= -8.5e-266)
		tmp = t_4;
	elseif (b <= 5.6e-290)
		tmp = t_1;
	elseif (b <= 2.7e-150)
		tmp = t_4;
	elseif (b <= 3.8e+78)
		tmp = t_2;
	else
		tmp = t_3;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = z * (1.0 - y);
	t_2 = x + t_1;
	t_3 = b * ((y + t) - 2.0);
	t_4 = x + (a * (1.0 - t));
	tmp = 0.0;
	if (b <= -3.2e+26)
		tmp = t_3;
	elseif (b <= -7.8e-203)
		tmp = t_2;
	elseif (b <= -8.5e-266)
		tmp = t_4;
	elseif (b <= 5.6e-290)
		tmp = t_1;
	elseif (b <= 2.7e-150)
		tmp = t_4;
	elseif (b <= 3.8e+78)
		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[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + t$95$1), $MachinePrecision]}, Block[{t$95$3 = N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(x + N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -3.2e+26], t$95$3, If[LessEqual[b, -7.8e-203], t$95$2, If[LessEqual[b, -8.5e-266], t$95$4, If[LessEqual[b, 5.6e-290], t$95$1, If[LessEqual[b, 2.7e-150], t$95$4, If[LessEqual[b, 3.8e+78], t$95$2, t$95$3]]]]]]]]]]

Derivation

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

Alternative 13: 85.6% accurate, 1.1× speedup

Math

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

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* a (- 1.0 t))))
   (if (or (<= z -1.55e+144) (not (<= z 5.6e+104)))
     (+ x (+ (* z (- 1.0 y)) t_1))
     (+ (+ x (* b (- (+ y t) 2.0))) t_1))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = a * (1.0 - t);
	double tmp;
	if ((z <= -1.55e+144) || !(z <= 5.6e+104)) {
		tmp = x + ((z * (1.0 - y)) + t_1);
	} else {
		tmp = (x + (b * ((y + t) - 2.0))) + 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 = a * (1.0d0 - t)
    if ((z <= (-1.55d+144)) .or. (.not. (z <= 5.6d+104))) then
        tmp = x + ((z * (1.0d0 - y)) + t_1)
    else
        tmp = (x + (b * ((y + t) - 2.0d0))) + 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 = a * (1.0 - t);
	double tmp;
	if ((z <= -1.55e+144) || !(z <= 5.6e+104)) {
		tmp = x + ((z * (1.0 - y)) + t_1);
	} else {
		tmp = (x + (b * ((y + t) - 2.0))) + t_1;
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 14: 85.9% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := z \cdot \left(1 - y\right)\\ \mathbf{if}\;b \leq -7.8 \cdot 10^{-98} \lor \neg \left(b \leq 6.6 \cdot 10^{+28}\right):\\ \;\;\;\;\left(x + b \cdot \left(\left(y + t\right) - 2\right)\right) + t_1\\ \mathbf{else}:\\ \;\;\;\;x + \left(t_1 + a \cdot \left(1 - t\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* z (- 1.0 y))))
   (if (or (<= b -7.8e-98) (not (<= b 6.6e+28)))
     (+ (+ x (* b (- (+ y t) 2.0))) t_1)
     (+ x (+ t_1 (* a (- 1.0 t)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = z * (1.0 - y);
	double tmp;
	if ((b <= -7.8e-98) || !(b <= 6.6e+28)) {
		tmp = (x + (b * ((y + t) - 2.0))) + t_1;
	} else {
		tmp = x + (t_1 + (a * (1.0 - t)));
	}
	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 = z * (1.0d0 - y)
    if ((b <= (-7.8d-98)) .or. (.not. (b <= 6.6d+28))) then
        tmp = (x + (b * ((y + t) - 2.0d0))) + t_1
    else
        tmp = x + (t_1 + (a * (1.0d0 - t)))
    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 * (1.0 - y);
	double tmp;
	if ((b <= -7.8e-98) || !(b <= 6.6e+28)) {
		tmp = (x + (b * ((y + t) - 2.0))) + t_1;
	} else {
		tmp = x + (t_1 + (a * (1.0 - t)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = z * (1.0 - y)
	tmp = 0
	if (b <= -7.8e-98) or not (b <= 6.6e+28):
		tmp = (x + (b * ((y + t) - 2.0))) + t_1
	else:
		tmp = x + (t_1 + (a * (1.0 - t)))
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(z * Float64(1.0 - y))
	tmp = 0.0
	if ((b <= -7.8e-98) || !(b <= 6.6e+28))
		tmp = Float64(Float64(x + Float64(b * Float64(Float64(y + t) - 2.0))) + t_1);
	else
		tmp = Float64(x + Float64(t_1 + Float64(a * Float64(1.0 - t))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = z * (1.0 - y);
	tmp = 0.0;
	if ((b <= -7.8e-98) || ~((b <= 6.6e+28)))
		tmp = (x + (b * ((y + t) - 2.0))) + t_1;
	else
		tmp = x + (t_1 + (a * (1.0 - t)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[b, -7.8e-98], N[Not[LessEqual[b, 6.6e+28]], $MachinePrecision]], N[(N[(x + N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], N[(x + N[(t$95$1 + N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 15: 25.3% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -3.7 \cdot 10^{+24}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;y \leq -4.2 \cdot 10^{-79}:\\ \;\;\;\;x\\ \mathbf{elif}\;y \leq -3.35 \cdot 10^{-152}:\\ \;\;\;\;t \cdot b\\ \mathbf{elif}\;y \leq -2.2 \cdot 10^{-303}:\\ \;\;\;\;-2 \cdot b\\ \mathbf{elif}\;y \leq 1.05 \cdot 10^{-235}:\\ \;\;\;\;t \cdot b\\ \mathbf{elif}\;y \leq 1.25 \cdot 10^{-50}:\\ \;\;\;\;z\\ \mathbf{elif}\;y \leq 8.7 \cdot 10^{+108}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;y \cdot b\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= y -3.7e+24)
   (* y b)
   (if (<= y -4.2e-79)
     x
     (if (<= y -3.35e-152)
       (* t b)
       (if (<= y -2.2e-303)
         (* -2.0 b)
         (if (<= y 1.05e-235)
           (* t b)
           (if (<= y 1.25e-50) z (if (<= y 8.7e+108) x (* y b)))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (y <= -3.7e+24) {
		tmp = y * b;
	} else if (y <= -4.2e-79) {
		tmp = x;
	} else if (y <= -3.35e-152) {
		tmp = t * b;
	} else if (y <= -2.2e-303) {
		tmp = -2.0 * b;
	} else if (y <= 1.05e-235) {
		tmp = t * b;
	} else if (y <= 1.25e-50) {
		tmp = z;
	} else if (y <= 8.7e+108) {
		tmp = x;
	} else {
		tmp = y * 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 <= (-3.7d+24)) then
        tmp = y * b
    else if (y <= (-4.2d-79)) then
        tmp = x
    else if (y <= (-3.35d-152)) then
        tmp = t * b
    else if (y <= (-2.2d-303)) then
        tmp = (-2.0d0) * b
    else if (y <= 1.05d-235) then
        tmp = t * b
    else if (y <= 1.25d-50) then
        tmp = z
    else if (y <= 8.7d+108) then
        tmp = x
    else
        tmp = y * 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 <= -3.7e+24) {
		tmp = y * b;
	} else if (y <= -4.2e-79) {
		tmp = x;
	} else if (y <= -3.35e-152) {
		tmp = t * b;
	} else if (y <= -2.2e-303) {
		tmp = -2.0 * b;
	} else if (y <= 1.05e-235) {
		tmp = t * b;
	} else if (y <= 1.25e-50) {
		tmp = z;
	} else if (y <= 8.7e+108) {
		tmp = x;
	} else {
		tmp = y * b;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if y <= -3.7e+24:
		tmp = y * b
	elif y <= -4.2e-79:
		tmp = x
	elif y <= -3.35e-152:
		tmp = t * b
	elif y <= -2.2e-303:
		tmp = -2.0 * b
	elif y <= 1.05e-235:
		tmp = t * b
	elif y <= 1.25e-50:
		tmp = z
	elif y <= 8.7e+108:
		tmp = x
	else:
		tmp = y * b
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (y <= -3.7e+24)
		tmp = Float64(y * b);
	elseif (y <= -4.2e-79)
		tmp = x;
	elseif (y <= -3.35e-152)
		tmp = Float64(t * b);
	elseif (y <= -2.2e-303)
		tmp = Float64(-2.0 * b);
	elseif (y <= 1.05e-235)
		tmp = Float64(t * b);
	elseif (y <= 1.25e-50)
		tmp = z;
	elseif (y <= 8.7e+108)
		tmp = x;
	else
		tmp = Float64(y * b);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (y <= -3.7e+24)
		tmp = y * b;
	elseif (y <= -4.2e-79)
		tmp = x;
	elseif (y <= -3.35e-152)
		tmp = t * b;
	elseif (y <= -2.2e-303)
		tmp = -2.0 * b;
	elseif (y <= 1.05e-235)
		tmp = t * b;
	elseif (y <= 1.25e-50)
		tmp = z;
	elseif (y <= 8.7e+108)
		tmp = x;
	else
		tmp = y * b;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[y, -3.7e+24], N[(y * b), $MachinePrecision], If[LessEqual[y, -4.2e-79], x, If[LessEqual[y, -3.35e-152], N[(t * b), $MachinePrecision], If[LessEqual[y, -2.2e-303], N[(-2.0 * b), $MachinePrecision], If[LessEqual[y, 1.05e-235], N[(t * b), $MachinePrecision], If[LessEqual[y, 1.25e-50], z, If[LessEqual[y, 8.7e+108], x, N[(y * b), $MachinePrecision]]]]]]]]

Derivation

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

Alternative 16: 70.0% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + \left(a + z \cdot \left(1 - y\right)\right)\\ t_2 := x + b \cdot \left(\left(y + t\right) - 2\right)\\ \mathbf{if}\;b \leq -4.5 \cdot 10^{+26}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;b \leq 10^{-289}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq 4.5 \cdot 10^{-168}:\\ \;\;\;\;x + a \cdot \left(1 - t\right)\\ \mathbf{elif}\;b \leq 3.4 \cdot 10^{+70}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ x (+ a (* z (- 1.0 y))))) (t_2 (+ x (* b (- (+ y t) 2.0)))))
   (if (<= b -4.5e+26)
     t_2
     (if (<= b 1e-289)
       t_1
       (if (<= b 4.5e-168)
         (+ x (* a (- 1.0 t)))
         (if (<= b 3.4e+70) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x + (a + (z * (1.0 - y)));
	double t_2 = x + (b * ((y + t) - 2.0));
	double tmp;
	if (b <= -4.5e+26) {
		tmp = t_2;
	} else if (b <= 1e-289) {
		tmp = t_1;
	} else if (b <= 4.5e-168) {
		tmp = x + (a * (1.0 - t));
	} else if (b <= 3.4e+70) {
		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 = x + (a + (z * (1.0d0 - y)))
    t_2 = x + (b * ((y + t) - 2.0d0))
    if (b <= (-4.5d+26)) then
        tmp = t_2
    else if (b <= 1d-289) then
        tmp = t_1
    else if (b <= 4.5d-168) then
        tmp = x + (a * (1.0d0 - t))
    else if (b <= 3.4d+70) 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 = x + (a + (z * (1.0 - y)));
	double t_2 = x + (b * ((y + t) - 2.0));
	double tmp;
	if (b <= -4.5e+26) {
		tmp = t_2;
	} else if (b <= 1e-289) {
		tmp = t_1;
	} else if (b <= 4.5e-168) {
		tmp = x + (a * (1.0 - t));
	} else if (b <= 3.4e+70) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x + (a + (z * (1.0 - y)))
	t_2 = x + (b * ((y + t) - 2.0))
	tmp = 0
	if b <= -4.5e+26:
		tmp = t_2
	elif b <= 1e-289:
		tmp = t_1
	elif b <= 4.5e-168:
		tmp = x + (a * (1.0 - t))
	elif b <= 3.4e+70:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x + Float64(a + Float64(z * Float64(1.0 - y))))
	t_2 = Float64(x + Float64(b * Float64(Float64(y + t) - 2.0)))
	tmp = 0.0
	if (b <= -4.5e+26)
		tmp = t_2;
	elseif (b <= 1e-289)
		tmp = t_1;
	elseif (b <= 4.5e-168)
		tmp = Float64(x + Float64(a * Float64(1.0 - t)));
	elseif (b <= 3.4e+70)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x + (a + (z * (1.0 - y)));
	t_2 = x + (b * ((y + t) - 2.0));
	tmp = 0.0;
	if (b <= -4.5e+26)
		tmp = t_2;
	elseif (b <= 1e-289)
		tmp = t_1;
	elseif (b <= 4.5e-168)
		tmp = x + (a * (1.0 - t));
	elseif (b <= 3.4e+70)
		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[(x + N[(a + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -4.5e+26], t$95$2, If[LessEqual[b, 1e-289], t$95$1, If[LessEqual[b, 4.5e-168], N[(x + N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 3.4e+70], t$95$1, t$95$2]]]]]]

Derivation

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

Alternative 17: 83.6% accurate, 1.2× speedup

Math

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

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= b -1.05e+27) (not (<= b 8.5e+65)))
   (+ x (* b (- (+ y t) 2.0)))
   (+ x (+ (* z (- 1.0 y)) (* a (- 1.0 t))))))

C

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

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (b <= -1.05e+27) or not (b <= 8.5e+65):
		tmp = x + (b * ((y + t) - 2.0))
	else:
		tmp = x + ((z * (1.0 - y)) + (a * (1.0 - t)))
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((b <= -1.05e+27) || !(b <= 8.5e+65))
		tmp = Float64(x + Float64(b * Float64(Float64(y + t) - 2.0)));
	else
		tmp = Float64(x + Float64(Float64(z * Float64(1.0 - y)) + Float64(a * Float64(1.0 - t))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((b <= -1.05e+27) || ~((b <= 8.5e+65)))
		tmp = x + (b * ((y + t) - 2.0));
	else
		tmp = x + ((z * (1.0 - y)) + (a * (1.0 - t)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[b, -1.05e+27], N[Not[LessEqual[b, 8.5e+65]], $MachinePrecision]], N[(x + N[(b * N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision] + N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 18: 55.2% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x - t \cdot a\\ t_2 := y \cdot \left(b - z\right)\\ \mathbf{if}\;y \leq -1.16 \cdot 10^{+86}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y \leq -2.15 \cdot 10^{+39}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq -2.7 \cdot 10^{+22}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y \leq 1.32 \cdot 10^{-17}:\\ \;\;\;\;x + \left(z + -2 \cdot b\right)\\ \mathbf{elif}\;y \leq 2.3 \cdot 10^{+117}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (- x (* t a))) (t_2 (* y (- b z))))
   (if (<= y -1.16e+86)
     t_2
     (if (<= y -2.15e+39)
       t_1
       (if (<= y -2.7e+22)
         t_2
         (if (<= y 1.32e-17)
           (+ x (+ z (* -2.0 b)))
           (if (<= y 2.3e+117) t_1 t_2)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x - (t * a);
	double t_2 = y * (b - z);
	double tmp;
	if (y <= -1.16e+86) {
		tmp = t_2;
	} else if (y <= -2.15e+39) {
		tmp = t_1;
	} else if (y <= -2.7e+22) {
		tmp = t_2;
	} else if (y <= 1.32e-17) {
		tmp = x + (z + (-2.0 * b));
	} else if (y <= 2.3e+117) {
		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 = x - (t * a)
    t_2 = y * (b - z)
    if (y <= (-1.16d+86)) then
        tmp = t_2
    else if (y <= (-2.15d+39)) then
        tmp = t_1
    else if (y <= (-2.7d+22)) then
        tmp = t_2
    else if (y <= 1.32d-17) then
        tmp = x + (z + ((-2.0d0) * b))
    else if (y <= 2.3d+117) 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 = x - (t * a);
	double t_2 = y * (b - z);
	double tmp;
	if (y <= -1.16e+86) {
		tmp = t_2;
	} else if (y <= -2.15e+39) {
		tmp = t_1;
	} else if (y <= -2.7e+22) {
		tmp = t_2;
	} else if (y <= 1.32e-17) {
		tmp = x + (z + (-2.0 * b));
	} else if (y <= 2.3e+117) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x - (t * a)
	t_2 = y * (b - z)
	tmp = 0
	if y <= -1.16e+86:
		tmp = t_2
	elif y <= -2.15e+39:
		tmp = t_1
	elif y <= -2.7e+22:
		tmp = t_2
	elif y <= 1.32e-17:
		tmp = x + (z + (-2.0 * b))
	elif y <= 2.3e+117:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x - Float64(t * a))
	t_2 = Float64(y * Float64(b - z))
	tmp = 0.0
	if (y <= -1.16e+86)
		tmp = t_2;
	elseif (y <= -2.15e+39)
		tmp = t_1;
	elseif (y <= -2.7e+22)
		tmp = t_2;
	elseif (y <= 1.32e-17)
		tmp = Float64(x + Float64(z + Float64(-2.0 * b)));
	elseif (y <= 2.3e+117)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x - (t * a);
	t_2 = y * (b - z);
	tmp = 0.0;
	if (y <= -1.16e+86)
		tmp = t_2;
	elseif (y <= -2.15e+39)
		tmp = t_1;
	elseif (y <= -2.7e+22)
		tmp = t_2;
	elseif (y <= 1.32e-17)
		tmp = x + (z + (-2.0 * b));
	elseif (y <= 2.3e+117)
		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[(x - N[(t * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.16e+86], t$95$2, If[LessEqual[y, -2.15e+39], t$95$1, If[LessEqual[y, -2.7e+22], t$95$2, If[LessEqual[y, 1.32e-17], N[(x + N[(z + N[(-2.0 * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.3e+117], t$95$1, t$95$2]]]]]]]

Derivation

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

Alternative 19: 33.4% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -1.35 \cdot 10^{+25}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;y \leq -3.9 \cdot 10^{-182}:\\ \;\;\;\;x + z\\ \mathbf{elif}\;y \leq -2.8 \cdot 10^{-306}:\\ \;\;\;\;-2 \cdot b\\ \mathbf{elif}\;y \leq 4.8 \cdot 10^{+101}:\\ \;\;\;\;x + z\\ \mathbf{else}:\\ \;\;\;\;y \cdot b\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= y -1.35e+25)
   (* y b)
   (if (<= y -3.9e-182)
     (+ x z)
     (if (<= y -2.8e-306) (* -2.0 b) (if (<= y 4.8e+101) (+ x z) (* y b))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (y <= -1.35e+25) {
		tmp = y * b;
	} else if (y <= -3.9e-182) {
		tmp = x + z;
	} else if (y <= -2.8e-306) {
		tmp = -2.0 * b;
	} else if (y <= 4.8e+101) {
		tmp = x + z;
	} else {
		tmp = y * 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 <= (-1.35d+25)) then
        tmp = y * b
    else if (y <= (-3.9d-182)) then
        tmp = x + z
    else if (y <= (-2.8d-306)) then
        tmp = (-2.0d0) * b
    else if (y <= 4.8d+101) then
        tmp = x + z
    else
        tmp = y * 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 <= -1.35e+25) {
		tmp = y * b;
	} else if (y <= -3.9e-182) {
		tmp = x + z;
	} else if (y <= -2.8e-306) {
		tmp = -2.0 * b;
	} else if (y <= 4.8e+101) {
		tmp = x + z;
	} else {
		tmp = y * b;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if y <= -1.35e+25:
		tmp = y * b
	elif y <= -3.9e-182:
		tmp = x + z
	elif y <= -2.8e-306:
		tmp = -2.0 * b
	elif y <= 4.8e+101:
		tmp = x + z
	else:
		tmp = y * b
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (y <= -1.35e+25)
		tmp = Float64(y * b);
	elseif (y <= -3.9e-182)
		tmp = Float64(x + z);
	elseif (y <= -2.8e-306)
		tmp = Float64(-2.0 * b);
	elseif (y <= 4.8e+101)
		tmp = Float64(x + z);
	else
		tmp = Float64(y * b);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (y <= -1.35e+25)
		tmp = y * b;
	elseif (y <= -3.9e-182)
		tmp = x + z;
	elseif (y <= -2.8e-306)
		tmp = -2.0 * b;
	elseif (y <= 4.8e+101)
		tmp = x + z;
	else
		tmp = y * b;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[y, -1.35e+25], N[(y * b), $MachinePrecision], If[LessEqual[y, -3.9e-182], N[(x + z), $MachinePrecision], If[LessEqual[y, -2.8e-306], N[(-2.0 * b), $MachinePrecision], If[LessEqual[y, 4.8e+101], N[(x + z), $MachinePrecision], N[(y * b), $MachinePrecision]]]]]

Derivation

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

Alternative 20: 55.0% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := t \cdot \left(b - a\right)\\ \mathbf{if}\;t \leq -58000000:\\ \;\;\;\;t_1\\ \mathbf{elif}\;t \leq 9.5 \cdot 10^{-42}:\\ \;\;\;\;x + b \cdot \left(y - 2\right)\\ \mathbf{elif}\;t \leq 6.2 \cdot 10^{+134}:\\ \;\;\;\;z \cdot \left(1 - y\right)\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* t (- b a))))
   (if (<= t -58000000.0)
     t_1
     (if (<= t 9.5e-42)
       (+ x (* b (- y 2.0)))
       (if (<= t 6.2e+134) (* z (- 1.0 y)) t_1)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = t * (b - a);
	double tmp;
	if (t <= -58000000.0) {
		tmp = t_1;
	} else if (t <= 9.5e-42) {
		tmp = x + (b * (y - 2.0));
	} else if (t <= 6.2e+134) {
		tmp = z * (1.0 - 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 * (b - a)
    if (t <= (-58000000.0d0)) then
        tmp = t_1
    else if (t <= 9.5d-42) then
        tmp = x + (b * (y - 2.0d0))
    else if (t <= 6.2d+134) then
        tmp = z * (1.0d0 - 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 * (b - a);
	double tmp;
	if (t <= -58000000.0) {
		tmp = t_1;
	} else if (t <= 9.5e-42) {
		tmp = x + (b * (y - 2.0));
	} else if (t <= 6.2e+134) {
		tmp = z * (1.0 - y);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = t * (b - a)
	tmp = 0
	if t <= -58000000.0:
		tmp = t_1
	elif t <= 9.5e-42:
		tmp = x + (b * (y - 2.0))
	elif t <= 6.2e+134:
		tmp = z * (1.0 - y)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(t * Float64(b - a))
	tmp = 0.0
	if (t <= -58000000.0)
		tmp = t_1;
	elseif (t <= 9.5e-42)
		tmp = Float64(x + Float64(b * Float64(y - 2.0)));
	elseif (t <= 6.2e+134)
		tmp = Float64(z * Float64(1.0 - y));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = t * (b - a);
	tmp = 0.0;
	if (t <= -58000000.0)
		tmp = t_1;
	elseif (t <= 9.5e-42)
		tmp = x + (b * (y - 2.0));
	elseif (t <= 6.2e+134)
		tmp = z * (1.0 - y);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -58000000.0], t$95$1, If[LessEqual[t, 9.5e-42], N[(x + N[(b * N[(y - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 6.2e+134], N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

Derivation

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

Alternative 21: 21.0% accurate, 4.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -1.55 \cdot 10^{+144}:\\ \;\;\;\;z\\ \mathbf{elif}\;z \leq 1.35 \cdot 10^{+109}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;z\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= z -1.55e+144) z (if (<= z 1.35e+109) x z)))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (z <= -1.55e+144) {
		tmp = z;
	} else if (z <= 1.35e+109) {
		tmp = x;
	} else {
		tmp = 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 <= (-1.55d+144)) then
        tmp = z
    else if (z <= 1.35d+109) then
        tmp = x
    else
        tmp = 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 <= -1.55e+144) {
		tmp = z;
	} else if (z <= 1.35e+109) {
		tmp = x;
	} else {
		tmp = z;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if z <= -1.55e+144:
		tmp = z
	elif z <= 1.35e+109:
		tmp = x
	else:
		tmp = z
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (z <= -1.55e+144)
		tmp = z;
	elseif (z <= 1.35e+109)
		tmp = x;
	else
		tmp = z;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (z <= -1.55e+144)
		tmp = z;
	elseif (z <= 1.35e+109)
		tmp = x;
	else
		tmp = z;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[z, -1.55e+144], z, If[LessEqual[z, 1.35e+109], x, z]]

Derivation

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

Alternative 22: 16.0% accurate, 21.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

Reproduce

herbie shell --seed 2023350 
(FPCore (x y z t a b)
  :name "Statistics.Distribution.Beta:$centropy from math-functions-0.1.5.2"
  :precision binary64
  (+ (- (- x (* (- y 1.0) z)) (* (- t 1.0) a)) (* (- (+ y t) 2.0) b)))