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

Percentage Accurate: 90.3% → 94.4%

Time: 12.5s

Alternatives: 14

Speedup: 1.0×

• 47.0% 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: 94.4% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := a + b \cdot c\\ t_2 := c \cdot \left(t_1 \cdot i\right)\\ t_3 := i \cdot \left(c \cdot t_1\right)\\ \mathbf{if}\;t_3 \leq -\infty:\\ \;\;\;\;-2 \cdot t_2\\ \mathbf{elif}\;t_3 \leq 10^{+242}:\\ \;\;\;\;2 \cdot \left(\left(z \cdot t + x \cdot y\right) - t_3\right)\\ \mathbf{else}:\\ \;\;\;\;2 \cdot \left(z \cdot t - t_2\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 (* c (* t_1 i))) (t_3 (* i (* c t_1))))
   (if (<= t_3 (- INFINITY))
     (* -2.0 t_2)
     (if (<= t_3 1e+242)
       (* 2.0 (- (+ (* z t) (* x y)) t_3))
       (* 2.0 (- (* z t) t_2))))))

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 = i * (c * t_1);
	double tmp;
	if (t_3 <= -((double) INFINITY)) {
		tmp = -2.0 * t_2;
	} else if (t_3 <= 1e+242) {
		tmp = 2.0 * (((z * t) + (x * y)) - t_3);
	} else {
		tmp = 2.0 * ((z * t) - t_2);
	}
	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 = i * (c * t_1);
	double tmp;
	if (t_3 <= -Double.POSITIVE_INFINITY) {
		tmp = -2.0 * t_2;
	} else if (t_3 <= 1e+242) {
		tmp = 2.0 * (((z * t) + (x * y)) - t_3);
	} else {
		tmp = 2.0 * ((z * t) - t_2);
	}
	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 = i * (c * t_1)
	tmp = 0
	if t_3 <= -math.inf:
		tmp = -2.0 * t_2
	elif t_3 <= 1e+242:
		tmp = 2.0 * (((z * t) + (x * y)) - t_3)
	else:
		tmp = 2.0 * ((z * t) - t_2)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(a + Float64(b * c))
	t_2 = Float64(c * Float64(t_1 * i))
	t_3 = Float64(i * Float64(c * t_1))
	tmp = 0.0
	if (t_3 <= Float64(-Inf))
		tmp = Float64(-2.0 * t_2);
	elseif (t_3 <= 1e+242)
		tmp = Float64(2.0 * Float64(Float64(Float64(z * t) + Float64(x * y)) - t_3));
	else
		tmp = Float64(2.0 * Float64(Float64(z * t) - t_2));
	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 = i * (c * t_1);
	tmp = 0.0;
	if (t_3 <= -Inf)
		tmp = -2.0 * t_2;
	elseif (t_3 <= 1e+242)
		tmp = 2.0 * (((z * t) + (x * y)) - t_3);
	else
		tmp = 2.0 * ((z * t) - t_2);
	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[(c * N[(t$95$1 * i), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(i * N[(c * t$95$1), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$3, (-Infinity)], N[(-2.0 * t$95$2), $MachinePrecision], If[LessEqual[t$95$3, 1e+242], N[(2.0 * N[(N[(N[(z * t), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision] - t$95$3), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(z * t), $MachinePrecision] - t$95$2), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

1. Split input into 3 regimes

2. if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -inf.0

   1. Initial program 76.0%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   2. Taylor expanded in z around 0 87.9%

      \[\leadsto 2 \cdot \color{blue}{\left(y \cdot x - c \cdot \left(i \cdot \left(c \cdot b + a\right)\right)\right)} \]

   3. Taylor expanded in y around 0 88.2%

      \[\leadsto \color{blue}{-2 \cdot \left(c \cdot \left(i \cdot \left(c \cdot b + a\right)\right)\right)} \]

   if -inf.0 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1.00000000000000005e242

   1. Initial program 98.4%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   if 1.00000000000000005e242 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i)

   1. Initial program 80.7%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   2. Taylor expanded in x around 0 96.3%

      \[\leadsto 2 \cdot \color{blue}{\left(t \cdot z - c \cdot \left(i \cdot \left(c \cdot b + a\right)\right)\right)} \]
3. Recombined 3 regimes into one program.

4. Final simplification 96.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;i \cdot \left(c \cdot \left(a + b \cdot c\right)\right) \leq -\infty:\\ \;\;\;\;-2 \cdot \left(c \cdot \left(\left(a + b \cdot c\right) \cdot i\right)\right)\\ \mathbf{elif}\;i \cdot \left(c \cdot \left(a + b \cdot c\right)\right) \leq 10^{+242}:\\ \;\;\;\;2 \cdot \left(\left(z \cdot t + x \cdot y\right) - i \cdot \left(c \cdot \left(a + b \cdot c\right)\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} \]

Alternative 2: 94.6% accurate, 0.2× speedup

Math

\[\begin{array}{l} \\ 2 \cdot \left(\mathsf{fma}\left(x, 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 (- (fma 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 * (fma(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(fma(x, y, Float64(z * t)) - Float64(Float64(a + Float64(b * c)) * Float64(c * i))))
end

Wolfram

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

Derivation

1. Initial program 91.0%

   \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]
2. Step-by-step derivation

   1. associate-*l* 95.3%

      \[\leadsto 2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \color{blue}{\left(a + b \cdot c\right) \cdot \left(c \cdot i\right)}\right) \]

   2. fma-def 95.7%

      \[\leadsto 2 \cdot \left(\color{blue}{\mathsf{fma}\left(x, y, z \cdot t\right)} - \left(a + b \cdot c\right) \cdot \left(c \cdot i\right)\right) \]

3. Simplified 95.7%

   \[\leadsto \color{blue}{2 \cdot \left(\mathsf{fma}\left(x, y, z \cdot t\right) - \left(a + b \cdot c\right) \cdot \left(c \cdot i\right)\right)} \]

4. Final simplification 95.7%

   \[\leadsto 2 \cdot \left(\mathsf{fma}\left(x, y, z \cdot t\right) - \left(a + b \cdot c\right) \cdot \left(c \cdot i\right)\right) \]

Alternative 3: 38.7% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := 2 \cdot \left(z \cdot t\right)\\ t_2 := 2 \cdot \left(x \cdot y\right)\\ \mathbf{if}\;x \leq -1.5 \cdot 10^{+149}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;x \leq -1.05 \cdot 10^{+136}:\\ \;\;\;\;-2 \cdot \left(c \cdot \left(a \cdot i\right)\right)\\ \mathbf{elif}\;x \leq -7.5 \cdot 10^{+102}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;x \leq -9 \cdot 10^{+66}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \leq -1.8 \cdot 10^{+40}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;x \leq -0.000185:\\ \;\;\;\;\left(a \cdot c\right) \cdot \left(i \cdot -2\right)\\ \mathbf{elif}\;x \leq 3.5 \cdot 10^{-264}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \leq 9.6 \cdot 10^{-231}:\\ \;\;\;\;2 \cdot \left(\left(c \cdot i\right) \cdot \left(-a\right)\right)\\ \mathbf{elif}\;x \leq 4.5 \cdot 10^{-84}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \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 (* x y))))
   (if (<= x -1.5e+149)
     t_2
     (if (<= x -1.05e+136)
       (* -2.0 (* c (* a i)))
       (if (<= x -7.5e+102)
         t_2
         (if (<= x -9e+66)
           t_1
           (if (<= x -1.8e+40)
             t_2
             (if (<= x -0.000185)
               (* (* a c) (* i -2.0))
               (if (<= x 3.5e-264)
                 t_1
                 (if (<= x 9.6e-231)
                   (* 2.0 (* (* c i) (- a)))
                   (if (<= x 4.5e-84) t_1 t_2)))))))))))

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 * (x * y);
	double tmp;
	if (x <= -1.5e+149) {
		tmp = t_2;
	} else if (x <= -1.05e+136) {
		tmp = -2.0 * (c * (a * i));
	} else if (x <= -7.5e+102) {
		tmp = t_2;
	} else if (x <= -9e+66) {
		tmp = t_1;
	} else if (x <= -1.8e+40) {
		tmp = t_2;
	} else if (x <= -0.000185) {
		tmp = (a * c) * (i * -2.0);
	} else if (x <= 3.5e-264) {
		tmp = t_1;
	} else if (x <= 9.6e-231) {
		tmp = 2.0 * ((c * i) * -a);
	} else if (x <= 4.5e-84) {
		tmp = t_1;
	} else {
		tmp = 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 = 2.0d0 * (z * t)
    t_2 = 2.0d0 * (x * y)
    if (x <= (-1.5d+149)) then
        tmp = t_2
    else if (x <= (-1.05d+136)) then
        tmp = (-2.0d0) * (c * (a * i))
    else if (x <= (-7.5d+102)) then
        tmp = t_2
    else if (x <= (-9d+66)) then
        tmp = t_1
    else if (x <= (-1.8d+40)) then
        tmp = t_2
    else if (x <= (-0.000185d0)) then
        tmp = (a * c) * (i * (-2.0d0))
    else if (x <= 3.5d-264) then
        tmp = t_1
    else if (x <= 9.6d-231) then
        tmp = 2.0d0 * ((c * i) * -a)
    else if (x <= 4.5d-84) 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 c, double i) {
	double t_1 = 2.0 * (z * t);
	double t_2 = 2.0 * (x * y);
	double tmp;
	if (x <= -1.5e+149) {
		tmp = t_2;
	} else if (x <= -1.05e+136) {
		tmp = -2.0 * (c * (a * i));
	} else if (x <= -7.5e+102) {
		tmp = t_2;
	} else if (x <= -9e+66) {
		tmp = t_1;
	} else if (x <= -1.8e+40) {
		tmp = t_2;
	} else if (x <= -0.000185) {
		tmp = (a * c) * (i * -2.0);
	} else if (x <= 3.5e-264) {
		tmp = t_1;
	} else if (x <= 9.6e-231) {
		tmp = 2.0 * ((c * i) * -a);
	} else if (x <= 4.5e-84) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = 2.0 * (z * t)
	t_2 = 2.0 * (x * y)
	tmp = 0
	if x <= -1.5e+149:
		tmp = t_2
	elif x <= -1.05e+136:
		tmp = -2.0 * (c * (a * i))
	elif x <= -7.5e+102:
		tmp = t_2
	elif x <= -9e+66:
		tmp = t_1
	elif x <= -1.8e+40:
		tmp = t_2
	elif x <= -0.000185:
		tmp = (a * c) * (i * -2.0)
	elif x <= 3.5e-264:
		tmp = t_1
	elif x <= 9.6e-231:
		tmp = 2.0 * ((c * i) * -a)
	elif x <= 4.5e-84:
		tmp = t_1
	else:
		tmp = t_2
	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(x * y))
	tmp = 0.0
	if (x <= -1.5e+149)
		tmp = t_2;
	elseif (x <= -1.05e+136)
		tmp = Float64(-2.0 * Float64(c * Float64(a * i)));
	elseif (x <= -7.5e+102)
		tmp = t_2;
	elseif (x <= -9e+66)
		tmp = t_1;
	elseif (x <= -1.8e+40)
		tmp = t_2;
	elseif (x <= -0.000185)
		tmp = Float64(Float64(a * c) * Float64(i * -2.0));
	elseif (x <= 3.5e-264)
		tmp = t_1;
	elseif (x <= 9.6e-231)
		tmp = Float64(2.0 * Float64(Float64(c * i) * Float64(-a)));
	elseif (x <= 4.5e-84)
		tmp = t_1;
	else
		tmp = t_2;
	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 * (x * y);
	tmp = 0.0;
	if (x <= -1.5e+149)
		tmp = t_2;
	elseif (x <= -1.05e+136)
		tmp = -2.0 * (c * (a * i));
	elseif (x <= -7.5e+102)
		tmp = t_2;
	elseif (x <= -9e+66)
		tmp = t_1;
	elseif (x <= -1.8e+40)
		tmp = t_2;
	elseif (x <= -0.000185)
		tmp = (a * c) * (i * -2.0);
	elseif (x <= 3.5e-264)
		tmp = t_1;
	elseif (x <= 9.6e-231)
		tmp = 2.0 * ((c * i) * -a);
	elseif (x <= 4.5e-84)
		tmp = t_1;
	else
		tmp = t_2;
	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[(x * y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.5e+149], t$95$2, If[LessEqual[x, -1.05e+136], N[(-2.0 * N[(c * N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -7.5e+102], t$95$2, If[LessEqual[x, -9e+66], t$95$1, If[LessEqual[x, -1.8e+40], t$95$2, If[LessEqual[x, -0.000185], N[(N[(a * c), $MachinePrecision] * N[(i * -2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 3.5e-264], t$95$1, If[LessEqual[x, 9.6e-231], N[(2.0 * N[(N[(c * i), $MachinePrecision] * (-a)), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 4.5e-84], t$95$1, t$95$2]]]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if x < -1.50000000000000002e149 or -1.05e136 < x < -7.5e102 or -8.9999999999999997e66 < x < -1.79999999999999998e40 or 4.50000000000000016e-84 < x

   1. Initial program 89.9%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   2. Taylor expanded in x around inf 52.3%

      \[\leadsto 2 \cdot \color{blue}{\left(y \cdot x\right)} \]

   if -1.50000000000000002e149 < x < -1.05e136

   1. Initial program 88.2%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   2. Taylor expanded in z around 0 64.6%

      \[\leadsto 2 \cdot \color{blue}{\left(y \cdot x - c \cdot \left(i \cdot \left(c \cdot b + a\right)\right)\right)} \]

   3. Taylor expanded in a around inf 63.4%

      \[\leadsto \color{blue}{-2 \cdot \left(c \cdot \left(i \cdot a\right)\right)} \]

   if -7.5e102 < x < -8.9999999999999997e66 or -1.85e-4 < x < 3.5e-264 or 9.59999999999999967e-231 < x < 4.50000000000000016e-84

   1. Initial program 91.3%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   2. Taylor expanded in z around inf 44.9%

      \[\leadsto 2 \cdot \color{blue}{\left(t \cdot z\right)} \]

   if -1.79999999999999998e40 < x < -1.85e-4

   1. Initial program 100.0%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   2. Taylor expanded in z around 0 69.7%

      \[\leadsto 2 \cdot \color{blue}{\left(y \cdot x - c \cdot \left(i \cdot \left(c \cdot b + a\right)\right)\right)} \]

   3. Taylor expanded in a around inf 20.7%

      \[\leadsto \color{blue}{-2 \cdot \left(c \cdot \left(i \cdot a\right)\right)} \]
   4. Step-by-step derivation

      1. *-commutative 20.7%

         \[\leadsto -2 \cdot \left(c \cdot \color{blue}{\left(a \cdot i\right)}\right) \]

      2. *-commutative 20.7%

         \[\leadsto \color{blue}{\left(c \cdot \left(a \cdot i\right)\right) \cdot -2} \]

      3. associate-*r* 51.2%

         \[\leadsto \color{blue}{\left(\left(c \cdot a\right) \cdot i\right)} \cdot -2 \]

      4. associate-*l* 51.2%

         \[\leadsto \color{blue}{\left(c \cdot a\right) \cdot \left(i \cdot -2\right)} \]

   5. Simplified 51.2%

      \[\leadsto \color{blue}{\left(c \cdot a\right) \cdot \left(i \cdot -2\right)} \]

   if 3.5e-264 < x < 9.59999999999999967e-231

   1. Initial program 100.0%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]
   2. Step-by-step derivation

      1. associate-*l* 100.0%

         \[\leadsto 2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \color{blue}{\left(a + b \cdot c\right) \cdot \left(c \cdot i\right)}\right) \]

      2. fma-def 100.0%

         \[\leadsto 2 \cdot \left(\color{blue}{\mathsf{fma}\left(x, y, z \cdot t\right)} - \left(a + b \cdot c\right) \cdot \left(c \cdot i\right)\right) \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{2 \cdot \left(\mathsf{fma}\left(x, y, z \cdot t\right) - \left(a + b \cdot c\right) \cdot \left(c \cdot i\right)\right)} \]
   4. Step-by-step derivation

      1. fma-def 100.0%

         \[\leadsto 2 \cdot \left(\color{blue}{\left(x \cdot y + z \cdot t\right)} - \left(a + b \cdot c\right) \cdot \left(c \cdot i\right)\right) \]

      2. +-commutative 100.0%

         \[\leadsto 2 \cdot \left(\color{blue}{\left(z \cdot t + x \cdot y\right)} - \left(a + b \cdot c\right) \cdot \left(c \cdot i\right)\right) \]

   5. Applied egg-rr 100.0%

      \[\leadsto 2 \cdot \left(\color{blue}{\left(z \cdot t + x \cdot y\right)} - \left(a + b \cdot c\right) \cdot \left(c \cdot i\right)\right) \]

   6. Taylor expanded in a around inf 16.1%

      \[\leadsto 2 \cdot \color{blue}{\left(-1 \cdot \left(c \cdot \left(i \cdot a\right)\right)\right)} \]
   7. Step-by-step derivation

      1. mul-1-neg 16.1%

         \[\leadsto 2 \cdot \color{blue}{\left(-c \cdot \left(i \cdot a\right)\right)} \]

      2. associate-*r* 16.0%

         \[\leadsto 2 \cdot \left(-\color{blue}{\left(c \cdot i\right) \cdot a}\right) \]

      3. *-commutative 16.0%

         \[\leadsto 2 \cdot \left(-\color{blue}{a \cdot \left(c \cdot i\right)}\right) \]

      4. distribute-rgt-neg-in 16.0%

         \[\leadsto 2 \cdot \color{blue}{\left(a \cdot \left(-c \cdot i\right)\right)} \]

      5. distribute-rgt-neg-in 16.0%

         \[\leadsto 2 \cdot \left(a \cdot \color{blue}{\left(c \cdot \left(-i\right)\right)}\right) \]

   8. Simplified 16.0%

      \[\leadsto 2 \cdot \color{blue}{\left(a \cdot \left(c \cdot \left(-i\right)\right)\right)} \]
3. Recombined 5 regimes into one program.

4. Final simplification 48.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -1.5 \cdot 10^{+149}:\\ \;\;\;\;2 \cdot \left(x \cdot y\right)\\ \mathbf{elif}\;x \leq -1.05 \cdot 10^{+136}:\\ \;\;\;\;-2 \cdot \left(c \cdot \left(a \cdot i\right)\right)\\ \mathbf{elif}\;x \leq -7.5 \cdot 10^{+102}:\\ \;\;\;\;2 \cdot \left(x \cdot y\right)\\ \mathbf{elif}\;x \leq -9 \cdot 10^{+66}:\\ \;\;\;\;2 \cdot \left(z \cdot t\right)\\ \mathbf{elif}\;x \leq -1.8 \cdot 10^{+40}:\\ \;\;\;\;2 \cdot \left(x \cdot y\right)\\ \mathbf{elif}\;x \leq -0.000185:\\ \;\;\;\;\left(a \cdot c\right) \cdot \left(i \cdot -2\right)\\ \mathbf{elif}\;x \leq 3.5 \cdot 10^{-264}:\\ \;\;\;\;2 \cdot \left(z \cdot t\right)\\ \mathbf{elif}\;x \leq 9.6 \cdot 10^{-231}:\\ \;\;\;\;2 \cdot \left(\left(c \cdot i\right) \cdot \left(-a\right)\right)\\ \mathbf{elif}\;x \leq 4.5 \cdot 10^{-84}:\\ \;\;\;\;2 \cdot \left(z \cdot t\right)\\ \mathbf{else}:\\ \;\;\;\;2 \cdot \left(x \cdot y\right)\\ \end{array} \]

Alternative 4: 76.2% accurate, 1.0× 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 \leq -1.12 \cdot 10^{+85} \lor \neg \left(x \leq 2.2 \cdot 10^{-146}\right):\\ \;\;\;\;2 \cdot \left(x \cdot y - t_1\right)\\ \mathbf{else}:\\ \;\;\;\;2 \cdot \left(z \cdot t - 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 (or (<= x -1.12e+85) (not (<= x 2.2e-146)))
     (* 2.0 (- (* x y) t_1))
     (* 2.0 (- (* z t) 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 <= -1.12e+85) || !(x <= 2.2e-146)) {
		tmp = 2.0 * ((x * y) - t_1);
	} else {
		tmp = 2.0 * ((z * t) - 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 <= (-1.12d+85)) .or. (.not. (x <= 2.2d-146))) then
        tmp = 2.0d0 * ((x * y) - t_1)
    else
        tmp = 2.0d0 * ((z * t) - 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 <= -1.12e+85) || !(x <= 2.2e-146)) {
		tmp = 2.0 * ((x * y) - t_1);
	} else {
		tmp = 2.0 * ((z * t) - 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 <= -1.12e+85) or not (x <= 2.2e-146):
		tmp = 2.0 * ((x * y) - t_1)
	else:
		tmp = 2.0 * ((z * t) - 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 ((x <= -1.12e+85) || !(x <= 2.2e-146))
		tmp = Float64(2.0 * Float64(Float64(x * y) - t_1));
	else
		tmp = Float64(2.0 * Float64(Float64(z * t) - 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 <= -1.12e+85) || ~((x <= 2.2e-146)))
		tmp = 2.0 * ((x * y) - t_1);
	else
		tmp = 2.0 * ((z * t) - 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[Or[LessEqual[x, -1.12e+85], N[Not[LessEqual[x, 2.2e-146]], $MachinePrecision]], N[(2.0 * N[(N[(x * y), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(z * t), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if x < -1.11999999999999993e85 or 2.2e-146 < x

   1. Initial program 89.9%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   2. Taylor expanded in z around 0 78.5%

      \[\leadsto 2 \cdot \color{blue}{\left(y \cdot x - c \cdot \left(i \cdot \left(c \cdot b + a\right)\right)\right)} \]

   if -1.11999999999999993e85 < x < 2.2e-146

   1. Initial program 92.3%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   2. Taylor expanded in x around 0 80.8%

      \[\leadsto 2 \cdot \color{blue}{\left(t \cdot z - c \cdot \left(i \cdot \left(c \cdot b + a\right)\right)\right)} \]
3. Recombined 2 regimes into one program.

4. Final simplification 79.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -1.12 \cdot 10^{+85} \lor \neg \left(x \leq 2.2 \cdot 10^{-146}\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(z \cdot t - c \cdot \left(\left(a + b \cdot c\right) \cdot i\right)\right)\\ \end{array} \]

Alternative 5: 86.4% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;c \leq -6 \cdot 10^{+79} \lor \neg \left(c \leq 5.2 \cdot 10^{+99}\right):\\ \;\;\;\;2 \cdot \left(z \cdot t - c \cdot \left(\left(a + b \cdot c\right) \cdot i\right)\right)\\ \mathbf{else}:\\ \;\;\;\;2 \cdot \left(\left(z \cdot t + x \cdot y\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+79) (not (<= c 5.2e+99)))
   (* 2.0 (- (* z t) (* c (* (+ a (* b c)) i))))
   (* 2.0 (- (+ (* z t) (* x y)) (* 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+79) || !(c <= 5.2e+99)) {
		tmp = 2.0 * ((z * t) - (c * ((a + (b * c)) * i)));
	} else {
		tmp = 2.0 * (((z * t) + (x * y)) - (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+79)) .or. (.not. (c <= 5.2d+99))) then
        tmp = 2.0d0 * ((z * t) - (c * ((a + (b * c)) * i)))
    else
        tmp = 2.0d0 * (((z * t) + (x * y)) - (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+79) || !(c <= 5.2e+99)) {
		tmp = 2.0 * ((z * t) - (c * ((a + (b * c)) * i)));
	} else {
		tmp = 2.0 * (((z * t) + (x * y)) - (i * (a * c)));
	}
	return tmp;
}

Python

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

Julia

function code(x, y, z, t, a, b, c, i)
	tmp = 0.0
	if ((c <= -6e+79) || !(c <= 5.2e+99))
		tmp = Float64(2.0 * Float64(Float64(z * t) - Float64(c * Float64(Float64(a + Float64(b * c)) * i))));
	else
		tmp = Float64(2.0 * Float64(Float64(Float64(z * t) + Float64(x * y)) - 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+79) || ~((c <= 5.2e+99)))
		tmp = 2.0 * ((z * t) - (c * ((a + (b * c)) * i)));
	else
		tmp = 2.0 * (((z * t) + (x * y)) - (i * (a * c)));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if c < -5.99999999999999948e79 or 5.1999999999999999e99 < c

   1. Initial program 81.1%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   2. Taylor expanded in x around 0 88.0%

      \[\leadsto 2 \cdot \color{blue}{\left(t \cdot z - c \cdot \left(i \cdot \left(c \cdot b + a\right)\right)\right)} \]

   if -5.99999999999999948e79 < c < 5.1999999999999999e99

   1. Initial program 97.1%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   2. Taylor expanded in a around inf 90.8%

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

4. Final simplification 89.7%

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

Alternative 6: 70.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -3 \cdot 10^{+103}:\\ \;\;\;\;2 \cdot \left(x \cdot y - c \cdot \left(a \cdot i\right)\right)\\ \mathbf{elif}\;x \leq 4.5 \cdot 10^{-84}:\\ \;\;\;\;2 \cdot \left(z \cdot t - c \cdot \left(\left(a + b \cdot c\right) \cdot i\right)\right)\\ \mathbf{else}:\\ \;\;\;\;2 \cdot \left(x \cdot y - c \cdot \left(c \cdot \left(b \cdot i\right)\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (if (<= x -3e+103)
   (* 2.0 (- (* x y) (* c (* a i))))
   (if (<= x 4.5e-84)
     (* 2.0 (- (* z t) (* c (* (+ a (* b c)) i))))
     (* 2.0 (- (* x y) (* c (* c (* b i))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double tmp;
	if (x <= -3e+103) {
		tmp = 2.0 * ((x * y) - (c * (a * i)));
	} else if (x <= 4.5e-84) {
		tmp = 2.0 * ((z * t) - (c * ((a + (b * c)) * i)));
	} else {
		tmp = 2.0 * ((x * y) - (c * (c * (b * 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 <= (-3d+103)) then
        tmp = 2.0d0 * ((x * y) - (c * (a * i)))
    else if (x <= 4.5d-84) then
        tmp = 2.0d0 * ((z * t) - (c * ((a + (b * c)) * i)))
    else
        tmp = 2.0d0 * ((x * y) - (c * (c * (b * 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 <= -3e+103) {
		tmp = 2.0 * ((x * y) - (c * (a * i)));
	} else if (x <= 4.5e-84) {
		tmp = 2.0 * ((z * t) - (c * ((a + (b * c)) * i)));
	} else {
		tmp = 2.0 * ((x * y) - (c * (c * (b * i))));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	tmp = 0
	if x <= -3e+103:
		tmp = 2.0 * ((x * y) - (c * (a * i)))
	elif x <= 4.5e-84:
		tmp = 2.0 * ((z * t) - (c * ((a + (b * c)) * i)))
	else:
		tmp = 2.0 * ((x * y) - (c * (c * (b * i))))
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	tmp = 0.0
	if (x <= -3e+103)
		tmp = Float64(2.0 * Float64(Float64(x * y) - Float64(c * Float64(a * i))));
	elseif (x <= 4.5e-84)
		tmp = Float64(2.0 * Float64(Float64(z * t) - Float64(c * Float64(Float64(a + Float64(b * c)) * i))));
	else
		tmp = Float64(2.0 * Float64(Float64(x * y) - Float64(c * Float64(c * Float64(b * i)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	tmp = 0.0;
	if (x <= -3e+103)
		tmp = 2.0 * ((x * y) - (c * (a * i)));
	elseif (x <= 4.5e-84)
		tmp = 2.0 * ((z * t) - (c * ((a + (b * c)) * i)));
	else
		tmp = 2.0 * ((x * y) - (c * (c * (b * i))));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if x < -3e103

   1. Initial program 91.9%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   2. Taylor expanded in z around 0 81.1%

      \[\leadsto 2 \cdot \color{blue}{\left(y \cdot x - c \cdot \left(i \cdot \left(c \cdot b + a\right)\right)\right)} \]

   3. Taylor expanded in c around 0 75.0%

      \[\leadsto 2 \cdot \left(y \cdot x - c \cdot \color{blue}{\left(a \cdot i\right)}\right) \]
   4. Step-by-step derivation

      1. *-commutative 75.0%

         \[\leadsto 2 \cdot \left(y \cdot x - c \cdot \color{blue}{\left(i \cdot a\right)}\right) \]

   5. Simplified 75.0%

      \[\leadsto 2 \cdot \left(y \cdot x - c \cdot \color{blue}{\left(i \cdot a\right)}\right) \]

   if -3e103 < x < 4.50000000000000016e-84

   1. Initial program 92.0%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   2. Taylor expanded in x around 0 81.4%

      \[\leadsto 2 \cdot \color{blue}{\left(t \cdot z - c \cdot \left(i \cdot \left(c \cdot b + a\right)\right)\right)} \]

   if 4.50000000000000016e-84 < x

   1. Initial program 88.7%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   2. Taylor expanded in z around 0 76.8%

      \[\leadsto 2 \cdot \color{blue}{\left(y \cdot x - c \cdot \left(i \cdot \left(c \cdot b + a\right)\right)\right)} \]

   3. Taylor expanded in c around inf 64.0%

      \[\leadsto 2 \cdot \left(y \cdot x - c \cdot \color{blue}{\left(c \cdot \left(i \cdot b\right)\right)}\right) \]
3. Recombined 3 regimes into one program.

4. Final simplification 74.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -3 \cdot 10^{+103}:\\ \;\;\;\;2 \cdot \left(x \cdot y - c \cdot \left(a \cdot i\right)\right)\\ \mathbf{elif}\;x \leq 4.5 \cdot 10^{-84}:\\ \;\;\;\;2 \cdot \left(z \cdot t - c \cdot \left(\left(a + b \cdot c\right) \cdot i\right)\right)\\ \mathbf{else}:\\ \;\;\;\;2 \cdot \left(x \cdot y - c \cdot \left(c \cdot \left(b \cdot i\right)\right)\right)\\ \end{array} \]

Alternative 7: 94.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ 2 \cdot \left(\left(z \cdot t + x \cdot y\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 (- (+ (* z t) (* x y)) (* (+ 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 * (((z * t) + (x * y)) - ((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 * (((z * t) + (x * y)) - ((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 * (((z * t) + (x * y)) - ((a + (b * c)) * (c * i)));
}

Python

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

Julia

function code(x, y, z, t, a, b, c, i)
	return Float64(2.0 * Float64(Float64(Float64(z * t) + Float64(x * y)) - 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 * (((z * t) + (x * y)) - ((a + (b * c)) * (c * i)));
end

Wolfram

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

Derivation

1. Initial program 91.0%

   \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]
2. Step-by-step derivation

   1. associate-*l* 95.3%

      \[\leadsto 2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \color{blue}{\left(a + b \cdot c\right) \cdot \left(c \cdot i\right)}\right) \]

   2. fma-def 95.7%

      \[\leadsto 2 \cdot \left(\color{blue}{\mathsf{fma}\left(x, y, z \cdot t\right)} - \left(a + b \cdot c\right) \cdot \left(c \cdot i\right)\right) \]

3. Simplified 95.7%

   \[\leadsto \color{blue}{2 \cdot \left(\mathsf{fma}\left(x, y, z \cdot t\right) - \left(a + b \cdot c\right) \cdot \left(c \cdot i\right)\right)} \]
4. Step-by-step derivation

   1. fma-def 95.3%

      \[\leadsto 2 \cdot \left(\color{blue}{\left(x \cdot y + z \cdot t\right)} - \left(a + b \cdot c\right) \cdot \left(c \cdot i\right)\right) \]

   2. +-commutative 95.3%

      \[\leadsto 2 \cdot \left(\color{blue}{\left(z \cdot t + x \cdot y\right)} - \left(a + b \cdot c\right) \cdot \left(c \cdot i\right)\right) \]

5. Applied egg-rr 95.3%

   \[\leadsto 2 \cdot \left(\color{blue}{\left(z \cdot t + x \cdot y\right)} - \left(a + b \cdot c\right) \cdot \left(c \cdot i\right)\right) \]

6. Final simplification 95.3%

   \[\leadsto 2 \cdot \left(\left(z \cdot t + x \cdot y\right) - \left(a + b \cdot c\right) \cdot \left(c \cdot i\right)\right) \]

Alternative 8: 60.2% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -2.3 \cdot 10^{+40}:\\ \;\;\;\;2 \cdot \left(z \cdot t + x \cdot y\right)\\ \mathbf{elif}\;x \leq 1.02 \cdot 10^{-135}:\\ \;\;\;\;2 \cdot \left(z \cdot t - b \cdot \left(c \cdot \left(c \cdot i\right)\right)\right)\\ \mathbf{else}:\\ \;\;\;\;2 \cdot \left(x \cdot y - 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 (<= x -2.3e+40)
   (* 2.0 (+ (* z t) (* x y)))
   (if (<= x 1.02e-135)
     (* 2.0 (- (* z t) (* b (* c (* c i)))))
     (* 2.0 (- (* x y) (* 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 (x <= -2.3e+40) {
		tmp = 2.0 * ((z * t) + (x * y));
	} else if (x <= 1.02e-135) {
		tmp = 2.0 * ((z * t) - (b * (c * (c * i))));
	} else {
		tmp = 2.0 * ((x * y) - (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 (x <= (-2.3d+40)) then
        tmp = 2.0d0 * ((z * t) + (x * y))
    else if (x <= 1.02d-135) then
        tmp = 2.0d0 * ((z * t) - (b * (c * (c * i))))
    else
        tmp = 2.0d0 * ((x * y) - (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 (x <= -2.3e+40) {
		tmp = 2.0 * ((z * t) + (x * y));
	} else if (x <= 1.02e-135) {
		tmp = 2.0 * ((z * t) - (b * (c * (c * i))));
	} else {
		tmp = 2.0 * ((x * y) - (i * (a * c)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	tmp = 0
	if x <= -2.3e+40:
		tmp = 2.0 * ((z * t) + (x * y))
	elif x <= 1.02e-135:
		tmp = 2.0 * ((z * t) - (b * (c * (c * i))))
	else:
		tmp = 2.0 * ((x * y) - (i * (a * c)))
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	tmp = 0.0
	if (x <= -2.3e+40)
		tmp = Float64(2.0 * Float64(Float64(z * t) + Float64(x * y)));
	elseif (x <= 1.02e-135)
		tmp = Float64(2.0 * Float64(Float64(z * t) - Float64(b * Float64(c * Float64(c * i)))));
	else
		tmp = Float64(2.0 * Float64(Float64(x * y) - 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 (x <= -2.3e+40)
		tmp = 2.0 * ((z * t) + (x * y));
	elseif (x <= 1.02e-135)
		tmp = 2.0 * ((z * t) - (b * (c * (c * i))));
	else
		tmp = 2.0 * ((x * y) - (i * (a * c)));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if x < -2.29999999999999994e40

   1. Initial program 90.0%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   2. Taylor expanded in c around 0 71.8%

      \[\leadsto 2 \cdot \color{blue}{\left(y \cdot x + t \cdot z\right)} \]

   if -2.29999999999999994e40 < x < 1.01999999999999994e-135

   1. Initial program 93.5%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   2. Taylor expanded in a around 0 77.9%

      \[\leadsto 2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \color{blue}{\left({c}^{2} \cdot b\right)} \cdot i\right) \]
   3. Step-by-step derivation

      1. unpow2 77.9%

         \[\leadsto 2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\color{blue}{\left(c \cdot c\right)} \cdot b\right) \cdot i\right) \]

      2. associate-*r* 83.4%

         \[\leadsto 2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \color{blue}{\left(c \cdot \left(c \cdot b\right)\right)} \cdot i\right) \]

   4. Simplified 83.4%

      \[\leadsto 2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \color{blue}{\left(c \cdot \left(c \cdot b\right)\right)} \cdot i\right) \]

   5. Taylor expanded in x around 0 70.4%

      \[\leadsto 2 \cdot \color{blue}{\left(t \cdot z - {c}^{2} \cdot \left(i \cdot b\right)\right)} \]
   6. Step-by-step derivation

      1. unpow2 70.4%

         \[\leadsto 2 \cdot \left(t \cdot z - \color{blue}{\left(c \cdot c\right)} \cdot \left(i \cdot b\right)\right) \]

      2. associate-*r* 71.5%

         \[\leadsto 2 \cdot \left(t \cdot z - \color{blue}{\left(\left(c \cdot c\right) \cdot i\right) \cdot b}\right) \]

      3. *-commutative 71.5%

         \[\leadsto 2 \cdot \left(t \cdot z - \color{blue}{b \cdot \left(\left(c \cdot c\right) \cdot i\right)}\right) \]

      4. associate-*l* 77.8%

         \[\leadsto 2 \cdot \left(t \cdot z - b \cdot \color{blue}{\left(c \cdot \left(c \cdot i\right)\right)}\right) \]

   7. Simplified 77.8%

      \[\leadsto 2 \cdot \color{blue}{\left(t \cdot z - b \cdot \left(c \cdot \left(c \cdot i\right)\right)\right)} \]

   if 1.01999999999999994e-135 < x

   1. Initial program 88.6%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   2. Taylor expanded in a around inf 75.7%

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

   3. Taylor expanded in z around 0 59.2%

      \[\leadsto 2 \cdot \color{blue}{\left(y \cdot x - c \cdot \left(a \cdot i\right)\right)} \]
   4. Step-by-step derivation

      1. associate-*r* 57.2%

         \[\leadsto 2 \cdot \left(y \cdot x - \color{blue}{\left(c \cdot a\right) \cdot i}\right) \]

   5. Simplified 57.2%

      \[\leadsto 2 \cdot \color{blue}{\left(y \cdot x - \left(c \cdot a\right) \cdot i\right)} \]
3. Recombined 3 regimes into one program.

4. Final simplification 69.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -2.3 \cdot 10^{+40}:\\ \;\;\;\;2 \cdot \left(z \cdot t + x \cdot y\right)\\ \mathbf{elif}\;x \leq 1.02 \cdot 10^{-135}:\\ \;\;\;\;2 \cdot \left(z \cdot t - b \cdot \left(c \cdot \left(c \cdot i\right)\right)\right)\\ \mathbf{else}:\\ \;\;\;\;2 \cdot \left(x \cdot y - i \cdot \left(a \cdot c\right)\right)\\ \end{array} \]

Alternative 9: 74.2% accurate, 1.3× speedup

Math

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

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (if (or (<= c -9.6e+92) (not (<= c 1.6e+100)))
   (* -2.0 (* c (* (+ a (* b c)) i)))
   (* 2.0 (+ (* z t) (* x y)))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double tmp;
	if ((c <= -9.6e+92) || !(c <= 1.6e+100)) {
		tmp = -2.0 * (c * ((a + (b * c)) * i));
	} else {
		tmp = 2.0 * ((z * t) + (x * y));
	}
	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 <= (-9.6d+92)) .or. (.not. (c <= 1.6d+100))) then
        tmp = (-2.0d0) * (c * ((a + (b * c)) * i))
    else
        tmp = 2.0d0 * ((z * t) + (x * y))
    end if
    code = tmp
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if c < -9.60000000000000018e92 or 1.5999999999999999e100 < c

   1. Initial program 81.0%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   2. Taylor expanded in z around 0 87.9%

      \[\leadsto 2 \cdot \color{blue}{\left(y \cdot x - c \cdot \left(i \cdot \left(c \cdot b + a\right)\right)\right)} \]

   3. Taylor expanded in y around 0 84.2%

      \[\leadsto \color{blue}{-2 \cdot \left(c \cdot \left(i \cdot \left(c \cdot b + a\right)\right)\right)} \]

   if -9.60000000000000018e92 < c < 1.5999999999999999e100

   1. Initial program 96.6%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   2. Taylor expanded in c around 0 74.4%

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

4. Final simplification 77.9%

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

Alternative 10: 68.8% accurate, 1.4× speedup

Math

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

FPCore

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

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double tmp;
	if ((c <= -4e+67) || !(c <= 1.15e+107)) {
		tmp = -2.0 * ((b * i) * (c * c));
	} else {
		tmp = 2.0 * ((z * t) + (x * y));
	}
	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 <= (-4d+67)) .or. (.not. (c <= 1.15d+107))) then
        tmp = (-2.0d0) * ((b * i) * (c * c))
    else
        tmp = 2.0d0 * ((z * t) + (x * y))
    end if
    code = tmp
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if c < -3.99999999999999993e67 or 1.15e107 < c

   1. Initial program 81.3%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   2. Taylor expanded in z around 0 84.8%

      \[\leadsto 2 \cdot \color{blue}{\left(y \cdot x - c \cdot \left(i \cdot \left(c \cdot b + a\right)\right)\right)} \]

   3. Taylor expanded in c around inf 68.7%

      \[\leadsto \color{blue}{-2 \cdot \left({c}^{2} \cdot \left(i \cdot b\right)\right)} \]
   4. Step-by-step derivation

      1. *-commutative 68.7%

         \[\leadsto \color{blue}{\left({c}^{2} \cdot \left(i \cdot b\right)\right) \cdot -2} \]

      2. associate-*r* 67.0%

         \[\leadsto \color{blue}{\left(\left({c}^{2} \cdot i\right) \cdot b\right)} \cdot -2 \]

      3. associate-*r* 68.7%

         \[\leadsto \color{blue}{\left({c}^{2} \cdot \left(i \cdot b\right)\right)} \cdot -2 \]

      4. unpow2 68.7%

         \[\leadsto \left(\color{blue}{\left(c \cdot c\right)} \cdot \left(i \cdot b\right)\right) \cdot -2 \]

   5. Simplified 68.7%

      \[\leadsto \color{blue}{\left(\left(c \cdot c\right) \cdot \left(i \cdot b\right)\right) \cdot -2} \]

   if -3.99999999999999993e67 < c < 1.15e107

   1. Initial program 97.0%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   2. Taylor expanded in c around 0 75.1%

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

4. Final simplification 72.6%

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

Alternative 11: 69.8% accurate, 1.4× speedup

Math

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

FPCore

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

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double tmp;
	if ((c <= -1.95e+138) || !(c <= 4.4e+107)) {
		tmp = -2.0 * (b * (c * (c * i)));
	} else {
		tmp = 2.0 * ((z * t) + (x * y));
	}
	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 <= (-1.95d+138)) .or. (.not. (c <= 4.4d+107))) then
        tmp = (-2.0d0) * (b * (c * (c * i)))
    else
        tmp = 2.0d0 * ((z * t) + (x * y))
    end if
    code = tmp
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if c < -1.9499999999999999e138 or 4.4e107 < c

   1. Initial program 81.8%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   2. Taylor expanded in z around 0 88.6%

      \[\leadsto 2 \cdot \color{blue}{\left(y \cdot x - c \cdot \left(i \cdot \left(c \cdot b + a\right)\right)\right)} \]

   3. Taylor expanded in c around inf 73.3%

      \[\leadsto \color{blue}{-2 \cdot \left({c}^{2} \cdot \left(i \cdot b\right)\right)} \]
   4. Step-by-step derivation

      1. *-commutative 73.3%

         \[\leadsto \color{blue}{\left({c}^{2} \cdot \left(i \cdot b\right)\right) \cdot -2} \]

      2. associate-*r* 73.6%

         \[\leadsto \color{blue}{\left(\left({c}^{2} \cdot i\right) \cdot b\right)} \cdot -2 \]

      3. unpow2 73.6%

         \[\leadsto \left(\left(\color{blue}{\left(c \cdot c\right)} \cdot i\right) \cdot b\right) \cdot -2 \]

      4. sqr-neg 73.6%

         \[\leadsto \left(\left(\color{blue}{\left(\left(-c\right) \cdot \left(-c\right)\right)} \cdot i\right) \cdot b\right) \cdot -2 \]

      5. sqr-neg 73.6%

         \[\leadsto \left(\left(\color{blue}{\left(c \cdot c\right)} \cdot i\right) \cdot b\right) \cdot -2 \]

      6. associate-*l* 77.1%

         \[\leadsto \left(\color{blue}{\left(c \cdot \left(c \cdot i\right)\right)} \cdot b\right) \cdot -2 \]

   5. Simplified 77.1%

      \[\leadsto \color{blue}{\left(\left(c \cdot \left(c \cdot i\right)\right) \cdot b\right) \cdot -2} \]

   if -1.9499999999999999e138 < c < 4.4e107

   1. Initial program 95.1%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   2. Taylor expanded in c around 0 71.7%

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

4. Final simplification 73.4%

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

Alternative 12: 58.0% accurate, 1.4× speedup

Math

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

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (if (<= a -3.8e+175)
   (* 2.0 (* (* c i) (- a)))
   (if (<= a 3e+217) (* 2.0 (+ (* z t) (* x y))) (* -2.0 (* c (* a i))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double tmp;
	if (a <= -3.8e+175) {
		tmp = 2.0 * ((c * i) * -a);
	} else if (a <= 3e+217) {
		tmp = 2.0 * ((z * t) + (x * y));
	} else {
		tmp = -2.0 * (c * (a * 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 (a <= (-3.8d+175)) then
        tmp = 2.0d0 * ((c * i) * -a)
    else if (a <= 3d+217) then
        tmp = 2.0d0 * ((z * t) + (x * y))
    else
        tmp = (-2.0d0) * (c * (a * 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 (a <= -3.8e+175) {
		tmp = 2.0 * ((c * i) * -a);
	} else if (a <= 3e+217) {
		tmp = 2.0 * ((z * t) + (x * y));
	} else {
		tmp = -2.0 * (c * (a * i));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	tmp = 0
	if a <= -3.8e+175:
		tmp = 2.0 * ((c * i) * -a)
	elif a <= 3e+217:
		tmp = 2.0 * ((z * t) + (x * y))
	else:
		tmp = -2.0 * (c * (a * i))
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	tmp = 0.0
	if (a <= -3.8e+175)
		tmp = Float64(2.0 * Float64(Float64(c * i) * Float64(-a)));
	elseif (a <= 3e+217)
		tmp = Float64(2.0 * Float64(Float64(z * t) + Float64(x * y)));
	else
		tmp = Float64(-2.0 * Float64(c * Float64(a * i)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	tmp = 0.0;
	if (a <= -3.8e+175)
		tmp = 2.0 * ((c * i) * -a);
	elseif (a <= 3e+217)
		tmp = 2.0 * ((z * t) + (x * y));
	else
		tmp = -2.0 * (c * (a * i));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if a < -3.7999999999999997e175

   1. Initial program 79.9%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]
   2. Step-by-step derivation

      1. associate-*l* 95.7%

         \[\leadsto 2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \color{blue}{\left(a + b \cdot c\right) \cdot \left(c \cdot i\right)}\right) \]

      2. fma-def 95.7%

         \[\leadsto 2 \cdot \left(\color{blue}{\mathsf{fma}\left(x, y, z \cdot t\right)} - \left(a + b \cdot c\right) \cdot \left(c \cdot i\right)\right) \]

   3. Simplified 95.7%

      \[\leadsto \color{blue}{2 \cdot \left(\mathsf{fma}\left(x, y, z \cdot t\right) - \left(a + b \cdot c\right) \cdot \left(c \cdot i\right)\right)} \]
   4. Step-by-step derivation

      1. fma-def 95.7%

         \[\leadsto 2 \cdot \left(\color{blue}{\left(x \cdot y + z \cdot t\right)} - \left(a + b \cdot c\right) \cdot \left(c \cdot i\right)\right) \]

      2. +-commutative 95.7%

         \[\leadsto 2 \cdot \left(\color{blue}{\left(z \cdot t + x \cdot y\right)} - \left(a + b \cdot c\right) \cdot \left(c \cdot i\right)\right) \]

   5. Applied egg-rr 95.7%

      \[\leadsto 2 \cdot \left(\color{blue}{\left(z \cdot t + x \cdot y\right)} - \left(a + b \cdot c\right) \cdot \left(c \cdot i\right)\right) \]

   6. Taylor expanded in a around inf 55.2%

      \[\leadsto 2 \cdot \color{blue}{\left(-1 \cdot \left(c \cdot \left(i \cdot a\right)\right)\right)} \]
   7. Step-by-step derivation

      1. mul-1-neg 55.2%

         \[\leadsto 2 \cdot \color{blue}{\left(-c \cdot \left(i \cdot a\right)\right)} \]

      2. associate-*r* 63.0%

         \[\leadsto 2 \cdot \left(-\color{blue}{\left(c \cdot i\right) \cdot a}\right) \]

      3. *-commutative 63.0%

         \[\leadsto 2 \cdot \left(-\color{blue}{a \cdot \left(c \cdot i\right)}\right) \]

      4. distribute-rgt-neg-in 63.0%

         \[\leadsto 2 \cdot \color{blue}{\left(a \cdot \left(-c \cdot i\right)\right)} \]

      5. distribute-rgt-neg-in 63.0%

         \[\leadsto 2 \cdot \left(a \cdot \color{blue}{\left(c \cdot \left(-i\right)\right)}\right) \]

   8. Simplified 63.0%

      \[\leadsto 2 \cdot \color{blue}{\left(a \cdot \left(c \cdot \left(-i\right)\right)\right)} \]

   if -3.7999999999999997e175 < a < 2.99999999999999976e217

   1. Initial program 92.0%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   2. Taylor expanded in c around 0 64.8%

      \[\leadsto 2 \cdot \color{blue}{\left(y \cdot x + t \cdot z\right)} \]

   if 2.99999999999999976e217 < a

   1. Initial program 92.8%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   2. Taylor expanded in z around 0 92.3%

      \[\leadsto 2 \cdot \color{blue}{\left(y \cdot x - c \cdot \left(i \cdot \left(c \cdot b + a\right)\right)\right)} \]

   3. Taylor expanded in a around inf 66.6%

      \[\leadsto \color{blue}{-2 \cdot \left(c \cdot \left(i \cdot a\right)\right)} \]
3. Recombined 3 regimes into one program.

4. Final simplification 64.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;a \leq -3.8 \cdot 10^{+175}:\\ \;\;\;\;2 \cdot \left(\left(c \cdot i\right) \cdot \left(-a\right)\right)\\ \mathbf{elif}\;a \leq 3 \cdot 10^{+217}:\\ \;\;\;\;2 \cdot \left(z \cdot t + x \cdot y\right)\\ \mathbf{else}:\\ \;\;\;\;-2 \cdot \left(c \cdot \left(a \cdot i\right)\right)\\ \end{array} \]

Alternative 13: 40.1% accurate, 2.1× speedup

Math

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

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (if (or (<= t -3.5e-10) (not (<= t 1.25e+128)))
   (* 2.0 (* z t))
   (* 2.0 (* x y))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double tmp;
	if ((t <= -3.5e-10) || !(t <= 1.25e+128)) {
		tmp = 2.0 * (z * t);
	} else {
		tmp = 2.0 * (x * y);
	}
	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 ((t <= (-3.5d-10)) .or. (.not. (t <= 1.25d+128))) then
        tmp = 2.0d0 * (z * t)
    else
        tmp = 2.0d0 * (x * y)
    end if
    code = tmp
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if t < -3.4999999999999998e-10 or 1.25e128 < t

   1. Initial program 86.4%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   2. Taylor expanded in z around inf 47.4%

      \[\leadsto 2 \cdot \color{blue}{\left(t \cdot z\right)} \]

   if -3.4999999999999998e-10 < t < 1.25e128

   1. Initial program 94.3%

      \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

   2. Taylor expanded in x around inf 37.6%

      \[\leadsto 2 \cdot \color{blue}{\left(y \cdot x\right)} \]
3. Recombined 2 regimes into one program.

4. Final simplification 41.7%

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

Alternative 14: 29.2% 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

1. Initial program 91.0%

   \[2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right) \]

2. Taylor expanded in z around inf 30.7%

   \[\leadsto 2 \cdot \color{blue}{\left(t \cdot z\right)} \]

3. Final simplification 30.7%

   \[\leadsto 2 \cdot \left(z \cdot t\right) \]

Developer target: 94.2% 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 2023229 
(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))))