Diagrams.ThreeD.Shapes:frustum from diagrams-lib-1.3.0.3, A

Percentage Accurate: 90.3% → 95.6%

Time: 13.9s

Alternatives: 13

Speedup: 0.5×

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

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 90.3% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 95.6% accurate, 0.5× speedup

Math

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

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 2: 94.6% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := a + b \cdot c\\ t_2 := \left(c \cdot t_1\right) \cdot i\\ t_3 := c \cdot \left(t_1 \cdot i\right)\\ \mathbf{if}\;t_2 \leq -\infty:\\ \;\;\;\;2 \cdot \left(x \cdot y - t_3\right)\\ \mathbf{elif}\;t_2 \leq 10^{+265}:\\ \;\;\;\;\left(\left(x \cdot y + z \cdot t\right) - t_2\right) \cdot 2\\ \mathbf{else}:\\ \;\;\;\;t_3 \cdot -2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (+ a (* b c))) (t_2 (* (* c t_1) i)) (t_3 (* c (* t_1 i))))
   (if (<= t_2 (- INFINITY))
     (* 2.0 (- (* x y) t_3))
     (if (<= t_2 1e+265) (* (- (+ (* x y) (* z t)) t_2) 2.0) (* t_3 -2.0)))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = a + (b * c);
	double t_2 = (c * t_1) * i;
	double t_3 = c * (t_1 * i);
	double tmp;
	if (t_2 <= -((double) INFINITY)) {
		tmp = 2.0 * ((x * y) - t_3);
	} else if (t_2 <= 1e+265) {
		tmp = (((x * y) + (z * t)) - t_2) * 2.0;
	} else {
		tmp = t_3 * -2.0;
	}
	return tmp;
}

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = a + (b * c);
	double t_2 = (c * t_1) * i;
	double t_3 = c * (t_1 * i);
	double tmp;
	if (t_2 <= -Double.POSITIVE_INFINITY) {
		tmp = 2.0 * ((x * y) - t_3);
	} else if (t_2 <= 1e+265) {
		tmp = (((x * y) + (z * t)) - t_2) * 2.0;
	} else {
		tmp = t_3 * -2.0;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = a + (b * c)
	t_2 = (c * t_1) * i
	t_3 = c * (t_1 * i)
	tmp = 0
	if t_2 <= -math.inf:
		tmp = 2.0 * ((x * y) - t_3)
	elif t_2 <= 1e+265:
		tmp = (((x * y) + (z * t)) - t_2) * 2.0
	else:
		tmp = t_3 * -2.0
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(a + Float64(b * c))
	t_2 = Float64(Float64(c * t_1) * i)
	t_3 = Float64(c * Float64(t_1 * i))
	tmp = 0.0
	if (t_2 <= Float64(-Inf))
		tmp = Float64(2.0 * Float64(Float64(x * y) - t_3));
	elseif (t_2 <= 1e+265)
		tmp = Float64(Float64(Float64(Float64(x * y) + Float64(z * t)) - t_2) * 2.0);
	else
		tmp = Float64(t_3 * -2.0);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = a + (b * c);
	t_2 = (c * t_1) * i;
	t_3 = c * (t_1 * i);
	tmp = 0.0;
	if (t_2 <= -Inf)
		tmp = 2.0 * ((x * y) - t_3);
	elseif (t_2 <= 1e+265)
		tmp = (((x * y) + (z * t)) - t_2) * 2.0;
	else
		tmp = t_3 * -2.0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(c * t$95$1), $MachinePrecision] * i), $MachinePrecision]}, Block[{t$95$3 = N[(c * N[(t$95$1 * i), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, (-Infinity)], N[(2.0 * N[(N[(x * y), $MachinePrecision] - t$95$3), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 1e+265], N[(N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] - t$95$2), $MachinePrecision] * 2.0), $MachinePrecision], N[(t$95$3 * -2.0), $MachinePrecision]]]]]]

Derivation

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

Alternative 3: 41.5% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := 2 \cdot \left(z \cdot t\right)\\ t_2 := i \cdot \left(a \cdot \left(c \cdot -2\right)\right)\\ t_3 := \left(x \cdot y\right) \cdot 2\\ \mathbf{if}\;x \cdot y \leq -4 \cdot 10^{+113}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;x \cdot y \leq -3.5 \cdot 10^{-161}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \cdot y \leq -3.5 \cdot 10^{-252}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;x \cdot y \leq 0:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \cdot y \leq 1.16 \cdot 10^{+72}:\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;t_3\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (* 2.0 (* z t)))
        (t_2 (* i (* a (* c -2.0))))
        (t_3 (* (* x y) 2.0)))
   (if (<= (* x y) -4e+113)
     t_3
     (if (<= (* x y) -3.5e-161)
       t_1
       (if (<= (* x y) -3.5e-252)
         t_2
         (if (<= (* x y) 0.0) t_1 (if (<= (* x y) 1.16e+72) t_2 t_3)))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = 2.0 * (z * t);
	double t_2 = i * (a * (c * -2.0));
	double t_3 = (x * y) * 2.0;
	double tmp;
	if ((x * y) <= -4e+113) {
		tmp = t_3;
	} else if ((x * y) <= -3.5e-161) {
		tmp = t_1;
	} else if ((x * y) <= -3.5e-252) {
		tmp = t_2;
	} else if ((x * y) <= 0.0) {
		tmp = t_1;
	} else if ((x * y) <= 1.16e+72) {
		tmp = t_2;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_1 = 2.0d0 * (z * t)
    t_2 = i * (a * (c * (-2.0d0)))
    t_3 = (x * y) * 2.0d0
    if ((x * y) <= (-4d+113)) then
        tmp = t_3
    else if ((x * y) <= (-3.5d-161)) then
        tmp = t_1
    else if ((x * y) <= (-3.5d-252)) then
        tmp = t_2
    else if ((x * y) <= 0.0d0) then
        tmp = t_1
    else if ((x * y) <= 1.16d+72) 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 c, double i) {
	double t_1 = 2.0 * (z * t);
	double t_2 = i * (a * (c * -2.0));
	double t_3 = (x * y) * 2.0;
	double tmp;
	if ((x * y) <= -4e+113) {
		tmp = t_3;
	} else if ((x * y) <= -3.5e-161) {
		tmp = t_1;
	} else if ((x * y) <= -3.5e-252) {
		tmp = t_2;
	} else if ((x * y) <= 0.0) {
		tmp = t_1;
	} else if ((x * y) <= 1.16e+72) {
		tmp = t_2;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = 2.0 * (z * t)
	t_2 = i * (a * (c * -2.0))
	t_3 = (x * y) * 2.0
	tmp = 0
	if (x * y) <= -4e+113:
		tmp = t_3
	elif (x * y) <= -3.5e-161:
		tmp = t_1
	elif (x * y) <= -3.5e-252:
		tmp = t_2
	elif (x * y) <= 0.0:
		tmp = t_1
	elif (x * y) <= 1.16e+72:
		tmp = t_2
	else:
		tmp = t_3
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(2.0 * Float64(z * t))
	t_2 = Float64(i * Float64(a * Float64(c * -2.0)))
	t_3 = Float64(Float64(x * y) * 2.0)
	tmp = 0.0
	if (Float64(x * y) <= -4e+113)
		tmp = t_3;
	elseif (Float64(x * y) <= -3.5e-161)
		tmp = t_1;
	elseif (Float64(x * y) <= -3.5e-252)
		tmp = t_2;
	elseif (Float64(x * y) <= 0.0)
		tmp = t_1;
	elseif (Float64(x * y) <= 1.16e+72)
		tmp = t_2;
	else
		tmp = t_3;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = 2.0 * (z * t);
	t_2 = i * (a * (c * -2.0));
	t_3 = (x * y) * 2.0;
	tmp = 0.0;
	if ((x * y) <= -4e+113)
		tmp = t_3;
	elseif ((x * y) <= -3.5e-161)
		tmp = t_1;
	elseif ((x * y) <= -3.5e-252)
		tmp = t_2;
	elseif ((x * y) <= 0.0)
		tmp = t_1;
	elseif ((x * y) <= 1.16e+72)
		tmp = t_2;
	else
		tmp = t_3;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(2.0 * N[(z * t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(i * N[(a * N[(c * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(x * y), $MachinePrecision] * 2.0), $MachinePrecision]}, If[LessEqual[N[(x * y), $MachinePrecision], -4e+113], t$95$3, If[LessEqual[N[(x * y), $MachinePrecision], -3.5e-161], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], -3.5e-252], t$95$2, If[LessEqual[N[(x * y), $MachinePrecision], 0.0], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], 1.16e+72], t$95$2, t$95$3]]]]]]]]

Derivation

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

Alternative 4: 42.0% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := 2 \cdot \left(z \cdot t\right)\\ t_2 := -2 \cdot \left(a \cdot \left(c \cdot i\right)\right)\\ t_3 := \left(x \cdot y\right) \cdot 2\\ \mathbf{if}\;x \cdot y \leq -6.5 \cdot 10^{+113}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;x \cdot y \leq -9 \cdot 10^{-152}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \cdot y \leq -8 \cdot 10^{-252}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;x \cdot y \leq 0:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \cdot y \leq 1.2 \cdot 10^{+70}:\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;t_3\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (* 2.0 (* z t)))
        (t_2 (* -2.0 (* a (* c i))))
        (t_3 (* (* x y) 2.0)))
   (if (<= (* x y) -6.5e+113)
     t_3
     (if (<= (* x y) -9e-152)
       t_1
       (if (<= (* x y) -8e-252)
         t_2
         (if (<= (* x y) 0.0) t_1 (if (<= (* x y) 1.2e+70) t_2 t_3)))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = 2.0 * (z * t);
	double t_2 = -2.0 * (a * (c * i));
	double t_3 = (x * y) * 2.0;
	double tmp;
	if ((x * y) <= -6.5e+113) {
		tmp = t_3;
	} else if ((x * y) <= -9e-152) {
		tmp = t_1;
	} else if ((x * y) <= -8e-252) {
		tmp = t_2;
	} else if ((x * y) <= 0.0) {
		tmp = t_1;
	} else if ((x * y) <= 1.2e+70) {
		tmp = t_2;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_1 = 2.0d0 * (z * t)
    t_2 = (-2.0d0) * (a * (c * i))
    t_3 = (x * y) * 2.0d0
    if ((x * y) <= (-6.5d+113)) then
        tmp = t_3
    else if ((x * y) <= (-9d-152)) then
        tmp = t_1
    else if ((x * y) <= (-8d-252)) then
        tmp = t_2
    else if ((x * y) <= 0.0d0) then
        tmp = t_1
    else if ((x * y) <= 1.2d+70) 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 c, double i) {
	double t_1 = 2.0 * (z * t);
	double t_2 = -2.0 * (a * (c * i));
	double t_3 = (x * y) * 2.0;
	double tmp;
	if ((x * y) <= -6.5e+113) {
		tmp = t_3;
	} else if ((x * y) <= -9e-152) {
		tmp = t_1;
	} else if ((x * y) <= -8e-252) {
		tmp = t_2;
	} else if ((x * y) <= 0.0) {
		tmp = t_1;
	} else if ((x * y) <= 1.2e+70) {
		tmp = t_2;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = 2.0 * (z * t)
	t_2 = -2.0 * (a * (c * i))
	t_3 = (x * y) * 2.0
	tmp = 0
	if (x * y) <= -6.5e+113:
		tmp = t_3
	elif (x * y) <= -9e-152:
		tmp = t_1
	elif (x * y) <= -8e-252:
		tmp = t_2
	elif (x * y) <= 0.0:
		tmp = t_1
	elif (x * y) <= 1.2e+70:
		tmp = t_2
	else:
		tmp = t_3
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(2.0 * Float64(z * t))
	t_2 = Float64(-2.0 * Float64(a * Float64(c * i)))
	t_3 = Float64(Float64(x * y) * 2.0)
	tmp = 0.0
	if (Float64(x * y) <= -6.5e+113)
		tmp = t_3;
	elseif (Float64(x * y) <= -9e-152)
		tmp = t_1;
	elseif (Float64(x * y) <= -8e-252)
		tmp = t_2;
	elseif (Float64(x * y) <= 0.0)
		tmp = t_1;
	elseif (Float64(x * y) <= 1.2e+70)
		tmp = t_2;
	else
		tmp = t_3;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = 2.0 * (z * t);
	t_2 = -2.0 * (a * (c * i));
	t_3 = (x * y) * 2.0;
	tmp = 0.0;
	if ((x * y) <= -6.5e+113)
		tmp = t_3;
	elseif ((x * y) <= -9e-152)
		tmp = t_1;
	elseif ((x * y) <= -8e-252)
		tmp = t_2;
	elseif ((x * y) <= 0.0)
		tmp = t_1;
	elseif ((x * y) <= 1.2e+70)
		tmp = t_2;
	else
		tmp = t_3;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(2.0 * N[(z * t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(-2.0 * N[(a * N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(x * y), $MachinePrecision] * 2.0), $MachinePrecision]}, If[LessEqual[N[(x * y), $MachinePrecision], -6.5e+113], t$95$3, If[LessEqual[N[(x * y), $MachinePrecision], -9e-152], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], -8e-252], t$95$2, If[LessEqual[N[(x * y), $MachinePrecision], 0.0], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], 1.2e+70], t$95$2, t$95$3]]]]]]]]

Derivation

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

Alternative 5: 80.0% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \cdot y \leq -5.1 \cdot 10^{+107} \lor \neg \left(x \cdot y \leq 2.25 \cdot 10^{+73}\right):\\ \;\;\;\;2 \cdot \left(x \cdot y - c \cdot \left(\left(b \cdot c\right) \cdot i\right)\right)\\ \mathbf{else}:\\ \;\;\;\;2 \cdot \left(z \cdot t - c \cdot \left(\left(a + b \cdot c\right) \cdot i\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (if (or (<= (* x y) -5.1e+107) (not (<= (* x y) 2.25e+73)))
   (* 2.0 (- (* x y) (* c (* (* b c) i))))
   (* 2.0 (- (* z t) (* c (* (+ a (* b c)) i))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double tmp;
	if (((x * y) <= -5.1e+107) || !((x * y) <= 2.25e+73)) {
		tmp = 2.0 * ((x * y) - (c * ((b * c) * i)));
	} else {
		tmp = 2.0 * ((z * t) - (c * ((a + (b * c)) * i)));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: tmp
    if (((x * y) <= (-5.1d+107)) .or. (.not. ((x * y) <= 2.25d+73))) then
        tmp = 2.0d0 * ((x * y) - (c * ((b * c) * i)))
    else
        tmp = 2.0d0 * ((z * t) - (c * ((a + (b * c)) * i)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double tmp;
	if (((x * y) <= -5.1e+107) || !((x * y) <= 2.25e+73)) {
		tmp = 2.0 * ((x * y) - (c * ((b * c) * i)));
	} else {
		tmp = 2.0 * ((z * t) - (c * ((a + (b * c)) * i)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	tmp = 0
	if ((x * y) <= -5.1e+107) or not ((x * y) <= 2.25e+73):
		tmp = 2.0 * ((x * y) - (c * ((b * c) * i)))
	else:
		tmp = 2.0 * ((z * t) - (c * ((a + (b * c)) * i)))
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	tmp = 0.0
	if ((Float64(x * y) <= -5.1e+107) || !(Float64(x * y) <= 2.25e+73))
		tmp = Float64(2.0 * Float64(Float64(x * y) - Float64(c * Float64(Float64(b * c) * i))));
	else
		tmp = Float64(2.0 * Float64(Float64(z * t) - Float64(c * Float64(Float64(a + Float64(b * c)) * i))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	tmp = 0.0;
	if (((x * y) <= -5.1e+107) || ~(((x * y) <= 2.25e+73)))
		tmp = 2.0 * ((x * y) - (c * ((b * c) * i)));
	else
		tmp = 2.0 * ((z * t) - (c * ((a + (b * c)) * i)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := If[Or[LessEqual[N[(x * y), $MachinePrecision], -5.1e+107], N[Not[LessEqual[N[(x * y), $MachinePrecision], 2.25e+73]], $MachinePrecision]], N[(2.0 * N[(N[(x * y), $MachinePrecision] - N[(c * N[(N[(b * c), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(z * t), $MachinePrecision] - N[(c * N[(N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 6: 80.8% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := c \cdot \left(\left(a + b \cdot c\right) \cdot i\right)\\ \mathbf{if}\;x \cdot y \leq -2.85 \cdot 10^{+104}:\\ \;\;\;\;2 \cdot \left(x \cdot y - c \cdot \left(\left(b \cdot c\right) \cdot i\right)\right)\\ \mathbf{elif}\;x \cdot y \leq 1.25 \cdot 10^{+73}:\\ \;\;\;\;2 \cdot \left(z \cdot t - t_1\right)\\ \mathbf{else}:\\ \;\;\;\;2 \cdot \left(x \cdot y - t_1\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (* c (* (+ a (* b c)) i))))
   (if (<= (* x y) -2.85e+104)
     (* 2.0 (- (* x y) (* c (* (* b c) i))))
     (if (<= (* x y) 1.25e+73)
       (* 2.0 (- (* z t) t_1))
       (* 2.0 (- (* x y) t_1))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = c * ((a + (b * c)) * i);
	double tmp;
	if ((x * y) <= -2.85e+104) {
		tmp = 2.0 * ((x * y) - (c * ((b * c) * i)));
	} else if ((x * y) <= 1.25e+73) {
		tmp = 2.0 * ((z * t) - t_1);
	} else {
		tmp = 2.0 * ((x * y) - t_1);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: t_1
    real(8) :: tmp
    t_1 = c * ((a + (b * c)) * i)
    if ((x * y) <= (-2.85d+104)) then
        tmp = 2.0d0 * ((x * y) - (c * ((b * c) * i)))
    else if ((x * y) <= 1.25d+73) then
        tmp = 2.0d0 * ((z * t) - t_1)
    else
        tmp = 2.0d0 * ((x * y) - 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 c, double i) {
	double t_1 = c * ((a + (b * c)) * i);
	double tmp;
	if ((x * y) <= -2.85e+104) {
		tmp = 2.0 * ((x * y) - (c * ((b * c) * i)));
	} else if ((x * y) <= 1.25e+73) {
		tmp = 2.0 * ((z * t) - t_1);
	} else {
		tmp = 2.0 * ((x * y) - t_1);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = c * ((a + (b * c)) * i)
	tmp = 0
	if (x * y) <= -2.85e+104:
		tmp = 2.0 * ((x * y) - (c * ((b * c) * i)))
	elif (x * y) <= 1.25e+73:
		tmp = 2.0 * ((z * t) - t_1)
	else:
		tmp = 2.0 * ((x * y) - t_1)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(c * Float64(Float64(a + Float64(b * c)) * i))
	tmp = 0.0
	if (Float64(x * y) <= -2.85e+104)
		tmp = Float64(2.0 * Float64(Float64(x * y) - Float64(c * Float64(Float64(b * c) * i))));
	elseif (Float64(x * y) <= 1.25e+73)
		tmp = Float64(2.0 * Float64(Float64(z * t) - t_1));
	else
		tmp = Float64(2.0 * Float64(Float64(x * y) - t_1));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = c * ((a + (b * c)) * i);
	tmp = 0.0;
	if ((x * y) <= -2.85e+104)
		tmp = 2.0 * ((x * y) - (c * ((b * c) * i)));
	elseif ((x * y) <= 1.25e+73)
		tmp = 2.0 * ((z * t) - t_1);
	else
		tmp = 2.0 * ((x * y) - t_1);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(c * N[(N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(x * y), $MachinePrecision], -2.85e+104], N[(2.0 * N[(N[(x * y), $MachinePrecision] - N[(c * N[(N[(b * c), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 1.25e+73], N[(2.0 * N[(N[(z * t), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(x * y), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision]]]]

Derivation

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

Alternative 7: 86.3% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x \cdot y + z \cdot t\\ t_2 := c \cdot \left(\left(a + b \cdot c\right) \cdot i\right)\\ \mathbf{if}\;c \leq -5.2 \cdot 10^{+158}:\\ \;\;\;\;t_2 \cdot -2\\ \mathbf{elif}\;c \leq -1.95 \cdot 10^{-94}:\\ \;\;\;\;2 \cdot \left(t_1 - i \cdot \left(c \cdot \left(b \cdot c\right)\right)\right)\\ \mathbf{elif}\;c \leq 21000:\\ \;\;\;\;2 \cdot \left(t_1 - i \cdot \left(a \cdot c\right)\right)\\ \mathbf{else}:\\ \;\;\;\;2 \cdot \left(x \cdot y - t_2\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (+ (* x y) (* z t))) (t_2 (* c (* (+ a (* b c)) i))))
   (if (<= c -5.2e+158)
     (* t_2 -2.0)
     (if (<= c -1.95e-94)
       (* 2.0 (- t_1 (* i (* c (* b c)))))
       (if (<= c 21000.0)
         (* 2.0 (- t_1 (* i (* a c))))
         (* 2.0 (- (* x y) t_2)))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (x * y) + (z * t);
	double t_2 = c * ((a + (b * c)) * i);
	double tmp;
	if (c <= -5.2e+158) {
		tmp = t_2 * -2.0;
	} else if (c <= -1.95e-94) {
		tmp = 2.0 * (t_1 - (i * (c * (b * c))));
	} else if (c <= 21000.0) {
		tmp = 2.0 * (t_1 - (i * (a * c)));
	} else {
		tmp = 2.0 * ((x * y) - t_2);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (x * y) + (z * t)
    t_2 = c * ((a + (b * c)) * i)
    if (c <= (-5.2d+158)) then
        tmp = t_2 * (-2.0d0)
    else if (c <= (-1.95d-94)) then
        tmp = 2.0d0 * (t_1 - (i * (c * (b * c))))
    else if (c <= 21000.0d0) then
        tmp = 2.0d0 * (t_1 - (i * (a * c)))
    else
        tmp = 2.0d0 * ((x * y) - 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 c, double i) {
	double t_1 = (x * y) + (z * t);
	double t_2 = c * ((a + (b * c)) * i);
	double tmp;
	if (c <= -5.2e+158) {
		tmp = t_2 * -2.0;
	} else if (c <= -1.95e-94) {
		tmp = 2.0 * (t_1 - (i * (c * (b * c))));
	} else if (c <= 21000.0) {
		tmp = 2.0 * (t_1 - (i * (a * c)));
	} else {
		tmp = 2.0 * ((x * y) - t_2);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = (x * y) + (z * t)
	t_2 = c * ((a + (b * c)) * i)
	tmp = 0
	if c <= -5.2e+158:
		tmp = t_2 * -2.0
	elif c <= -1.95e-94:
		tmp = 2.0 * (t_1 - (i * (c * (b * c))))
	elif c <= 21000.0:
		tmp = 2.0 * (t_1 - (i * (a * c)))
	else:
		tmp = 2.0 * ((x * y) - t_2)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(Float64(x * y) + Float64(z * t))
	t_2 = Float64(c * Float64(Float64(a + Float64(b * c)) * i))
	tmp = 0.0
	if (c <= -5.2e+158)
		tmp = Float64(t_2 * -2.0);
	elseif (c <= -1.95e-94)
		tmp = Float64(2.0 * Float64(t_1 - Float64(i * Float64(c * Float64(b * c)))));
	elseif (c <= 21000.0)
		tmp = Float64(2.0 * Float64(t_1 - Float64(i * Float64(a * c))));
	else
		tmp = Float64(2.0 * Float64(Float64(x * y) - t_2));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = (x * y) + (z * t);
	t_2 = c * ((a + (b * c)) * i);
	tmp = 0.0;
	if (c <= -5.2e+158)
		tmp = t_2 * -2.0;
	elseif (c <= -1.95e-94)
		tmp = 2.0 * (t_1 - (i * (c * (b * c))));
	elseif (c <= 21000.0)
		tmp = 2.0 * (t_1 - (i * (a * c)));
	else
		tmp = 2.0 * ((x * y) - t_2);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(c * N[(N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -5.2e+158], N[(t$95$2 * -2.0), $MachinePrecision], If[LessEqual[c, -1.95e-94], N[(2.0 * N[(t$95$1 - N[(i * N[(c * N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 21000.0], N[(2.0 * N[(t$95$1 - N[(i * N[(a * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(x * y), $MachinePrecision] - t$95$2), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

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

Alternative 8: 74.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;c \leq -6.4 \cdot 10^{+130} \lor \neg \left(c \leq -1.3 \cdot 10^{+49}\right) \land \left(c \leq -3.5 \cdot 10^{+16} \lor \neg \left(c \leq 2.7 \cdot 10^{-7}\right)\right):\\ \;\;\;\;\left(c \cdot \left(\left(a + b \cdot c\right) \cdot i\right)\right) \cdot -2\\ \mathbf{else}:\\ \;\;\;\;\left(x \cdot y + z \cdot t\right) \cdot 2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (if (or (<= c -6.4e+130)
         (and (not (<= c -1.3e+49)) (or (<= c -3.5e+16) (not (<= c 2.7e-7)))))
   (* (* c (* (+ a (* b c)) i)) -2.0)
   (* (+ (* x y) (* z t)) 2.0)))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double tmp;
	if ((c <= -6.4e+130) || (!(c <= -1.3e+49) && ((c <= -3.5e+16) || !(c <= 2.7e-7)))) {
		tmp = (c * ((a + (b * c)) * i)) * -2.0;
	} else {
		tmp = ((x * y) + (z * t)) * 2.0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: tmp
    if ((c <= (-6.4d+130)) .or. (.not. (c <= (-1.3d+49))) .and. (c <= (-3.5d+16)) .or. (.not. (c <= 2.7d-7))) then
        tmp = (c * ((a + (b * c)) * i)) * (-2.0d0)
    else
        tmp = ((x * y) + (z * t)) * 2.0d0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double tmp;
	if ((c <= -6.4e+130) || (!(c <= -1.3e+49) && ((c <= -3.5e+16) || !(c <= 2.7e-7)))) {
		tmp = (c * ((a + (b * c)) * i)) * -2.0;
	} else {
		tmp = ((x * y) + (z * t)) * 2.0;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	tmp = 0
	if (c <= -6.4e+130) or (not (c <= -1.3e+49) and ((c <= -3.5e+16) or not (c <= 2.7e-7))):
		tmp = (c * ((a + (b * c)) * i)) * -2.0
	else:
		tmp = ((x * y) + (z * t)) * 2.0
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	tmp = 0.0
	if ((c <= -6.4e+130) || (!(c <= -1.3e+49) && ((c <= -3.5e+16) || !(c <= 2.7e-7))))
		tmp = Float64(Float64(c * Float64(Float64(a + Float64(b * c)) * i)) * -2.0);
	else
		tmp = Float64(Float64(Float64(x * y) + Float64(z * t)) * 2.0);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	tmp = 0.0;
	if ((c <= -6.4e+130) || (~((c <= -1.3e+49)) && ((c <= -3.5e+16) || ~((c <= 2.7e-7)))))
		tmp = (c * ((a + (b * c)) * i)) * -2.0;
	else
		tmp = ((x * y) + (z * t)) * 2.0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := If[Or[LessEqual[c, -6.4e+130], And[N[Not[LessEqual[c, -1.3e+49]], $MachinePrecision], Or[LessEqual[c, -3.5e+16], N[Not[LessEqual[c, 2.7e-7]], $MachinePrecision]]]], N[(N[(c * N[(N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision] * -2.0), $MachinePrecision], N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]]

Derivation

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

Alternative 9: 87.3% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;c \leq -6 \cdot 10^{-29} \lor \neg \left(c \leq 1000000\right):\\ \;\;\;\;2 \cdot \left(x \cdot y - c \cdot \left(\left(a + b \cdot c\right) \cdot i\right)\right)\\ \mathbf{else}:\\ \;\;\;\;2 \cdot \left(\left(x \cdot y + z \cdot t\right) - i \cdot \left(a \cdot c\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (if (or (<= c -6e-29) (not (<= c 1000000.0)))
   (* 2.0 (- (* x y) (* c (* (+ a (* b c)) i))))
   (* 2.0 (- (+ (* x y) (* z t)) (* i (* a c))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double tmp;
	if ((c <= -6e-29) || !(c <= 1000000.0)) {
		tmp = 2.0 * ((x * y) - (c * ((a + (b * c)) * i)));
	} else {
		tmp = 2.0 * (((x * y) + (z * t)) - (i * (a * c)));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: tmp
    if ((c <= (-6d-29)) .or. (.not. (c <= 1000000.0d0))) then
        tmp = 2.0d0 * ((x * y) - (c * ((a + (b * c)) * i)))
    else
        tmp = 2.0d0 * (((x * y) + (z * t)) - (i * (a * c)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double tmp;
	if ((c <= -6e-29) || !(c <= 1000000.0)) {
		tmp = 2.0 * ((x * y) - (c * ((a + (b * c)) * i)));
	} else {
		tmp = 2.0 * (((x * y) + (z * t)) - (i * (a * c)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	tmp = 0
	if (c <= -6e-29) or not (c <= 1000000.0):
		tmp = 2.0 * ((x * y) - (c * ((a + (b * c)) * i)))
	else:
		tmp = 2.0 * (((x * y) + (z * t)) - (i * (a * c)))
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	tmp = 0.0
	if ((c <= -6e-29) || !(c <= 1000000.0))
		tmp = Float64(2.0 * Float64(Float64(x * y) - Float64(c * Float64(Float64(a + Float64(b * c)) * i))));
	else
		tmp = Float64(2.0 * Float64(Float64(Float64(x * y) + Float64(z * t)) - Float64(i * Float64(a * c))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	tmp = 0.0;
	if ((c <= -6e-29) || ~((c <= 1000000.0)))
		tmp = 2.0 * ((x * y) - (c * ((a + (b * c)) * i)));
	else
		tmp = 2.0 * (((x * y) + (z * t)) - (i * (a * c)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := If[Or[LessEqual[c, -6e-29], N[Not[LessEqual[c, 1000000.0]], $MachinePrecision]], N[(2.0 * N[(N[(x * y), $MachinePrecision] - N[(c * N[(N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] - N[(i * N[(a * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 10: 74.9% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(c \cdot \left(\left(a + b \cdot c\right) \cdot i\right)\right) \cdot -2\\ \mathbf{if}\;c \leq -5.8 \cdot 10^{+141}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;c \leq -2.9 \cdot 10^{-39}:\\ \;\;\;\;2 \cdot \left(x \cdot y - c \cdot \left(\left(b \cdot c\right) \cdot i\right)\right)\\ \mathbf{elif}\;c \leq 2.7 \cdot 10^{-7}:\\ \;\;\;\;\left(x \cdot y + z \cdot t\right) \cdot 2\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (* (* c (* (+ a (* b c)) i)) -2.0)))
   (if (<= c -5.8e+141)
     t_1
     (if (<= c -2.9e-39)
       (* 2.0 (- (* x y) (* c (* (* b c) i))))
       (if (<= c 2.7e-7) (* (+ (* x y) (* z t)) 2.0) t_1)))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (c * ((a + (b * c)) * i)) * -2.0;
	double tmp;
	if (c <= -5.8e+141) {
		tmp = t_1;
	} else if (c <= -2.9e-39) {
		tmp = 2.0 * ((x * y) - (c * ((b * c) * i)));
	} else if (c <= 2.7e-7) {
		tmp = ((x * y) + (z * t)) * 2.0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (c * ((a + (b * c)) * i)) * (-2.0d0)
    if (c <= (-5.8d+141)) then
        tmp = t_1
    else if (c <= (-2.9d-39)) then
        tmp = 2.0d0 * ((x * y) - (c * ((b * c) * i)))
    else if (c <= 2.7d-7) then
        tmp = ((x * y) + (z * t)) * 2.0d0
    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 c, double i) {
	double t_1 = (c * ((a + (b * c)) * i)) * -2.0;
	double tmp;
	if (c <= -5.8e+141) {
		tmp = t_1;
	} else if (c <= -2.9e-39) {
		tmp = 2.0 * ((x * y) - (c * ((b * c) * i)));
	} else if (c <= 2.7e-7) {
		tmp = ((x * y) + (z * t)) * 2.0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = (c * ((a + (b * c)) * i)) * -2.0
	tmp = 0
	if c <= -5.8e+141:
		tmp = t_1
	elif c <= -2.9e-39:
		tmp = 2.0 * ((x * y) - (c * ((b * c) * i)))
	elif c <= 2.7e-7:
		tmp = ((x * y) + (z * t)) * 2.0
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(Float64(c * Float64(Float64(a + Float64(b * c)) * i)) * -2.0)
	tmp = 0.0
	if (c <= -5.8e+141)
		tmp = t_1;
	elseif (c <= -2.9e-39)
		tmp = Float64(2.0 * Float64(Float64(x * y) - Float64(c * Float64(Float64(b * c) * i))));
	elseif (c <= 2.7e-7)
		tmp = Float64(Float64(Float64(x * y) + Float64(z * t)) * 2.0);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = (c * ((a + (b * c)) * i)) * -2.0;
	tmp = 0.0;
	if (c <= -5.8e+141)
		tmp = t_1;
	elseif (c <= -2.9e-39)
		tmp = 2.0 * ((x * y) - (c * ((b * c) * i)));
	elseif (c <= 2.7e-7)
		tmp = ((x * y) + (z * t)) * 2.0;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(c * N[(N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision] * -2.0), $MachinePrecision]}, If[LessEqual[c, -5.8e+141], t$95$1, If[LessEqual[c, -2.9e-39], N[(2.0 * N[(N[(x * y), $MachinePrecision] - N[(c * N[(N[(b * c), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 2.7e-7], N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], t$95$1]]]]

Derivation

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

Alternative 11: 44.5% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \cdot y \leq -5.6 \cdot 10^{+113} \lor \neg \left(x \cdot y \leq 1.4 \cdot 10^{+73}\right):\\ \;\;\;\;\left(x \cdot y\right) \cdot 2\\ \mathbf{else}:\\ \;\;\;\;2 \cdot \left(z \cdot t\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (if (or (<= (* x y) -5.6e+113) (not (<= (* x y) 1.4e+73)))
   (* (* x y) 2.0)
   (* 2.0 (* z t))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double tmp;
	if (((x * y) <= -5.6e+113) || !((x * y) <= 1.4e+73)) {
		tmp = (x * y) * 2.0;
	} else {
		tmp = 2.0 * (z * t);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: tmp
    if (((x * y) <= (-5.6d+113)) .or. (.not. ((x * y) <= 1.4d+73))) then
        tmp = (x * y) * 2.0d0
    else
        tmp = 2.0d0 * (z * 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 c, double i) {
	double tmp;
	if (((x * y) <= -5.6e+113) || !((x * y) <= 1.4e+73)) {
		tmp = (x * y) * 2.0;
	} else {
		tmp = 2.0 * (z * t);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	tmp = 0
	if ((x * y) <= -5.6e+113) or not ((x * y) <= 1.4e+73):
		tmp = (x * y) * 2.0
	else:
		tmp = 2.0 * (z * t)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	tmp = 0.0
	if ((Float64(x * y) <= -5.6e+113) || !(Float64(x * y) <= 1.4e+73))
		tmp = Float64(Float64(x * y) * 2.0);
	else
		tmp = Float64(2.0 * Float64(z * t));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	tmp = 0.0;
	if (((x * y) <= -5.6e+113) || ~(((x * y) <= 1.4e+73)))
		tmp = (x * y) * 2.0;
	else
		tmp = 2.0 * (z * t);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := If[Or[LessEqual[N[(x * y), $MachinePrecision], -5.6e+113], N[Not[LessEqual[N[(x * y), $MachinePrecision], 1.4e+73]], $MachinePrecision]], N[(N[(x * y), $MachinePrecision] * 2.0), $MachinePrecision], N[(2.0 * N[(z * t), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 12: 57.6% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;c \leq -8 \cdot 10^{+133}:\\ \;\;\;\;-2 \cdot \left(a \cdot \left(c \cdot i\right)\right)\\ \mathbf{elif}\;c \leq 1.78 \cdot 10^{+190}:\\ \;\;\;\;\left(x \cdot y + z \cdot t\right) \cdot 2\\ \mathbf{else}:\\ \;\;\;\;i \cdot \left(a \cdot \left(c \cdot -2\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (if (<= c -8e+133)
   (* -2.0 (* a (* c i)))
   (if (<= c 1.78e+190) (* (+ (* x y) (* z t)) 2.0) (* i (* a (* c -2.0))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double tmp;
	if (c <= -8e+133) {
		tmp = -2.0 * (a * (c * i));
	} else if (c <= 1.78e+190) {
		tmp = ((x * y) + (z * t)) * 2.0;
	} else {
		tmp = i * (a * (c * -2.0));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    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), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: tmp
    if (c <= (-8d+133)) then
        tmp = (-2.0d0) * (a * (c * i))
    else if (c <= 1.78d+190) then
        tmp = ((x * y) + (z * t)) * 2.0d0
    else
        tmp = i * (a * (c * (-2.0d0)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double tmp;
	if (c <= -8e+133) {
		tmp = -2.0 * (a * (c * i));
	} else if (c <= 1.78e+190) {
		tmp = ((x * y) + (z * t)) * 2.0;
	} else {
		tmp = i * (a * (c * -2.0));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	tmp = 0
	if c <= -8e+133:
		tmp = -2.0 * (a * (c * i))
	elif c <= 1.78e+190:
		tmp = ((x * y) + (z * t)) * 2.0
	else:
		tmp = i * (a * (c * -2.0))
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	tmp = 0.0
	if (c <= -8e+133)
		tmp = Float64(-2.0 * Float64(a * Float64(c * i)));
	elseif (c <= 1.78e+190)
		tmp = Float64(Float64(Float64(x * y) + Float64(z * t)) * 2.0);
	else
		tmp = Float64(i * Float64(a * Float64(c * -2.0)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	tmp = 0.0;
	if (c <= -8e+133)
		tmp = -2.0 * (a * (c * i));
	elseif (c <= 1.78e+190)
		tmp = ((x * y) + (z * t)) * 2.0;
	else
		tmp = i * (a * (c * -2.0));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[c, -8e+133], N[(-2.0 * N[(a * N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 1.78e+190], N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], N[(i * N[(a * N[(c * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 13: 29.8% accurate, 3.8× speedup

Math

\[\begin{array}{l} \\ 2 \cdot \left(z \cdot t\right) \end{array} \]

FPCore

(FPCore (x y z t a b c i) :precision binary64 (* 2.0 (* z t)))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	return 2.0 * (z * t);
}

Fortran

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

Java

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

Python

def code(x, y, z, t, a, b, c, i):
	return 2.0 * (z * t)

Julia

function code(x, y, z, t, a, b, c, i)
	return Float64(2.0 * Float64(z * t))
end

MATLAB

function tmp = code(x, y, z, t, a, b, c, i)
	tmp = 2.0 * (z * t);
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(2.0 * N[(z * t), $MachinePrecision]), $MachinePrecision]

Derivation

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

Developer target: 94.4% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Reproduce

herbie shell --seed 2023343 
(FPCore (x y z t a b c i)
  :name "Diagrams.ThreeD.Shapes:frustum from diagrams-lib-1.3.0.3, A"
  :precision binary64

  :herbie-target
  (* 2.0 (- (+ (* x y) (* z t)) (* (+ a (* b c)) (* c i))))

  (* 2.0 (- (+ (* x y) (* z t)) (* (* (+ a (* b c)) c) i))))