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

Percentage Accurate: 90.4% → 96.5%

Time: 13.2s

Alternatives: 13

Speedup: 0.5×

• 46.8% 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.4% 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: 96.5% accurate, 0.1× speedup

Math

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

FPCore

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

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 tmp;
	if ((((x * y) + (z * t)) - ((c * t_1) * i)) <= ((double) INFINITY)) {
		tmp = 2.0 * (fma(x, y, (z * t)) - (t_1 * (c * i)));
	} else {
		tmp = 2.0 * ((t_1 * i) * -c);
	}
	return tmp;
}

Julia

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

Wolfram

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

Derivation

1. Split input into 2 regimes

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

   1. Initial program 94.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+ 94.9%

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

      2. *-commutative 94.9%

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

      3. associate--l+ 94.9%

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

      4. associate--l+ 94.9%

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

      5. *-commutative 94.9%

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

      6. associate--l+ 94.9%

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

      7. fma-def 94.9%

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

      8. associate-*l* 98.3%

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

   3. Simplified 98.3%

      \[\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)} \]

   if +inf.0 < (-.f64 (+.f64 (*.f64 x y) (*.f64 z t)) (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i))

   1. Initial program 0.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 i around inf 64.3%

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

4. Final simplification 96.5%

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

Alternative 2: 94.5% 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 := t_1 \cdot i\\ \mathbf{if}\;t_2 \leq -\infty:\\ \;\;\;\;2 \cdot \left(z \cdot t - c \cdot t_3\right)\\ \mathbf{elif}\;t_2 \leq 10^{+260}:\\ \;\;\;\;\left(\left(x \cdot y + z \cdot t\right) - t_2\right) \cdot 2\\ \mathbf{else}:\\ \;\;\;\;2 \cdot \left(t_3 \cdot \left(-c\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 (* (* c t_1) i)) (t_3 (* t_1 i)))
   (if (<= t_2 (- INFINITY))
     (* 2.0 (- (* z t) (* c t_3)))
     (if (<= t_2 1e+260)
       (* (- (+ (* x y) (* z t)) t_2) 2.0)
       (* 2.0 (* t_3 (- c)))))))

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 = t_1 * i;
	double tmp;
	if (t_2 <= -((double) INFINITY)) {
		tmp = 2.0 * ((z * t) - (c * t_3));
	} else if (t_2 <= 1e+260) {
		tmp = (((x * y) + (z * t)) - t_2) * 2.0;
	} else {
		tmp = 2.0 * (t_3 * -c);
	}
	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 = t_1 * i;
	double tmp;
	if (t_2 <= -Double.POSITIVE_INFINITY) {
		tmp = 2.0 * ((z * t) - (c * t_3));
	} else if (t_2 <= 1e+260) {
		tmp = (((x * y) + (z * t)) - t_2) * 2.0;
	} else {
		tmp = 2.0 * (t_3 * -c);
	}
	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 = t_1 * i
	tmp = 0
	if t_2 <= -math.inf:
		tmp = 2.0 * ((z * t) - (c * t_3))
	elif t_2 <= 1e+260:
		tmp = (((x * y) + (z * t)) - t_2) * 2.0
	else:
		tmp = 2.0 * (t_3 * -c)
	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(t_1 * i)
	tmp = 0.0
	if (t_2 <= Float64(-Inf))
		tmp = Float64(2.0 * Float64(Float64(z * t) - Float64(c * t_3)));
	elseif (t_2 <= 1e+260)
		tmp = Float64(Float64(Float64(Float64(x * y) + Float64(z * t)) - t_2) * 2.0);
	else
		tmp = Float64(2.0 * Float64(t_3 * Float64(-c)));
	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 = t_1 * i;
	tmp = 0.0;
	if (t_2 <= -Inf)
		tmp = 2.0 * ((z * t) - (c * t_3));
	elseif (t_2 <= 1e+260)
		tmp = (((x * y) + (z * t)) - t_2) * 2.0;
	else
		tmp = 2.0 * (t_3 * -c);
	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[(t$95$1 * i), $MachinePrecision]}, If[LessEqual[t$95$2, (-Infinity)], N[(2.0 * N[(N[(z * t), $MachinePrecision] - N[(c * t$95$3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 1e+260], N[(N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] - t$95$2), $MachinePrecision] * 2.0), $MachinePrecision], N[(2.0 * N[(t$95$3 * (-c)), $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 80.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 94.3%

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

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

   1. Initial program 99.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) \]

   if 1.00000000000000007e260 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i)

   1. Initial program 67.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 i around inf 85.6%

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

4. Final simplification 96.1%

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

Alternative 3: 96.5% 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(\left(t_1 \cdot i\right) \cdot \left(-c\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 (* (* t_1 i) (- c))))))

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 * ((t_1 * i) * -c);
	}
	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 * ((t_1 * i) * -c);
	}
	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 * ((t_1 * i) * -c)
	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(t_1 * i) * Float64(-c)));
	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 * ((t_1 * i) * -c);
	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[(t$95$1 * i), $MachinePrecision] * (-c)), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 2 regimes

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

   1. Initial program 94.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+ 94.9%

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

      2. *-commutative 94.9%

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

      3. associate--l+ 94.9%

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

      4. associate--l+ 94.9%

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

      5. *-commutative 94.9%

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

      6. associate--l+ 94.9%

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

      7. fma-def 94.9%

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

      8. associate-*l* 98.3%

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

   3. Simplified 98.3%

      \[\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 98.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 98.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 98.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) \]

   if +inf.0 < (-.f64 (+.f64 (*.f64 x y) (*.f64 z t)) (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i))

   1. Initial program 0.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 i around inf 64.3%

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

4. Final simplification 96.4%

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

Alternative 4: 74.7% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(x \cdot y + z \cdot t\right) \cdot 2\\ t_2 := 2 \cdot \left(\left(\left(a + b \cdot c\right) \cdot i\right) \cdot \left(-c\right)\right)\\ \mathbf{if}\;c \leq -8.2 \cdot 10^{-22}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;c \leq 3.8 \cdot 10^{+43}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;c \leq 3.95 \cdot 10^{+90}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;c \leq 4.7 \cdot 10^{+104}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;c \leq 3.7 \cdot 10^{+154}:\\ \;\;\;\;2 \cdot \left(z \cdot t - c \cdot \left(b \cdot \left(c \cdot i\right)\right)\right)\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (* (+ (* x y) (* z t)) 2.0))
        (t_2 (* 2.0 (* (* (+ a (* b c)) i) (- c)))))
   (if (<= c -8.2e-22)
     t_2
     (if (<= c 3.8e+43)
       t_1
       (if (<= c 3.95e+90)
         t_2
         (if (<= c 4.7e+104)
           t_1
           (if (<= c 3.7e+154)
             (* 2.0 (- (* z t) (* c (* b (* c i)))))
             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)) * 2.0;
	double t_2 = 2.0 * (((a + (b * c)) * i) * -c);
	double tmp;
	if (c <= -8.2e-22) {
		tmp = t_2;
	} else if (c <= 3.8e+43) {
		tmp = t_1;
	} else if (c <= 3.95e+90) {
		tmp = t_2;
	} else if (c <= 4.7e+104) {
		tmp = t_1;
	} else if (c <= 3.7e+154) {
		tmp = 2.0 * ((z * t) - (c * (b * (c * i))));
	} 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 = ((x * y) + (z * t)) * 2.0d0
    t_2 = 2.0d0 * (((a + (b * c)) * i) * -c)
    if (c <= (-8.2d-22)) then
        tmp = t_2
    else if (c <= 3.8d+43) then
        tmp = t_1
    else if (c <= 3.95d+90) then
        tmp = t_2
    else if (c <= 4.7d+104) then
        tmp = t_1
    else if (c <= 3.7d+154) then
        tmp = 2.0d0 * ((z * t) - (c * (b * (c * i))))
    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 = ((x * y) + (z * t)) * 2.0;
	double t_2 = 2.0 * (((a + (b * c)) * i) * -c);
	double tmp;
	if (c <= -8.2e-22) {
		tmp = t_2;
	} else if (c <= 3.8e+43) {
		tmp = t_1;
	} else if (c <= 3.95e+90) {
		tmp = t_2;
	} else if (c <= 4.7e+104) {
		tmp = t_1;
	} else if (c <= 3.7e+154) {
		tmp = 2.0 * ((z * t) - (c * (b * (c * i))));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = ((x * y) + (z * t)) * 2.0
	t_2 = 2.0 * (((a + (b * c)) * i) * -c)
	tmp = 0
	if c <= -8.2e-22:
		tmp = t_2
	elif c <= 3.8e+43:
		tmp = t_1
	elif c <= 3.95e+90:
		tmp = t_2
	elif c <= 4.7e+104:
		tmp = t_1
	elif c <= 3.7e+154:
		tmp = 2.0 * ((z * t) - (c * (b * (c * i))))
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(Float64(Float64(x * y) + Float64(z * t)) * 2.0)
	t_2 = Float64(2.0 * Float64(Float64(Float64(a + Float64(b * c)) * i) * Float64(-c)))
	tmp = 0.0
	if (c <= -8.2e-22)
		tmp = t_2;
	elseif (c <= 3.8e+43)
		tmp = t_1;
	elseif (c <= 3.95e+90)
		tmp = t_2;
	elseif (c <= 4.7e+104)
		tmp = t_1;
	elseif (c <= 3.7e+154)
		tmp = Float64(2.0 * Float64(Float64(z * t) - Float64(c * Float64(b * Float64(c * i)))));
	else
		tmp = 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)) * 2.0;
	t_2 = 2.0 * (((a + (b * c)) * i) * -c);
	tmp = 0.0;
	if (c <= -8.2e-22)
		tmp = t_2;
	elseif (c <= 3.8e+43)
		tmp = t_1;
	elseif (c <= 3.95e+90)
		tmp = t_2;
	elseif (c <= 4.7e+104)
		tmp = t_1;
	elseif (c <= 3.7e+154)
		tmp = 2.0 * ((z * t) - (c * (b * (c * i))));
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]}, Block[{t$95$2 = N[(2.0 * N[(N[(N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision] * (-c)), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -8.2e-22], t$95$2, If[LessEqual[c, 3.8e+43], t$95$1, If[LessEqual[c, 3.95e+90], t$95$2, If[LessEqual[c, 4.7e+104], t$95$1, If[LessEqual[c, 3.7e+154], N[(2.0 * N[(N[(z * t), $MachinePrecision] - N[(c * N[(b * N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]

Derivation

1. Split input into 3 regimes

2. if c < -8.1999999999999999e-22 or 3.80000000000000008e43 < c < 3.9499999999999998e90 or 3.69999999999999994e154 < c

   1. Initial program 81.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 i around inf 80.6%

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

   if -8.1999999999999999e-22 < c < 3.80000000000000008e43 or 3.9499999999999998e90 < c < 4.70000000000000017e104

   1. Initial program 97.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 83.2%

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

   if 4.70000000000000017e104 < c < 3.69999999999999994e154

   1. Initial program 85.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 x around 0 92.8%

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

   3. Taylor expanded in a around 0 85.3%

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

4. Final simplification 82.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;c \leq -8.2 \cdot 10^{-22}:\\ \;\;\;\;2 \cdot \left(\left(\left(a + b \cdot c\right) \cdot i\right) \cdot \left(-c\right)\right)\\ \mathbf{elif}\;c \leq 3.8 \cdot 10^{+43}:\\ \;\;\;\;\left(x \cdot y + z \cdot t\right) \cdot 2\\ \mathbf{elif}\;c \leq 3.95 \cdot 10^{+90}:\\ \;\;\;\;2 \cdot \left(\left(\left(a + b \cdot c\right) \cdot i\right) \cdot \left(-c\right)\right)\\ \mathbf{elif}\;c \leq 4.7 \cdot 10^{+104}:\\ \;\;\;\;\left(x \cdot y + z \cdot t\right) \cdot 2\\ \mathbf{elif}\;c \leq 3.7 \cdot 10^{+154}:\\ \;\;\;\;2 \cdot \left(z \cdot t - c \cdot \left(b \cdot \left(c \cdot i\right)\right)\right)\\ \mathbf{else}:\\ \;\;\;\;2 \cdot \left(\left(\left(a + b \cdot c\right) \cdot i\right) \cdot \left(-c\right)\right)\\ \end{array} \]

Alternative 5: 42.8% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(x \cdot y\right) \cdot 2\\ \mathbf{if}\;x \cdot y \leq -2.6 \cdot 10^{+48}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \cdot y \leq 3.7 \cdot 10^{-267}:\\ \;\;\;\;2 \cdot \left(z \cdot t\right)\\ \mathbf{elif}\;x \cdot y \leq 1.22 \cdot 10^{+89}:\\ \;\;\;\;2 \cdot \left(\left(-c\right) \cdot \left(a \cdot i\right)\right)\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (* (* x y) 2.0)))
   (if (<= (* x y) -2.6e+48)
     t_1
     (if (<= (* x y) 3.7e-267)
       (* 2.0 (* z t))
       (if (<= (* x y) 1.22e+89) (* 2.0 (* (- c) (* a i))) t_1)))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (x * y) * 2.0;
	double tmp;
	if ((x * y) <= -2.6e+48) {
		tmp = t_1;
	} else if ((x * y) <= 3.7e-267) {
		tmp = 2.0 * (z * t);
	} else if ((x * y) <= 1.22e+89) {
		tmp = 2.0 * (-c * (a * i));
	} 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 = (x * y) * 2.0d0
    if ((x * y) <= (-2.6d+48)) then
        tmp = t_1
    else if ((x * y) <= 3.7d-267) then
        tmp = 2.0d0 * (z * t)
    else if ((x * y) <= 1.22d+89) then
        tmp = 2.0d0 * (-c * (a * i))
    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 = (x * y) * 2.0;
	double tmp;
	if ((x * y) <= -2.6e+48) {
		tmp = t_1;
	} else if ((x * y) <= 3.7e-267) {
		tmp = 2.0 * (z * t);
	} else if ((x * y) <= 1.22e+89) {
		tmp = 2.0 * (-c * (a * i));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = (x * y) * 2.0
	tmp = 0
	if (x * y) <= -2.6e+48:
		tmp = t_1
	elif (x * y) <= 3.7e-267:
		tmp = 2.0 * (z * t)
	elif (x * y) <= 1.22e+89:
		tmp = 2.0 * (-c * (a * i))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(Float64(x * y) * 2.0)
	tmp = 0.0
	if (Float64(x * y) <= -2.6e+48)
		tmp = t_1;
	elseif (Float64(x * y) <= 3.7e-267)
		tmp = Float64(2.0 * Float64(z * t));
	elseif (Float64(x * y) <= 1.22e+89)
		tmp = Float64(2.0 * Float64(Float64(-c) * Float64(a * i)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = (x * y) * 2.0;
	tmp = 0.0;
	if ((x * y) <= -2.6e+48)
		tmp = t_1;
	elseif ((x * y) <= 3.7e-267)
		tmp = 2.0 * (z * t);
	elseif ((x * y) <= 1.22e+89)
		tmp = 2.0 * (-c * (a * i));
	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[(x * y), $MachinePrecision] * 2.0), $MachinePrecision]}, If[LessEqual[N[(x * y), $MachinePrecision], -2.6e+48], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], 3.7e-267], N[(2.0 * N[(z * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 1.22e+89], N[(2.0 * N[((-c) * N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

Derivation

1. Split input into 3 regimes

2. if (*.f64 x y) < -2.59999999999999995e48 or 1.22e89 < (*.f64 x y)

   1. Initial program 88.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 x around inf 58.1%

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

   if -2.59999999999999995e48 < (*.f64 x y) < 3.69999999999999986e-267

   1. Initial program 93.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 z around inf 47.3%

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

   if 3.69999999999999986e-267 < (*.f64 x y) < 1.22e89

   1. Initial program 87.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 a around inf 40.0%

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

      1. mul-1-neg 40.0%

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

      2. *-commutative 40.0%

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

      3. associate-*l* 34.6%

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

   4. Simplified 34.6%

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

4. Final simplification 48.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \cdot y \leq -2.6 \cdot 10^{+48}:\\ \;\;\;\;\left(x \cdot y\right) \cdot 2\\ \mathbf{elif}\;x \cdot y \leq 3.7 \cdot 10^{-267}:\\ \;\;\;\;2 \cdot \left(z \cdot t\right)\\ \mathbf{elif}\;x \cdot y \leq 1.22 \cdot 10^{+89}:\\ \;\;\;\;2 \cdot \left(\left(-c\right) \cdot \left(a \cdot i\right)\right)\\ \mathbf{else}:\\ \;\;\;\;\left(x \cdot y\right) \cdot 2\\ \end{array} \]

Alternative 6: 42.9% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(x \cdot y\right) \cdot 2\\ \mathbf{if}\;x \cdot y \leq -2.05 \cdot 10^{+48}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \cdot y \leq 1.1 \cdot 10^{-234}:\\ \;\;\;\;2 \cdot \left(z \cdot t\right)\\ \mathbf{elif}\;x \cdot y \leq 2 \cdot 10^{+110}:\\ \;\;\;\;2 \cdot \left(\left(a \cdot c\right) \cdot \left(-i\right)\right)\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (* (* x y) 2.0)))
   (if (<= (* x y) -2.05e+48)
     t_1
     (if (<= (* x y) 1.1e-234)
       (* 2.0 (* z t))
       (if (<= (* x y) 2e+110) (* 2.0 (* (* a c) (- i))) t_1)))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (x * y) * 2.0;
	double tmp;
	if ((x * y) <= -2.05e+48) {
		tmp = t_1;
	} else if ((x * y) <= 1.1e-234) {
		tmp = 2.0 * (z * t);
	} else if ((x * y) <= 2e+110) {
		tmp = 2.0 * ((a * c) * -i);
	} 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 = (x * y) * 2.0d0
    if ((x * y) <= (-2.05d+48)) then
        tmp = t_1
    else if ((x * y) <= 1.1d-234) then
        tmp = 2.0d0 * (z * t)
    else if ((x * y) <= 2d+110) then
        tmp = 2.0d0 * ((a * c) * -i)
    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 = (x * y) * 2.0;
	double tmp;
	if ((x * y) <= -2.05e+48) {
		tmp = t_1;
	} else if ((x * y) <= 1.1e-234) {
		tmp = 2.0 * (z * t);
	} else if ((x * y) <= 2e+110) {
		tmp = 2.0 * ((a * c) * -i);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = (x * y) * 2.0
	tmp = 0
	if (x * y) <= -2.05e+48:
		tmp = t_1
	elif (x * y) <= 1.1e-234:
		tmp = 2.0 * (z * t)
	elif (x * y) <= 2e+110:
		tmp = 2.0 * ((a * c) * -i)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(Float64(x * y) * 2.0)
	tmp = 0.0
	if (Float64(x * y) <= -2.05e+48)
		tmp = t_1;
	elseif (Float64(x * y) <= 1.1e-234)
		tmp = Float64(2.0 * Float64(z * t));
	elseif (Float64(x * y) <= 2e+110)
		tmp = Float64(2.0 * Float64(Float64(a * c) * Float64(-i)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = (x * y) * 2.0;
	tmp = 0.0;
	if ((x * y) <= -2.05e+48)
		tmp = t_1;
	elseif ((x * y) <= 1.1e-234)
		tmp = 2.0 * (z * t);
	elseif ((x * y) <= 2e+110)
		tmp = 2.0 * ((a * c) * -i);
	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[(x * y), $MachinePrecision] * 2.0), $MachinePrecision]}, If[LessEqual[N[(x * y), $MachinePrecision], -2.05e+48], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], 1.1e-234], N[(2.0 * N[(z * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 2e+110], N[(2.0 * N[(N[(a * c), $MachinePrecision] * (-i)), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

Derivation

1. Split input into 3 regimes

2. if (*.f64 x y) < -2.0500000000000001e48 or 2e110 < (*.f64 x y)

   1. Initial program 87.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 x around inf 60.0%

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

   if -2.0500000000000001e48 < (*.f64 x y) < 1.1e-234

   1. Initial program 90.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 45.6%

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

   if 1.1e-234 < (*.f64 x y) < 2e110

   1. Initial program 91.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 a around inf 39.1%

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

      1. mul-1-neg 39.1%

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

      2. *-commutative 39.1%

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

      3. associate-*l* 33.5%

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

   4. Simplified 33.5%

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

   5. Taylor expanded in c around 0 39.1%

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

      1. *-commutative 39.1%

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

      2. associate-*r* 33.5%

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

      3. *-commutative 33.5%

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

      4. associate-*l* 36.3%

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

   7. Simplified 36.3%

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

4. Final simplification 48.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \cdot y \leq -2.05 \cdot 10^{+48}:\\ \;\;\;\;\left(x \cdot y\right) \cdot 2\\ \mathbf{elif}\;x \cdot y \leq 1.1 \cdot 10^{-234}:\\ \;\;\;\;2 \cdot \left(z \cdot t\right)\\ \mathbf{elif}\;x \cdot y \leq 2 \cdot 10^{+110}:\\ \;\;\;\;2 \cdot \left(\left(a \cdot c\right) \cdot \left(-i\right)\right)\\ \mathbf{else}:\\ \;\;\;\;\left(x \cdot y\right) \cdot 2\\ \end{array} \]

Alternative 7: 43.5% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(x \cdot y\right) \cdot 2\\ \mathbf{if}\;x \cdot y \leq -1.05 \cdot 10^{+47}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \cdot y \leq 6.8 \cdot 10^{-249}:\\ \;\;\;\;2 \cdot \left(z \cdot t\right)\\ \mathbf{elif}\;x \cdot y \leq 1.3 \cdot 10^{+117}:\\ \;\;\;\;\left(-2\right) \cdot \left(a \cdot \left(c \cdot i\right)\right)\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (* (* x y) 2.0)))
   (if (<= (* x y) -1.05e+47)
     t_1
     (if (<= (* x y) 6.8e-249)
       (* 2.0 (* z t))
       (if (<= (* x y) 1.3e+117) (* (- 2.0) (* a (* c i))) t_1)))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (x * y) * 2.0;
	double tmp;
	if ((x * y) <= -1.05e+47) {
		tmp = t_1;
	} else if ((x * y) <= 6.8e-249) {
		tmp = 2.0 * (z * t);
	} else if ((x * y) <= 1.3e+117) {
		tmp = -2.0 * (a * (c * i));
	} 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 = (x * y) * 2.0d0
    if ((x * y) <= (-1.05d+47)) then
        tmp = t_1
    else if ((x * y) <= 6.8d-249) then
        tmp = 2.0d0 * (z * t)
    else if ((x * y) <= 1.3d+117) then
        tmp = -2.0d0 * (a * (c * i))
    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 = (x * y) * 2.0;
	double tmp;
	if ((x * y) <= -1.05e+47) {
		tmp = t_1;
	} else if ((x * y) <= 6.8e-249) {
		tmp = 2.0 * (z * t);
	} else if ((x * y) <= 1.3e+117) {
		tmp = -2.0 * (a * (c * i));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = (x * y) * 2.0
	tmp = 0
	if (x * y) <= -1.05e+47:
		tmp = t_1
	elif (x * y) <= 6.8e-249:
		tmp = 2.0 * (z * t)
	elif (x * y) <= 1.3e+117:
		tmp = -2.0 * (a * (c * i))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(Float64(x * y) * 2.0)
	tmp = 0.0
	if (Float64(x * y) <= -1.05e+47)
		tmp = t_1;
	elseif (Float64(x * y) <= 6.8e-249)
		tmp = Float64(2.0 * Float64(z * t));
	elseif (Float64(x * y) <= 1.3e+117)
		tmp = Float64(Float64(-2.0) * Float64(a * Float64(c * i)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = (x * y) * 2.0;
	tmp = 0.0;
	if ((x * y) <= -1.05e+47)
		tmp = t_1;
	elseif ((x * y) <= 6.8e-249)
		tmp = 2.0 * (z * t);
	elseif ((x * y) <= 1.3e+117)
		tmp = -2.0 * (a * (c * i));
	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[(x * y), $MachinePrecision] * 2.0), $MachinePrecision]}, If[LessEqual[N[(x * y), $MachinePrecision], -1.05e+47], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], 6.8e-249], N[(2.0 * N[(z * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 1.3e+117], N[((-2.0) * N[(a * N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

Derivation

1. Split input into 3 regimes

2. if (*.f64 x y) < -1.05e47 or 1.3e117 < (*.f64 x y)

   1. Initial program 87.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 x around inf 60.0%

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

   if -1.05e47 < (*.f64 x y) < 6.7999999999999996e-249

   1. Initial program 93.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 z around inf 47.3%

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

   if 6.7999999999999996e-249 < (*.f64 x y) < 1.3e117

   1. Initial program 88.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 38.7%

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

      1. mul-1-neg 38.7%

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

      2. distribute-rgt-neg-in 38.7%

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

      3. *-commutative 38.7%

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

      4. distribute-rgt-neg-in 38.7%

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

   4. Simplified 38.7%

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

4. Final simplification 49.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \cdot y \leq -1.05 \cdot 10^{+47}:\\ \;\;\;\;\left(x \cdot y\right) \cdot 2\\ \mathbf{elif}\;x \cdot y \leq 6.8 \cdot 10^{-249}:\\ \;\;\;\;2 \cdot \left(z \cdot t\right)\\ \mathbf{elif}\;x \cdot y \leq 1.3 \cdot 10^{+117}:\\ \;\;\;\;\left(-2\right) \cdot \left(a \cdot \left(c \cdot i\right)\right)\\ \mathbf{else}:\\ \;\;\;\;\left(x \cdot y\right) \cdot 2\\ \end{array} \]

Alternative 8: 80.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;c \leq -4.6 \cdot 10^{-22} \lor \neg \left(c \leq 0.034\right):\\ \;\;\;\;2 \cdot \left(z \cdot t - c \cdot \left(\left(a + b \cdot c\right) \cdot i\right)\right)\\ \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 -4.6e-22) (not (<= c 0.034)))
   (* 2.0 (- (* z t) (* c (* (+ a (* b c)) i))))
   (* (+ (* 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 <= -4.6e-22) || !(c <= 0.034)) {
		tmp = 2.0 * ((z * t) - (c * ((a + (b * c)) * i)));
	} 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 <= (-4.6d-22)) .or. (.not. (c <= 0.034d0))) then
        tmp = 2.0d0 * ((z * t) - (c * ((a + (b * c)) * i)))
    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 <= -4.6e-22) || !(c <= 0.034)) {
		tmp = 2.0 * ((z * t) - (c * ((a + (b * c)) * i)));
	} 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 <= -4.6e-22) or not (c <= 0.034):
		tmp = 2.0 * ((z * t) - (c * ((a + (b * c)) * i)))
	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 <= -4.6e-22) || !(c <= 0.034))
		tmp = Float64(2.0 * Float64(Float64(z * t) - Float64(c * Float64(Float64(a + Float64(b * c)) * i))));
	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 <= -4.6e-22) || ~((c <= 0.034)))
		tmp = 2.0 * ((z * t) - (c * ((a + (b * c)) * i)));
	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, -4.6e-22], N[Not[LessEqual[c, 0.034]], $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[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if c < -4.5999999999999996e-22 or 0.034000000000000002 < c

   1. Initial program 82.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 x around 0 83.7%

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

   if -4.5999999999999996e-22 < c < 0.034000000000000002

   1. Initial program 99.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 84.7%

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

4. Final simplification 84.1%

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

Alternative 9: 87.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;c \leq -0.0026 \lor \neg \left(c \leq 3.15 \cdot 10^{+41}\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(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 -0.0026) (not (<= c 3.15e+41)))
   (* 2.0 (- (* z t) (* 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 <= -0.0026) || !(c <= 3.15e+41)) {
		tmp = 2.0 * ((z * t) - (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 <= (-0.0026d0)) .or. (.not. (c <= 3.15d+41))) then
        tmp = 2.0d0 * ((z * t) - (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 <= -0.0026) || !(c <= 3.15e+41)) {
		tmp = 2.0 * ((z * t) - (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 <= -0.0026) or not (c <= 3.15e+41):
		tmp = 2.0 * ((z * t) - (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 <= -0.0026) || !(c <= 3.15e+41))
		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(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 <= -0.0026) || ~((c <= 3.15e+41)))
		tmp = 2.0 * ((z * t) - (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, -0.0026], N[Not[LessEqual[c, 3.15e+41]], $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[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] - N[(i * N[(a * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if c < -0.0025999999999999999 or 3.1499999999999999e41 < c

   1. Initial program 80.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 84.7%

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

   if -0.0025999999999999999 < c < 3.1499999999999999e41

   1. Initial program 99.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 a around inf 97.0%

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

      1. *-commutative 97.0%

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

   4. Simplified 97.0%

      \[\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 90.8%

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

Alternative 10: 75.3% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;c \leq -6.1 \cdot 10^{-18} \lor \neg \left(c \leq 2.4 \cdot 10^{+45}\right):\\ \;\;\;\;2 \cdot \left(\left(\left(a + b \cdot c\right) \cdot i\right) \cdot \left(-c\right)\right)\\ \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.1e-18) (not (<= c 2.4e+45)))
   (* 2.0 (* (* (+ a (* b c)) i) (- c)))
   (* (+ (* 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.1e-18) || !(c <= 2.4e+45)) {
		tmp = 2.0 * (((a + (b * c)) * i) * -c);
	} 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.1d-18)) .or. (.not. (c <= 2.4d+45))) then
        tmp = 2.0d0 * (((a + (b * c)) * i) * -c)
    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.1e-18) || !(c <= 2.4e+45)) {
		tmp = 2.0 * (((a + (b * c)) * i) * -c);
	} 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.1e-18) or not (c <= 2.4e+45):
		tmp = 2.0 * (((a + (b * c)) * i) * -c)
	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.1e-18) || !(c <= 2.4e+45))
		tmp = Float64(2.0 * Float64(Float64(Float64(a + Float64(b * c)) * i) * Float64(-c)));
	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.1e-18) || ~((c <= 2.4e+45)))
		tmp = 2.0 * (((a + (b * c)) * i) * -c);
	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.1e-18], N[Not[LessEqual[c, 2.4e+45]], $MachinePrecision]], N[(2.0 * N[(N[(N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision] * (-c)), $MachinePrecision]), $MachinePrecision], N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if c < -6.0999999999999999e-18 or 2.39999999999999989e45 < 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 i around inf 77.2%

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

   if -6.0999999999999999e-18 < c < 2.39999999999999989e45

   1. Initial program 99.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 83.5%

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

4. Final simplification 80.2%

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

Alternative 11: 43.4% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \cdot y \leq -9.6 \cdot 10^{+46} \lor \neg \left(x \cdot y \leq 2.8 \cdot 10^{-102}\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) -9.6e+46) (not (<= (* x y) 2.8e-102)))
   (* (* 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) <= -9.6e+46) || !((x * y) <= 2.8e-102)) {
		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) <= (-9.6d+46)) .or. (.not. ((x * y) <= 2.8d-102))) 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) <= -9.6e+46) || !((x * y) <= 2.8e-102)) {
		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) <= -9.6e+46) or not ((x * y) <= 2.8e-102):
		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) <= -9.6e+46) || !(Float64(x * y) <= 2.8e-102))
		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) <= -9.6e+46) || ~(((x * y) <= 2.8e-102)))
		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], -9.6e+46], N[Not[LessEqual[N[(x * y), $MachinePrecision], 2.8e-102]], $MachinePrecision]], N[(N[(x * y), $MachinePrecision] * 2.0), $MachinePrecision], N[(2.0 * N[(z * t), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if (*.f64 x y) < -9.60000000000000034e46 or 2.80000000000000013e-102 < (*.f64 x y)

   1. Initial program 88.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 x around inf 47.3%

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

   if -9.60000000000000034e46 < (*.f64 x y) < 2.80000000000000013e-102

   1. Initial program 90.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 inf 43.1%

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

4. Final simplification 45.6%

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

Alternative 12: 57.9% accurate, 1.4× speedup

Math

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

Python

def code(x, y, z, t, a, b, c, i):
	tmp = 0
	if (i <= -2.9e+142) or not (i <= 3.5e+136):
		tmp = -2.0 * (a * (c * i))
	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 ((i <= -2.9e+142) || !(i <= 3.5e+136))
		tmp = Float64(Float64(-2.0) * Float64(a * Float64(c * i)));
	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 ((i <= -2.9e+142) || ~((i <= 3.5e+136)))
		tmp = -2.0 * (a * (c * i));
	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[i, -2.9e+142], N[Not[LessEqual[i, 3.5e+136]], $MachinePrecision]], N[((-2.0) * N[(a * N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if i < -2.90000000000000013e142 or 3.50000000000000001e136 < i

   1. Initial program 91.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 55.0%

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

      1. mul-1-neg 55.0%

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

      2. distribute-rgt-neg-in 55.0%

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

      3. *-commutative 55.0%

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

      4. distribute-rgt-neg-in 55.0%

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

   4. Simplified 55.0%

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

   if -2.90000000000000013e142 < i < 3.50000000000000001e136

   1. Initial program 89.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 65.5%

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

4. Final simplification 63.1%

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

Alternative 13: 29.0% 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 89.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 inf 27.4%

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

3. Final simplification 27.4%

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

Developer target: 94.3% 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 2023340 
(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))))