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

Percentage Accurate: 95.2% → 98.0%

Time: 14.7s

Alternatives: 25

Speedup: 0.5×

• 36.7% 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.2% 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.0% 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) + \left(\left(y + t\right) - 2\right) \cdot b\\ \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))) (* (- (+ y t) 2.0) b))))
   (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))) + (((y + t) - 2.0) * b);
	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))) + (((y + t) - 2.0) * b);
	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))) + (((y + t) - 2.0) * b)
	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(Float64(Float64(y + t) - 2.0) * b))
	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))) + (((y + t) - 2.0) * b);
	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[(N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision] * b), $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: 83.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := a \cdot \left(1 - t\right)\\ t_2 := x + \left(\left(y + t\right) - 2\right) \cdot b\\ t_3 := t_2 + t_1\\ \mathbf{if}\;b \leq -8.5 \cdot 10^{-145}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;b \leq 3.2 \cdot 10^{+35}:\\ \;\;\;\;x + \left(t_1 + \left(z - y \cdot z\right)\right)\\ \mathbf{elif}\;b \leq 1.15 \cdot 10^{+116}:\\ \;\;\;\;t_3\\ \mathbf{else}:\\ \;\;\;\;t_2 + z \cdot \left(1 - y\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* a (- 1.0 t)))
        (t_2 (+ x (* (- (+ y t) 2.0) b)))
        (t_3 (+ t_2 t_1)))
   (if (<= b -8.5e-145)
     t_3
     (if (<= b 3.2e+35)
       (+ x (+ t_1 (- z (* y z))))
       (if (<= b 1.15e+116) t_3 (+ t_2 (* z (- 1.0 y))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = a * (1.0 - t);
	double t_2 = x + (((y + t) - 2.0) * b);
	double t_3 = t_2 + t_1;
	double tmp;
	if (b <= -8.5e-145) {
		tmp = t_3;
	} else if (b <= 3.2e+35) {
		tmp = x + (t_1 + (z - (y * z)));
	} else if (b <= 1.15e+116) {
		tmp = t_3;
	} else {
		tmp = t_2 + (z * (1.0 - 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) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_1 = a * (1.0d0 - t)
    t_2 = x + (((y + t) - 2.0d0) * b)
    t_3 = t_2 + t_1
    if (b <= (-8.5d-145)) then
        tmp = t_3
    else if (b <= 3.2d+35) then
        tmp = x + (t_1 + (z - (y * z)))
    else if (b <= 1.15d+116) then
        tmp = t_3
    else
        tmp = t_2 + (z * (1.0d0 - 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 t_1 = a * (1.0 - t);
	double t_2 = x + (((y + t) - 2.0) * b);
	double t_3 = t_2 + t_1;
	double tmp;
	if (b <= -8.5e-145) {
		tmp = t_3;
	} else if (b <= 3.2e+35) {
		tmp = x + (t_1 + (z - (y * z)));
	} else if (b <= 1.15e+116) {
		tmp = t_3;
	} else {
		tmp = t_2 + (z * (1.0 - y));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = a * (1.0 - t)
	t_2 = x + (((y + t) - 2.0) * b)
	t_3 = t_2 + t_1
	tmp = 0
	if b <= -8.5e-145:
		tmp = t_3
	elif b <= 3.2e+35:
		tmp = x + (t_1 + (z - (y * z)))
	elif b <= 1.15e+116:
		tmp = t_3
	else:
		tmp = t_2 + (z * (1.0 - y))
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(a * Float64(1.0 - t))
	t_2 = Float64(x + Float64(Float64(Float64(y + t) - 2.0) * b))
	t_3 = Float64(t_2 + t_1)
	tmp = 0.0
	if (b <= -8.5e-145)
		tmp = t_3;
	elseif (b <= 3.2e+35)
		tmp = Float64(x + Float64(t_1 + Float64(z - Float64(y * z))));
	elseif (b <= 1.15e+116)
		tmp = t_3;
	else
		tmp = Float64(t_2 + Float64(z * Float64(1.0 - y)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = a * (1.0 - t);
	t_2 = x + (((y + t) - 2.0) * b);
	t_3 = t_2 + t_1;
	tmp = 0.0;
	if (b <= -8.5e-145)
		tmp = t_3;
	elseif (b <= 3.2e+35)
		tmp = x + (t_1 + (z - (y * z)));
	elseif (b <= 1.15e+116)
		tmp = t_3;
	else
		tmp = t_2 + (z * (1.0 - y));
	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]}, Block[{t$95$2 = N[(x + N[(N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 + t$95$1), $MachinePrecision]}, If[LessEqual[b, -8.5e-145], t$95$3, If[LessEqual[b, 3.2e+35], N[(x + N[(t$95$1 + N[(z - N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.15e+116], t$95$3, N[(t$95$2 + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]

Derivation

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

Alternative 3: 85.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + \left(\left(y + t\right) - 2\right) \cdot b\\ t_2 := a \cdot \left(1 - t\right)\\ \mathbf{if}\;b \leq -2.7 \cdot 10^{+95}:\\ \;\;\;\;z + \left(x + \left(y \cdot \left(b - z\right) + b \cdot \left(t - 2\right)\right)\right)\\ \mathbf{elif}\;b \leq 1.22 \cdot 10^{+36}:\\ \;\;\;\;x + \left(t_2 + \left(z - y \cdot z\right)\right)\\ \mathbf{elif}\;b \leq 3.9 \cdot 10^{+114}:\\ \;\;\;\;t_1 + t_2\\ \mathbf{else}:\\ \;\;\;\;t_1 + z \cdot \left(1 - y\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ x (* (- (+ y t) 2.0) b))) (t_2 (* a (- 1.0 t))))
   (if (<= b -2.7e+95)
     (+ z (+ x (+ (* y (- b z)) (* b (- t 2.0)))))
     (if (<= b 1.22e+36)
       (+ x (+ t_2 (- z (* y z))))
       (if (<= b 3.9e+114) (+ t_1 t_2) (+ t_1 (* z (- 1.0 y))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x + (((y + t) - 2.0) * b);
	double t_2 = a * (1.0 - t);
	double tmp;
	if (b <= -2.7e+95) {
		tmp = z + (x + ((y * (b - z)) + (b * (t - 2.0))));
	} else if (b <= 1.22e+36) {
		tmp = x + (t_2 + (z - (y * z)));
	} else if (b <= 3.9e+114) {
		tmp = t_1 + t_2;
	} else {
		tmp = t_1 + (z * (1.0 - 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) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = x + (((y + t) - 2.0d0) * b)
    t_2 = a * (1.0d0 - t)
    if (b <= (-2.7d+95)) then
        tmp = z + (x + ((y * (b - z)) + (b * (t - 2.0d0))))
    else if (b <= 1.22d+36) then
        tmp = x + (t_2 + (z - (y * z)))
    else if (b <= 3.9d+114) then
        tmp = t_1 + t_2
    else
        tmp = t_1 + (z * (1.0d0 - 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 t_1 = x + (((y + t) - 2.0) * b);
	double t_2 = a * (1.0 - t);
	double tmp;
	if (b <= -2.7e+95) {
		tmp = z + (x + ((y * (b - z)) + (b * (t - 2.0))));
	} else if (b <= 1.22e+36) {
		tmp = x + (t_2 + (z - (y * z)));
	} else if (b <= 3.9e+114) {
		tmp = t_1 + t_2;
	} else {
		tmp = t_1 + (z * (1.0 - y));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x + (((y + t) - 2.0) * b)
	t_2 = a * (1.0 - t)
	tmp = 0
	if b <= -2.7e+95:
		tmp = z + (x + ((y * (b - z)) + (b * (t - 2.0))))
	elif b <= 1.22e+36:
		tmp = x + (t_2 + (z - (y * z)))
	elif b <= 3.9e+114:
		tmp = t_1 + t_2
	else:
		tmp = t_1 + (z * (1.0 - y))
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x + Float64(Float64(Float64(y + t) - 2.0) * b))
	t_2 = Float64(a * Float64(1.0 - t))
	tmp = 0.0
	if (b <= -2.7e+95)
		tmp = Float64(z + Float64(x + Float64(Float64(y * Float64(b - z)) + Float64(b * Float64(t - 2.0)))));
	elseif (b <= 1.22e+36)
		tmp = Float64(x + Float64(t_2 + Float64(z - Float64(y * z))));
	elseif (b <= 3.9e+114)
		tmp = Float64(t_1 + t_2);
	else
		tmp = Float64(t_1 + Float64(z * Float64(1.0 - y)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x + (((y + t) - 2.0) * b);
	t_2 = a * (1.0 - t);
	tmp = 0.0;
	if (b <= -2.7e+95)
		tmp = z + (x + ((y * (b - z)) + (b * (t - 2.0))));
	elseif (b <= 1.22e+36)
		tmp = x + (t_2 + (z - (y * z)));
	elseif (b <= 3.9e+114)
		tmp = t_1 + t_2;
	else
		tmp = t_1 + (z * (1.0 - y));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

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

Alternative 4: 84.1% accurate, 1.1× speedup

Math

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

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* a (- 1.0 t))))
   (if (or (<= b -8.5e-145) (not (<= b 1.1e+35)))
     (+ (+ x (* (- (+ y t) 2.0) b)) t_1)
     (+ x (+ t_1 (- z (* y z)))))))

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 ((b <= -8.5e-145) || !(b <= 1.1e+35)) {
		tmp = (x + (((y + t) - 2.0) * b)) + t_1;
	} else {
		tmp = x + (t_1 + (z - (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) :: t_1
    real(8) :: tmp
    t_1 = a * (1.0d0 - t)
    if ((b <= (-8.5d-145)) .or. (.not. (b <= 1.1d+35))) then
        tmp = (x + (((y + t) - 2.0d0) * b)) + t_1
    else
        tmp = x + (t_1 + (z - (y * z)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = a * (1.0 - t);
	double tmp;
	if ((b <= -8.5e-145) || !(b <= 1.1e+35)) {
		tmp = (x + (((y + t) - 2.0) * b)) + t_1;
	} else {
		tmp = x + (t_1 + (z - (y * z)));
	}
	return tmp;
}

Python

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

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(a * Float64(1.0 - t))
	tmp = 0.0
	if ((b <= -8.5e-145) || !(b <= 1.1e+35))
		tmp = Float64(Float64(x + Float64(Float64(Float64(y + t) - 2.0) * b)) + t_1);
	else
		tmp = Float64(x + Float64(t_1 + Float64(z - Float64(y * z))));
	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 ((b <= -8.5e-145) || ~((b <= 1.1e+35)))
		tmp = (x + (((y + t) - 2.0) * b)) + t_1;
	else
		tmp = x + (t_1 + (z - (y * z)));
	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[b, -8.5e-145], N[Not[LessEqual[b, 1.1e+35]], $MachinePrecision]], N[(N[(x + N[(N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], N[(x + N[(t$95$1 + N[(z - N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 5: 50.7% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y \cdot \left(b - z\right)\\ t_2 := t \cdot \left(b - a\right)\\ \mathbf{if}\;t \leq -2.9 \cdot 10^{-5}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;t \leq -2.7 \cdot 10^{-308}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;t \leq 1.42 \cdot 10^{-188}:\\ \;\;\;\;x + z\\ \mathbf{elif}\;t \leq 1.6 \cdot 10^{-148}:\\ \;\;\;\;b \cdot \left(y - 2\right)\\ \mathbf{elif}\;t \leq 4 \cdot 10^{-136}:\\ \;\;\;\;x + z\\ \mathbf{elif}\;t \leq 1.78 \cdot 10^{+59}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* y (- b z))) (t_2 (* t (- b a))))
   (if (<= t -2.9e-5)
     t_2
     (if (<= t -2.7e-308)
       t_1
       (if (<= t 1.42e-188)
         (+ x z)
         (if (<= t 1.6e-148)
           (* b (- y 2.0))
           (if (<= t 4e-136) (+ x z) (if (<= t 1.78e+59) t_1 t_2))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = y * (b - z);
	double t_2 = t * (b - a);
	double tmp;
	if (t <= -2.9e-5) {
		tmp = t_2;
	} else if (t <= -2.7e-308) {
		tmp = t_1;
	} else if (t <= 1.42e-188) {
		tmp = x + z;
	} else if (t <= 1.6e-148) {
		tmp = b * (y - 2.0);
	} else if (t <= 4e-136) {
		tmp = x + z;
	} else if (t <= 1.78e+59) {
		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 = y * (b - z)
    t_2 = t * (b - a)
    if (t <= (-2.9d-5)) then
        tmp = t_2
    else if (t <= (-2.7d-308)) then
        tmp = t_1
    else if (t <= 1.42d-188) then
        tmp = x + z
    else if (t <= 1.6d-148) then
        tmp = b * (y - 2.0d0)
    else if (t <= 4d-136) then
        tmp = x + z
    else if (t <= 1.78d+59) 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 = y * (b - z);
	double t_2 = t * (b - a);
	double tmp;
	if (t <= -2.9e-5) {
		tmp = t_2;
	} else if (t <= -2.7e-308) {
		tmp = t_1;
	} else if (t <= 1.42e-188) {
		tmp = x + z;
	} else if (t <= 1.6e-148) {
		tmp = b * (y - 2.0);
	} else if (t <= 4e-136) {
		tmp = x + z;
	} else if (t <= 1.78e+59) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = y * (b - z)
	t_2 = t * (b - a)
	tmp = 0
	if t <= -2.9e-5:
		tmp = t_2
	elif t <= -2.7e-308:
		tmp = t_1
	elif t <= 1.42e-188:
		tmp = x + z
	elif t <= 1.6e-148:
		tmp = b * (y - 2.0)
	elif t <= 4e-136:
		tmp = x + z
	elif t <= 1.78e+59:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(y * Float64(b - z))
	t_2 = Float64(t * Float64(b - a))
	tmp = 0.0
	if (t <= -2.9e-5)
		tmp = t_2;
	elseif (t <= -2.7e-308)
		tmp = t_1;
	elseif (t <= 1.42e-188)
		tmp = Float64(x + z);
	elseif (t <= 1.6e-148)
		tmp = Float64(b * Float64(y - 2.0));
	elseif (t <= 4e-136)
		tmp = Float64(x + z);
	elseif (t <= 1.78e+59)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = y * (b - z);
	t_2 = t * (b - a);
	tmp = 0.0;
	if (t <= -2.9e-5)
		tmp = t_2;
	elseif (t <= -2.7e-308)
		tmp = t_1;
	elseif (t <= 1.42e-188)
		tmp = x + z;
	elseif (t <= 1.6e-148)
		tmp = b * (y - 2.0);
	elseif (t <= 4e-136)
		tmp = x + z;
	elseif (t <= 1.78e+59)
		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[(y * N[(b - z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.9e-5], t$95$2, If[LessEqual[t, -2.7e-308], t$95$1, If[LessEqual[t, 1.42e-188], N[(x + z), $MachinePrecision], If[LessEqual[t, 1.6e-148], N[(b * N[(y - 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 4e-136], N[(x + z), $MachinePrecision], If[LessEqual[t, 1.78e+59], t$95$1, t$95$2]]]]]]]]

Derivation

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

Alternative 6: 84.1% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b \leq -5 \cdot 10^{+95} \lor \neg \left(b \leq 4.5 \cdot 10^{+90}\right):\\ \;\;\;\;x + \left(\left(y + t\right) - 2\right) \cdot b\\ \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 -5e+95) (not (<= b 4.5e+90)))
   (+ x (* (- (+ y t) 2.0) b))
   (+ 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 <= -5e+95) || !(b <= 4.5e+90)) {
		tmp = x + (((y + t) - 2.0) * b);
	} 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 <= (-5d+95)) .or. (.not. (b <= 4.5d+90))) then
        tmp = x + (((y + t) - 2.0d0) * b)
    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 <= -5e+95) || !(b <= 4.5e+90)) {
		tmp = x + (((y + t) - 2.0) * b);
	} 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 <= -5e+95) or not (b <= 4.5e+90):
		tmp = x + (((y + t) - 2.0) * b)
	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 <= -5e+95) || !(b <= 4.5e+90))
		tmp = Float64(x + Float64(Float64(Float64(y + t) - 2.0) * b));
	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 <= -5e+95) || ~((b <= 4.5e+90)))
		tmp = x + (((y + t) - 2.0) * b);
	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, -5e+95], N[Not[LessEqual[b, 4.5e+90]], $MachinePrecision]], N[(x + N[(N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision] * b), $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 7: 84.1% accurate, 1.2× speedup

Math

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

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= b -2.9e+95) (not (<= b 1.5e+91)))
   (+ x (* (- (+ y t) 2.0) b))
   (+ x (+ (* a (- 1.0 t)) (- z (* y z))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((b <= -2.9e+95) || !(b <= 1.5e+91)) {
		tmp = x + (((y + t) - 2.0) * b);
	} else {
		tmp = x + ((a * (1.0 - t)) + (z - (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 ((b <= (-2.9d+95)) .or. (.not. (b <= 1.5d+91))) then
        tmp = x + (((y + t) - 2.0d0) * b)
    else
        tmp = x + ((a * (1.0d0 - t)) + (z - (y * z)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((b <= -2.9e+95) || !(b <= 1.5e+91)) {
		tmp = x + (((y + t) - 2.0) * b);
	} else {
		tmp = x + ((a * (1.0 - t)) + (z - (y * z)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (b <= -2.9e+95) or not (b <= 1.5e+91):
		tmp = x + (((y + t) - 2.0) * b)
	else:
		tmp = x + ((a * (1.0 - t)) + (z - (y * z)))
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((b <= -2.9e+95) || !(b <= 1.5e+91))
		tmp = Float64(x + Float64(Float64(Float64(y + t) - 2.0) * b));
	else
		tmp = Float64(x + Float64(Float64(a * Float64(1.0 - t)) + Float64(z - Float64(y * z))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((b <= -2.9e+95) || ~((b <= 1.5e+91)))
		tmp = x + (((y + t) - 2.0) * b);
	else
		tmp = x + ((a * (1.0 - t)) + (z - (y * z)));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

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

Alternative 8: 49.7% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := t \cdot \left(b - a\right)\\ \mathbf{if}\;t \leq -2.9 \cdot 10^{-5}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;t \leq -2.8 \cdot 10^{-308}:\\ \;\;\;\;y \cdot \left(b - z\right)\\ \mathbf{elif}\;t \leq 4.7 \cdot 10^{-188}:\\ \;\;\;\;x + z\\ \mathbf{elif}\;t \leq 8.5 \cdot 10^{-48}:\\ \;\;\;\;b \cdot \left(y - 2\right)\\ \mathbf{elif}\;t \leq 3.3 \cdot 10^{+65}:\\ \;\;\;\;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 -2.9e-5)
     t_1
     (if (<= t -2.8e-308)
       (* y (- b z))
       (if (<= t 4.7e-188)
         (+ x z)
         (if (<= t 8.5e-48)
           (* b (- y 2.0))
           (if (<= t 3.3e+65) (* 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 <= -2.9e-5) {
		tmp = t_1;
	} else if (t <= -2.8e-308) {
		tmp = y * (b - z);
	} else if (t <= 4.7e-188) {
		tmp = x + z;
	} else if (t <= 8.5e-48) {
		tmp = b * (y - 2.0);
	} else if (t <= 3.3e+65) {
		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 <= (-2.9d-5)) then
        tmp = t_1
    else if (t <= (-2.8d-308)) then
        tmp = y * (b - z)
    else if (t <= 4.7d-188) then
        tmp = x + z
    else if (t <= 8.5d-48) then
        tmp = b * (y - 2.0d0)
    else if (t <= 3.3d+65) 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 <= -2.9e-5) {
		tmp = t_1;
	} else if (t <= -2.8e-308) {
		tmp = y * (b - z);
	} else if (t <= 4.7e-188) {
		tmp = x + z;
	} else if (t <= 8.5e-48) {
		tmp = b * (y - 2.0);
	} else if (t <= 3.3e+65) {
		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 <= -2.9e-5:
		tmp = t_1
	elif t <= -2.8e-308:
		tmp = y * (b - z)
	elif t <= 4.7e-188:
		tmp = x + z
	elif t <= 8.5e-48:
		tmp = b * (y - 2.0)
	elif t <= 3.3e+65:
		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 <= -2.9e-5)
		tmp = t_1;
	elseif (t <= -2.8e-308)
		tmp = Float64(y * Float64(b - z));
	elseif (t <= 4.7e-188)
		tmp = Float64(x + z);
	elseif (t <= 8.5e-48)
		tmp = Float64(b * Float64(y - 2.0));
	elseif (t <= 3.3e+65)
		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 <= -2.9e-5)
		tmp = t_1;
	elseif (t <= -2.8e-308)
		tmp = y * (b - z);
	elseif (t <= 4.7e-188)
		tmp = x + z;
	elseif (t <= 8.5e-48)
		tmp = b * (y - 2.0);
	elseif (t <= 3.3e+65)
		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, -2.9e-5], t$95$1, If[LessEqual[t, -2.8e-308], N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 4.7e-188], N[(x + z), $MachinePrecision], If[LessEqual[t, 8.5e-48], N[(b * N[(y - 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.3e+65], N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]

Derivation

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

Alternative 9: 49.8% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := t \cdot \left(b - a\right)\\ \mathbf{if}\;t \leq -2.9 \cdot 10^{-5}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;t \leq -2.6 \cdot 10^{-308}:\\ \;\;\;\;y \cdot \left(b - z\right)\\ \mathbf{elif}\;t \leq 3.7 \cdot 10^{-188}:\\ \;\;\;\;x + z\\ \mathbf{elif}\;t \leq 3.8 \cdot 10^{-49}:\\ \;\;\;\;b \cdot \left(y - 2\right)\\ \mathbf{elif}\;t \leq 3.5 \cdot 10^{+65}:\\ \;\;\;\;z - y \cdot z\\ \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 -2.9e-5)
     t_1
     (if (<= t -2.6e-308)
       (* y (- b z))
       (if (<= t 3.7e-188)
         (+ x z)
         (if (<= t 3.8e-49)
           (* b (- y 2.0))
           (if (<= t 3.5e+65) (- z (* y z)) 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 <= -2.9e-5) {
		tmp = t_1;
	} else if (t <= -2.6e-308) {
		tmp = y * (b - z);
	} else if (t <= 3.7e-188) {
		tmp = x + z;
	} else if (t <= 3.8e-49) {
		tmp = b * (y - 2.0);
	} else if (t <= 3.5e+65) {
		tmp = z - (y * 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 = t * (b - a)
    if (t <= (-2.9d-5)) then
        tmp = t_1
    else if (t <= (-2.6d-308)) then
        tmp = y * (b - z)
    else if (t <= 3.7d-188) then
        tmp = x + z
    else if (t <= 3.8d-49) then
        tmp = b * (y - 2.0d0)
    else if (t <= 3.5d+65) then
        tmp = z - (y * 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 = t * (b - a);
	double tmp;
	if (t <= -2.9e-5) {
		tmp = t_1;
	} else if (t <= -2.6e-308) {
		tmp = y * (b - z);
	} else if (t <= 3.7e-188) {
		tmp = x + z;
	} else if (t <= 3.8e-49) {
		tmp = b * (y - 2.0);
	} else if (t <= 3.5e+65) {
		tmp = z - (y * z);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = t * (b - a)
	tmp = 0
	if t <= -2.9e-5:
		tmp = t_1
	elif t <= -2.6e-308:
		tmp = y * (b - z)
	elif t <= 3.7e-188:
		tmp = x + z
	elif t <= 3.8e-49:
		tmp = b * (y - 2.0)
	elif t <= 3.5e+65:
		tmp = z - (y * z)
	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 <= -2.9e-5)
		tmp = t_1;
	elseif (t <= -2.6e-308)
		tmp = Float64(y * Float64(b - z));
	elseif (t <= 3.7e-188)
		tmp = Float64(x + z);
	elseif (t <= 3.8e-49)
		tmp = Float64(b * Float64(y - 2.0));
	elseif (t <= 3.5e+65)
		tmp = Float64(z - Float64(y * z));
	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 <= -2.9e-5)
		tmp = t_1;
	elseif (t <= -2.6e-308)
		tmp = y * (b - z);
	elseif (t <= 3.7e-188)
		tmp = x + z;
	elseif (t <= 3.8e-49)
		tmp = b * (y - 2.0);
	elseif (t <= 3.5e+65)
		tmp = z - (y * z);
	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, -2.9e-5], t$95$1, If[LessEqual[t, -2.6e-308], N[(y * N[(b - z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.7e-188], N[(x + z), $MachinePrecision], If[LessEqual[t, 3.8e-49], N[(b * N[(y - 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.5e+65], N[(z - N[(y * z), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]

Derivation

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

Alternative 10: 57.7% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + z \cdot \left(1 - y\right)\\ t_2 := t \cdot \left(b - a\right)\\ \mathbf{if}\;t \leq -9 \cdot 10^{+14}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;t \leq 1.35 \cdot 10^{-135}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;t \leq 8.6 \cdot 10^{-51}:\\ \;\;\;\;b \cdot \left(y - 2\right)\\ \mathbf{elif}\;t \leq 5.2 \cdot 10^{+65}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ x (* z (- 1.0 y)))) (t_2 (* t (- b a))))
   (if (<= t -9e+14)
     t_2
     (if (<= t 1.35e-135)
       t_1
       (if (<= t 8.6e-51) (* b (- y 2.0)) (if (<= t 5.2e+65) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x + (z * (1.0 - y));
	double t_2 = t * (b - a);
	double tmp;
	if (t <= -9e+14) {
		tmp = t_2;
	} else if (t <= 1.35e-135) {
		tmp = t_1;
	} else if (t <= 8.6e-51) {
		tmp = b * (y - 2.0);
	} else if (t <= 5.2e+65) {
		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 + (z * (1.0d0 - y))
    t_2 = t * (b - a)
    if (t <= (-9d+14)) then
        tmp = t_2
    else if (t <= 1.35d-135) then
        tmp = t_1
    else if (t <= 8.6d-51) then
        tmp = b * (y - 2.0d0)
    else if (t <= 5.2d+65) 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 + (z * (1.0 - y));
	double t_2 = t * (b - a);
	double tmp;
	if (t <= -9e+14) {
		tmp = t_2;
	} else if (t <= 1.35e-135) {
		tmp = t_1;
	} else if (t <= 8.6e-51) {
		tmp = b * (y - 2.0);
	} else if (t <= 5.2e+65) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x + (z * (1.0 - y))
	t_2 = t * (b - a)
	tmp = 0
	if t <= -9e+14:
		tmp = t_2
	elif t <= 1.35e-135:
		tmp = t_1
	elif t <= 8.6e-51:
		tmp = b * (y - 2.0)
	elif t <= 5.2e+65:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x + Float64(z * Float64(1.0 - y)))
	t_2 = Float64(t * Float64(b - a))
	tmp = 0.0
	if (t <= -9e+14)
		tmp = t_2;
	elseif (t <= 1.35e-135)
		tmp = t_1;
	elseif (t <= 8.6e-51)
		tmp = Float64(b * Float64(y - 2.0));
	elseif (t <= 5.2e+65)
		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 + (z * (1.0 - y));
	t_2 = t * (b - a);
	tmp = 0.0;
	if (t <= -9e+14)
		tmp = t_2;
	elseif (t <= 1.35e-135)
		tmp = t_1;
	elseif (t <= 8.6e-51)
		tmp = b * (y - 2.0);
	elseif (t <= 5.2e+65)
		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[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -9e+14], t$95$2, If[LessEqual[t, 1.35e-135], t$95$1, If[LessEqual[t, 8.6e-51], N[(b * N[(y - 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.2e+65], t$95$1, t$95$2]]]]]]

Derivation

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

Alternative 11: 66.5% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := t \cdot \left(b - a\right)\\ \mathbf{if}\;t \leq -3050000000000:\\ \;\;\;\;t_1\\ \mathbf{elif}\;t \leq 6.2 \cdot 10^{-50}:\\ \;\;\;\;x + \left(a + b \cdot \left(y + -2\right)\right)\\ \mathbf{elif}\;t \leq 6.8 \cdot 10^{+65}:\\ \;\;\;\;x + \left(a + z \cdot \left(1 - y\right)\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 -3050000000000.0)
     t_1
     (if (<= t 6.2e-50)
       (+ x (+ a (* b (+ y -2.0))))
       (if (<= t 6.8e+65) (+ x (+ a (* 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 <= -3050000000000.0) {
		tmp = t_1;
	} else if (t <= 6.2e-50) {
		tmp = x + (a + (b * (y + -2.0)));
	} else if (t <= 6.8e+65) {
		tmp = x + (a + (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 <= (-3050000000000.0d0)) then
        tmp = t_1
    else if (t <= 6.2d-50) then
        tmp = x + (a + (b * (y + (-2.0d0))))
    else if (t <= 6.8d+65) then
        tmp = x + (a + (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 <= -3050000000000.0) {
		tmp = t_1;
	} else if (t <= 6.2e-50) {
		tmp = x + (a + (b * (y + -2.0)));
	} else if (t <= 6.8e+65) {
		tmp = x + (a + (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 <= -3050000000000.0:
		tmp = t_1
	elif t <= 6.2e-50:
		tmp = x + (a + (b * (y + -2.0)))
	elif t <= 6.8e+65:
		tmp = x + (a + (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 <= -3050000000000.0)
		tmp = t_1;
	elseif (t <= 6.2e-50)
		tmp = Float64(x + Float64(a + Float64(b * Float64(y + -2.0))));
	elseif (t <= 6.8e+65)
		tmp = Float64(x + Float64(a + 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 <= -3050000000000.0)
		tmp = t_1;
	elseif (t <= 6.2e-50)
		tmp = x + (a + (b * (y + -2.0)));
	elseif (t <= 6.8e+65)
		tmp = x + (a + (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, -3050000000000.0], t$95$1, If[LessEqual[t, 6.2e-50], N[(x + N[(a + N[(b * N[(y + -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 6.8e+65], N[(x + N[(a + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

Derivation

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

Alternative 12: 67.1% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -2.95:\\ \;\;\;\;\left(\left(y + t\right) - 2\right) \cdot b - t \cdot a\\ \mathbf{elif}\;t \leq 2.65 \cdot 10^{-52}:\\ \;\;\;\;x + \left(a + b \cdot \left(y + -2\right)\right)\\ \mathbf{elif}\;t \leq 2.9 \cdot 10^{+65}:\\ \;\;\;\;x + \left(a + z \cdot \left(1 - y\right)\right)\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(b - a\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= t -2.95)
   (- (* (- (+ y t) 2.0) b) (* t a))
   (if (<= t 2.65e-52)
     (+ x (+ a (* b (+ y -2.0))))
     (if (<= t 2.9e+65) (+ x (+ a (* z (- 1.0 y)))) (* t (- b a))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (t <= -2.95) {
		tmp = (((y + t) - 2.0) * b) - (t * a);
	} else if (t <= 2.65e-52) {
		tmp = x + (a + (b * (y + -2.0)));
	} else if (t <= 2.9e+65) {
		tmp = x + (a + (z * (1.0 - y)));
	} else {
		tmp = t * (b - 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 (t <= (-2.95d0)) then
        tmp = (((y + t) - 2.0d0) * b) - (t * a)
    else if (t <= 2.65d-52) then
        tmp = x + (a + (b * (y + (-2.0d0))))
    else if (t <= 2.9d+65) then
        tmp = x + (a + (z * (1.0d0 - y)))
    else
        tmp = t * (b - 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 (t <= -2.95) {
		tmp = (((y + t) - 2.0) * b) - (t * a);
	} else if (t <= 2.65e-52) {
		tmp = x + (a + (b * (y + -2.0)));
	} else if (t <= 2.9e+65) {
		tmp = x + (a + (z * (1.0 - y)));
	} else {
		tmp = t * (b - a);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if t <= -2.95:
		tmp = (((y + t) - 2.0) * b) - (t * a)
	elif t <= 2.65e-52:
		tmp = x + (a + (b * (y + -2.0)))
	elif t <= 2.9e+65:
		tmp = x + (a + (z * (1.0 - y)))
	else:
		tmp = t * (b - a)
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (t <= -2.95)
		tmp = Float64(Float64(Float64(Float64(y + t) - 2.0) * b) - Float64(t * a));
	elseif (t <= 2.65e-52)
		tmp = Float64(x + Float64(a + Float64(b * Float64(y + -2.0))));
	elseif (t <= 2.9e+65)
		tmp = Float64(x + Float64(a + Float64(z * Float64(1.0 - y))));
	else
		tmp = Float64(t * Float64(b - a));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (t <= -2.95)
		tmp = (((y + t) - 2.0) * b) - (t * a);
	elseif (t <= 2.65e-52)
		tmp = x + (a + (b * (y + -2.0)));
	elseif (t <= 2.9e+65)
		tmp = x + (a + (z * (1.0 - y)));
	else
		tmp = t * (b - a);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -2.95], N[(N[(N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision] * b), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.65e-52], N[(x + N[(a + N[(b * N[(y + -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.9e+65], N[(x + N[(a + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]]]]

Derivation

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

Alternative 13: 58.1% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := t \cdot \left(b - a\right)\\ \mathbf{if}\;t \leq -1.45 \cdot 10^{+15}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;t \leq 5.1 \cdot 10^{-54}:\\ \;\;\;\;x + \left(\left(y + t\right) - 2\right) \cdot b\\ \mathbf{elif}\;t \leq 6.2 \cdot 10^{+65}:\\ \;\;\;\;x + 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 -1.45e+15)
     t_1
     (if (<= t 5.1e-54)
       (+ x (* (- (+ y t) 2.0) b))
       (if (<= t 6.2e+65) (+ x (* 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 <= -1.45e+15) {
		tmp = t_1;
	} else if (t <= 5.1e-54) {
		tmp = x + (((y + t) - 2.0) * b);
	} else if (t <= 6.2e+65) {
		tmp = x + (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 <= (-1.45d+15)) then
        tmp = t_1
    else if (t <= 5.1d-54) then
        tmp = x + (((y + t) - 2.0d0) * b)
    else if (t <= 6.2d+65) then
        tmp = x + (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 <= -1.45e+15) {
		tmp = t_1;
	} else if (t <= 5.1e-54) {
		tmp = x + (((y + t) - 2.0) * b);
	} else if (t <= 6.2e+65) {
		tmp = x + (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 <= -1.45e+15:
		tmp = t_1
	elif t <= 5.1e-54:
		tmp = x + (((y + t) - 2.0) * b)
	elif t <= 6.2e+65:
		tmp = x + (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 <= -1.45e+15)
		tmp = t_1;
	elseif (t <= 5.1e-54)
		tmp = Float64(x + Float64(Float64(Float64(y + t) - 2.0) * b));
	elseif (t <= 6.2e+65)
		tmp = Float64(x + 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 <= -1.45e+15)
		tmp = t_1;
	elseif (t <= 5.1e-54)
		tmp = x + (((y + t) - 2.0) * b);
	elseif (t <= 6.2e+65)
		tmp = x + (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, -1.45e+15], t$95$1, If[LessEqual[t, 5.1e-54], N[(x + N[(N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 6.2e+65], N[(x + N[(z * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

Derivation

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

Alternative 14: 58.1% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := t \cdot \left(b - a\right)\\ \mathbf{if}\;t \leq -2 \cdot 10^{+15}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;t \leq 2.65 \cdot 10^{-51}:\\ \;\;\;\;x + \left(\left(y + t\right) - 2\right) \cdot b\\ \mathbf{elif}\;t \leq 3.2 \cdot 10^{+65}:\\ \;\;\;\;x + \left(z - y \cdot z\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 -2e+15)
     t_1
     (if (<= t 2.65e-51)
       (+ x (* (- (+ y t) 2.0) b))
       (if (<= t 3.2e+65) (+ x (- z (* y z))) 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 <= -2e+15) {
		tmp = t_1;
	} else if (t <= 2.65e-51) {
		tmp = x + (((y + t) - 2.0) * b);
	} else if (t <= 3.2e+65) {
		tmp = x + (z - (y * 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 = t * (b - a)
    if (t <= (-2d+15)) then
        tmp = t_1
    else if (t <= 2.65d-51) then
        tmp = x + (((y + t) - 2.0d0) * b)
    else if (t <= 3.2d+65) then
        tmp = x + (z - (y * 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 = t * (b - a);
	double tmp;
	if (t <= -2e+15) {
		tmp = t_1;
	} else if (t <= 2.65e-51) {
		tmp = x + (((y + t) - 2.0) * b);
	} else if (t <= 3.2e+65) {
		tmp = x + (z - (y * z));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = t * (b - a)
	tmp = 0
	if t <= -2e+15:
		tmp = t_1
	elif t <= 2.65e-51:
		tmp = x + (((y + t) - 2.0) * b)
	elif t <= 3.2e+65:
		tmp = x + (z - (y * z))
	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 <= -2e+15)
		tmp = t_1;
	elseif (t <= 2.65e-51)
		tmp = Float64(x + Float64(Float64(Float64(y + t) - 2.0) * b));
	elseif (t <= 3.2e+65)
		tmp = Float64(x + Float64(z - Float64(y * z)));
	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 <= -2e+15)
		tmp = t_1;
	elseif (t <= 2.65e-51)
		tmp = x + (((y + t) - 2.0) * b);
	elseif (t <= 3.2e+65)
		tmp = x + (z - (y * z));
	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, -2e+15], t$95$1, If[LessEqual[t, 2.65e-51], N[(x + N[(N[(N[(y + t), $MachinePrecision] - 2.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.2e+65], N[(x + N[(z - N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

Derivation

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

Alternative 15: 67.4% accurate, 1.6× speedup

Math

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

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= t -500000000000.0) (not (<= t 6.8e+65)))
   (* t (- b a))
   (+ x (+ a (* z (- 1.0 y))))))

C

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 16: 27.7% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -7.4 \cdot 10^{+109}:\\ \;\;\;\;z \cdot \left(-y\right)\\ \mathbf{elif}\;y \leq -1 \cdot 10^{-137}:\\ \;\;\;\;t \cdot b\\ \mathbf{elif}\;y \leq 2 \cdot 10^{-225}:\\ \;\;\;\;z\\ \mathbf{elif}\;y \leq 48000000000:\\ \;\;\;\;t \cdot b\\ \mathbf{else}:\\ \;\;\;\;y \cdot b\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= y -7.4e+109)
   (* z (- y))
   (if (<= y -1e-137)
     (* t b)
     (if (<= y 2e-225) z (if (<= y 48000000000.0) (* t b) (* y b))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (y <= -7.4e+109) {
		tmp = z * -y;
	} else if (y <= -1e-137) {
		tmp = t * b;
	} else if (y <= 2e-225) {
		tmp = z;
	} else if (y <= 48000000000.0) {
		tmp = t * b;
	} 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 <= (-7.4d+109)) then
        tmp = z * -y
    else if (y <= (-1d-137)) then
        tmp = t * b
    else if (y <= 2d-225) then
        tmp = z
    else if (y <= 48000000000.0d0) then
        tmp = t * b
    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 <= -7.4e+109) {
		tmp = z * -y;
	} else if (y <= -1e-137) {
		tmp = t * b;
	} else if (y <= 2e-225) {
		tmp = z;
	} else if (y <= 48000000000.0) {
		tmp = t * b;
	} else {
		tmp = y * b;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if y <= -7.4e+109:
		tmp = z * -y
	elif y <= -1e-137:
		tmp = t * b
	elif y <= 2e-225:
		tmp = z
	elif y <= 48000000000.0:
		tmp = t * b
	else:
		tmp = y * b
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (y <= -7.4e+109)
		tmp = Float64(z * Float64(-y));
	elseif (y <= -1e-137)
		tmp = Float64(t * b);
	elseif (y <= 2e-225)
		tmp = z;
	elseif (y <= 48000000000.0)
		tmp = Float64(t * b);
	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 <= -7.4e+109)
		tmp = z * -y;
	elseif (y <= -1e-137)
		tmp = t * b;
	elseif (y <= 2e-225)
		tmp = z;
	elseif (y <= 48000000000.0)
		tmp = t * b;
	else
		tmp = y * b;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[y, -7.4e+109], N[(z * (-y)), $MachinePrecision], If[LessEqual[y, -1e-137], N[(t * b), $MachinePrecision], If[LessEqual[y, 2e-225], z, If[LessEqual[y, 48000000000.0], N[(t * b), $MachinePrecision], N[(y * b), $MachinePrecision]]]]]

Derivation

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

Alternative 17: 34.6% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -1.2 \cdot 10^{+43}:\\ \;\;\;\;z \cdot \left(-y\right)\\ \mathbf{elif}\;y \leq 3.3 \cdot 10^{-160}:\\ \;\;\;\;x + z\\ \mathbf{elif}\;y \leq 7.6 \cdot 10^{-52}:\\ \;\;\;\;t \cdot \left(-a\right)\\ \mathbf{elif}\;y \leq 21000000000000:\\ \;\;\;\;x + z\\ \mathbf{else}:\\ \;\;\;\;y \cdot b\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= y -1.2e+43)
   (* z (- y))
   (if (<= y 3.3e-160)
     (+ x z)
     (if (<= y 7.6e-52)
       (* t (- a))
       (if (<= y 21000000000000.0) (+ x z) (* y b))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (y <= -1.2e+43) {
		tmp = z * -y;
	} else if (y <= 3.3e-160) {
		tmp = x + z;
	} else if (y <= 7.6e-52) {
		tmp = t * -a;
	} else if (y <= 21000000000000.0) {
		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.2d+43)) then
        tmp = z * -y
    else if (y <= 3.3d-160) then
        tmp = x + z
    else if (y <= 7.6d-52) then
        tmp = t * -a
    else if (y <= 21000000000000.0d0) 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.2e+43) {
		tmp = z * -y;
	} else if (y <= 3.3e-160) {
		tmp = x + z;
	} else if (y <= 7.6e-52) {
		tmp = t * -a;
	} else if (y <= 21000000000000.0) {
		tmp = x + z;
	} else {
		tmp = y * b;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if y <= -1.2e+43:
		tmp = z * -y
	elif y <= 3.3e-160:
		tmp = x + z
	elif y <= 7.6e-52:
		tmp = t * -a
	elif y <= 21000000000000.0:
		tmp = x + z
	else:
		tmp = y * b
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (y <= -1.2e+43)
		tmp = Float64(z * Float64(-y));
	elseif (y <= 3.3e-160)
		tmp = Float64(x + z);
	elseif (y <= 7.6e-52)
		tmp = Float64(t * Float64(-a));
	elseif (y <= 21000000000000.0)
		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.2e+43)
		tmp = z * -y;
	elseif (y <= 3.3e-160)
		tmp = x + z;
	elseif (y <= 7.6e-52)
		tmp = t * -a;
	elseif (y <= 21000000000000.0)
		tmp = x + z;
	else
		tmp = y * b;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[y, -1.2e+43], N[(z * (-y)), $MachinePrecision], If[LessEqual[y, 3.3e-160], N[(x + z), $MachinePrecision], If[LessEqual[y, 7.6e-52], N[(t * (-a)), $MachinePrecision], If[LessEqual[y, 21000000000000.0], N[(x + z), $MachinePrecision], N[(y * b), $MachinePrecision]]]]]

Derivation

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

Alternative 18: 48.4% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := t \cdot \left(b - a\right)\\ \mathbf{if}\;t \leq -1.7 \cdot 10^{-10}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;t \leq 6.1 \cdot 10^{-33}:\\ \;\;\;\;b \cdot \left(y - 2\right)\\ \mathbf{elif}\;t \leq 25000000000:\\ \;\;\;\;x + z\\ \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 -1.7e-10)
     t_1
     (if (<= t 6.1e-33)
       (* b (- y 2.0))
       (if (<= t 25000000000.0) (+ x z) 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 <= -1.7e-10) {
		tmp = t_1;
	} else if (t <= 6.1e-33) {
		tmp = b * (y - 2.0);
	} else if (t <= 25000000000.0) {
		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 = t * (b - a)
    if (t <= (-1.7d-10)) then
        tmp = t_1
    else if (t <= 6.1d-33) then
        tmp = b * (y - 2.0d0)
    else if (t <= 25000000000.0d0) 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 = t * (b - a);
	double tmp;
	if (t <= -1.7e-10) {
		tmp = t_1;
	} else if (t <= 6.1e-33) {
		tmp = b * (y - 2.0);
	} else if (t <= 25000000000.0) {
		tmp = x + z;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = t * (b - a)
	tmp = 0
	if t <= -1.7e-10:
		tmp = t_1
	elif t <= 6.1e-33:
		tmp = b * (y - 2.0)
	elif t <= 25000000000.0:
		tmp = x + z
	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 <= -1.7e-10)
		tmp = t_1;
	elseif (t <= 6.1e-33)
		tmp = Float64(b * Float64(y - 2.0));
	elseif (t <= 25000000000.0)
		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 = t * (b - a);
	tmp = 0.0;
	if (t <= -1.7e-10)
		tmp = t_1;
	elseif (t <= 6.1e-33)
		tmp = b * (y - 2.0);
	elseif (t <= 25000000000.0)
		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[(t * N[(b - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.7e-10], t$95$1, If[LessEqual[t, 6.1e-33], N[(b * N[(y - 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 25000000000.0], N[(x + z), $MachinePrecision], t$95$1]]]]

Derivation

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

Alternative 19: 27.0% accurate, 2.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -8 \cdot 10^{+15}:\\ \;\;\;\;t \cdot b\\ \mathbf{elif}\;t \leq -4.3 \cdot 10^{-211}:\\ \;\;\;\;a\\ \mathbf{elif}\;t \leq 4.6 \cdot 10^{+38}:\\ \;\;\;\;y \cdot b\\ \mathbf{else}:\\ \;\;\;\;t \cdot b\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= t -8e+15)
   (* t b)
   (if (<= t -4.3e-211) a (if (<= t 4.6e+38) (* y b) (* t b)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (t <= -8e+15) {
		tmp = t * b;
	} else if (t <= -4.3e-211) {
		tmp = a;
	} else if (t <= 4.6e+38) {
		tmp = y * b;
	} else {
		tmp = t * 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 (t <= (-8d+15)) then
        tmp = t * b
    else if (t <= (-4.3d-211)) then
        tmp = a
    else if (t <= 4.6d+38) then
        tmp = y * b
    else
        tmp = t * 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 (t <= -8e+15) {
		tmp = t * b;
	} else if (t <= -4.3e-211) {
		tmp = a;
	} else if (t <= 4.6e+38) {
		tmp = y * b;
	} else {
		tmp = t * b;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if t <= -8e+15:
		tmp = t * b
	elif t <= -4.3e-211:
		tmp = a
	elif t <= 4.6e+38:
		tmp = y * b
	else:
		tmp = t * b
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (t <= -8e+15)
		tmp = Float64(t * b);
	elseif (t <= -4.3e-211)
		tmp = a;
	elseif (t <= 4.6e+38)
		tmp = Float64(y * b);
	else
		tmp = Float64(t * b);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (t <= -8e+15)
		tmp = t * b;
	elseif (t <= -4.3e-211)
		tmp = a;
	elseif (t <= 4.6e+38)
		tmp = y * b;
	else
		tmp = t * b;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -8e+15], N[(t * b), $MachinePrecision], If[LessEqual[t, -4.3e-211], a, If[LessEqual[t, 4.6e+38], N[(y * b), $MachinePrecision], N[(t * b), $MachinePrecision]]]]

Derivation

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

Alternative 20: 34.6% accurate, 2.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b \leq -2.8 \cdot 10^{+96}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;b \leq 5.6 \cdot 10^{+90}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{else}:\\ \;\;\;\;t \cdot b\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= b -2.8e+96) (* y b) (if (<= b 5.6e+90) (* a (- 1.0 t)) (* t b))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (b <= -2.8e+96) {
		tmp = y * b;
	} else if (b <= 5.6e+90) {
		tmp = a * (1.0 - t);
	} else {
		tmp = t * 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 (b <= (-2.8d+96)) then
        tmp = y * b
    else if (b <= 5.6d+90) then
        tmp = a * (1.0d0 - t)
    else
        tmp = t * 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 (b <= -2.8e+96) {
		tmp = y * b;
	} else if (b <= 5.6e+90) {
		tmp = a * (1.0 - t);
	} else {
		tmp = t * b;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if b <= -2.8e+96:
		tmp = y * b
	elif b <= 5.6e+90:
		tmp = a * (1.0 - t)
	else:
		tmp = t * b
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (b <= -2.8e+96)
		tmp = Float64(y * b);
	elseif (b <= 5.6e+90)
		tmp = Float64(a * Float64(1.0 - t));
	else
		tmp = Float64(t * b);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (b <= -2.8e+96)
		tmp = y * b;
	elseif (b <= 5.6e+90)
		tmp = a * (1.0 - t);
	else
		tmp = t * b;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -2.8e+96], N[(y * b), $MachinePrecision], If[LessEqual[b, 5.6e+90], N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision], N[(t * b), $MachinePrecision]]]

Derivation

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

Alternative 21: 36.9% accurate, 2.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b \leq -1.45 \cdot 10^{+96}:\\ \;\;\;\;b \cdot \left(y - 2\right)\\ \mathbf{elif}\;b \leq 10^{+91}:\\ \;\;\;\;a \cdot \left(1 - t\right)\\ \mathbf{else}:\\ \;\;\;\;t \cdot b\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= b -1.45e+96)
   (* b (- y 2.0))
   (if (<= b 1e+91) (* a (- 1.0 t)) (* t b))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (b <= -1.45e+96) {
		tmp = b * (y - 2.0);
	} else if (b <= 1e+91) {
		tmp = a * (1.0 - t);
	} else {
		tmp = t * 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 (b <= (-1.45d+96)) then
        tmp = b * (y - 2.0d0)
    else if (b <= 1d+91) then
        tmp = a * (1.0d0 - t)
    else
        tmp = t * 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 (b <= -1.45e+96) {
		tmp = b * (y - 2.0);
	} else if (b <= 1e+91) {
		tmp = a * (1.0 - t);
	} else {
		tmp = t * b;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if b <= -1.45e+96:
		tmp = b * (y - 2.0)
	elif b <= 1e+91:
		tmp = a * (1.0 - t)
	else:
		tmp = t * b
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (b <= -1.45e+96)
		tmp = Float64(b * Float64(y - 2.0));
	elseif (b <= 1e+91)
		tmp = Float64(a * Float64(1.0 - t));
	else
		tmp = Float64(t * b);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (b <= -1.45e+96)
		tmp = b * (y - 2.0);
	elseif (b <= 1e+91)
		tmp = a * (1.0 - t);
	else
		tmp = t * b;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.45e+96], N[(b * N[(y - 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1e+91], N[(a * N[(1.0 - t), $MachinePrecision]), $MachinePrecision], N[(t * b), $MachinePrecision]]]

Derivation

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

Alternative 22: 27.4% accurate, 2.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b \leq -2.2 \cdot 10^{+96}:\\ \;\;\;\;y \cdot b\\ \mathbf{elif}\;b \leq 4.6 \cdot 10^{+90}:\\ \;\;\;\;t \cdot \left(-a\right)\\ \mathbf{else}:\\ \;\;\;\;t \cdot b\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= b -2.2e+96) (* y b) (if (<= b 4.6e+90) (* t (- a)) (* t b))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (b <= -2.2e+96) {
		tmp = y * b;
	} else if (b <= 4.6e+90) {
		tmp = t * -a;
	} else {
		tmp = t * 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 (b <= (-2.2d+96)) then
        tmp = y * b
    else if (b <= 4.6d+90) then
        tmp = t * -a
    else
        tmp = t * 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 (b <= -2.2e+96) {
		tmp = y * b;
	} else if (b <= 4.6e+90) {
		tmp = t * -a;
	} else {
		tmp = t * b;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if b <= -2.2e+96:
		tmp = y * b
	elif b <= 4.6e+90:
		tmp = t * -a
	else:
		tmp = t * b
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (b <= -2.2e+96)
		tmp = Float64(y * b);
	elseif (b <= 4.6e+90)
		tmp = Float64(t * Float64(-a));
	else
		tmp = Float64(t * b);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (b <= -2.2e+96)
		tmp = y * b;
	elseif (b <= 4.6e+90)
		tmp = t * -a;
	else
		tmp = t * b;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -2.2e+96], N[(y * b), $MachinePrecision], If[LessEqual[b, 4.6e+90], N[(t * (-a)), $MachinePrecision], N[(t * b), $MachinePrecision]]]

Derivation

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

Alternative 23: 26.3% accurate, 2.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -4.3 \cdot 10^{+15} \lor \neg \left(t \leq 7500\right):\\ \;\;\;\;t \cdot b\\ \mathbf{else}:\\ \;\;\;\;a\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= t -4.3e+15) (not (<= t 7500.0))) (* t b) a))

C

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

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (t <= -4.3e+15) or not (t <= 7500.0):
		tmp = t * b
	else:
		tmp = a
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((t <= -4.3e+15) || !(t <= 7500.0))
		tmp = Float64(t * b);
	else
		tmp = a;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((t <= -4.3e+15) || ~((t <= 7500.0)))
		tmp = t * b;
	else
		tmp = a;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[t, -4.3e+15], N[Not[LessEqual[t, 7500.0]], $MachinePrecision]], N[(t * b), $MachinePrecision], a]

Derivation

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

Alternative 24: 20.5% accurate, 4.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -2.8 \cdot 10^{+83}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 8 \cdot 10^{+122}:\\ \;\;\;\;a\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= x -2.8e+83) x (if (<= x 8e+122) a x)))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (x <= -2.8e+83) {
		tmp = x;
	} else if (x <= 8e+122) {
		tmp = a;
	} 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 (x <= (-2.8d+83)) then
        tmp = x
    else if (x <= 8d+122) then
        tmp = a
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (x <= -2.8e+83) {
		tmp = x;
	} else if (x <= 8e+122) {
		tmp = a;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if x <= -2.8e+83:
		tmp = x
	elif x <= 8e+122:
		tmp = a
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (x <= -2.8e+83)
		tmp = x;
	elseif (x <= 8e+122)
		tmp = a;
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (x <= -2.8e+83)
		tmp = x;
	elseif (x <= 8e+122)
		tmp = a;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[x, -2.8e+83], x, If[LessEqual[x, 8e+122], a, x]]

Derivation

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

Alternative 25: 10.7% accurate, 21.0× speedup

Math

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

FPCore

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

C

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

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 = a
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Reproduce

herbie shell --seed 2023343 
(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)))