Graphics.Rasterific.CubicBezier:cachedBezierAt from Rasterific-0.6.1

Percentage Accurate: 92.7% → 97.6%

Time: 7.6s

Alternatives: 14

Speedup: 0.2×

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

Specification

Math

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

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    code = ((x + (y * z)) + (t * a)) + ((a * z) * b)
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 92.7% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    code = ((x + (y * z)) + (t * a)) + ((a * z) * b)
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 97.6% accurate, 0.2× speedup

Math

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

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if (+.f64 (+.f64 (+.f64 x (*.f64 y z)) (*.f64 t a)) (*.f64 (*.f64 a z) b)) < -inf.0 or 1e297 < (+.f64 (+.f64 (+.f64 x (*.f64 y z)) (*.f64 t a)) (*.f64 (*.f64 a z) b)) < +inf.0

   1. Initial program 87.4%

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

      1. associate-+l+ 87.4%

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

      2. associate-*l* 100.0%

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

   3. Simplified 100.0%

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

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

   1. Initial program 99.5%

      \[\left(\left(x + y \cdot z\right) + t \cdot a\right) + \left(a \cdot z\right) \cdot b \]

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

   1. Initial program 0.0%

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

      1. associate-+l+ 0.0%

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

      2. associate-*l* 23.1%

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

   3. Simplified 23.1%

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

   4. Taylor expanded in z around inf 92.3%

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

4. Final simplification 99.3%

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

Alternative 2: 96.6% accurate, 0.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq 5 \cdot 10^{+24}:\\ \;\;\;\;\mathsf{fma}\left(a, t + z \cdot b, \mathsf{fma}\left(y, z, x\right)\right)\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(z, \mathsf{fma}\left(a, b, y\right), \mathsf{fma}\left(t, a, x\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= z 5e+24)
   (fma a (+ t (* z b)) (fma y z x))
   (fma z (fma a b y) (fma t a x))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (z <= 5e+24) {
		tmp = fma(a, (t + (z * b)), fma(y, z, x));
	} else {
		tmp = fma(z, fma(a, b, y), fma(t, a, x));
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (z <= 5e+24)
		tmp = fma(a, Float64(t + Float64(z * b)), fma(y, z, x));
	else
		tmp = fma(z, fma(a, b, y), fma(t, a, x));
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[z, 5e+24], N[(a * N[(t + N[(z * b), $MachinePrecision]), $MachinePrecision] + N[(y * z + x), $MachinePrecision]), $MachinePrecision], N[(z * N[(a * b + y), $MachinePrecision] + N[(t * a + x), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if z < 5.00000000000000045e24

   1. Initial program 94.0%

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

      1. associate-+l+ 94.0%

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

      2. +-commutative 94.0%

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

      3. *-commutative 94.0%

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

      4. associate-*l* 94.4%

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

      5. distribute-lft-out 97.2%

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

      6. fma-def 98.4%

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

      7. +-commutative 98.4%

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

      8. fma-def 98.4%

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

   3. Simplified 98.4%

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

   if 5.00000000000000045e24 < z

   1. Initial program 84.9%

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

      1. +-commutative 84.9%

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

      2. +-commutative 84.9%

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

      3. associate-+l+ 84.9%

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

      4. associate-+r+ 84.9%

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

      5. *-commutative 84.9%

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

      6. associate-*l* 97.3%

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

      7. *-commutative 97.3%

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

      8. distribute-lft-out 99.9%

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

      9. fma-def 99.9%

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

      10. fma-def 99.9%

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

      11. +-commutative 99.9%

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

      12. fma-def 99.9%

          \[\leadsto \mathsf{fma}\left(z, \mathsf{fma}\left(a, b, y\right), \color{blue}{\mathsf{fma}\left(t, a, x\right)}\right) \]

   3. Simplified 99.9%

      \[\leadsto \color{blue}{\mathsf{fma}\left(z, \mathsf{fma}\left(a, b, y\right), \mathsf{fma}\left(t, a, x\right)\right)} \]
3. Recombined 2 regimes into one program.

4. Final simplification 98.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq 5 \cdot 10^{+24}:\\ \;\;\;\;\mathsf{fma}\left(a, t + z \cdot b, \mathsf{fma}\left(y, z, x\right)\right)\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(z, \mathsf{fma}\left(a, b, y\right), \mathsf{fma}\left(t, a, x\right)\right)\\ \end{array} \]

Alternative 3: 94.4% accurate, 0.1× speedup

Math

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

FPCore

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

C

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

Julia

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

Wolfram

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

Derivation

1. Initial program 91.3%

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

   1. associate-+l+ 91.3%

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

   2. +-commutative 91.3%

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

   3. *-commutative 91.3%

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

   4. associate-*l* 93.1%

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

   5. distribute-lft-out 95.1%

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

   6. fma-def 95.9%

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

   7. +-commutative 95.9%

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

   8. fma-def 95.9%

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

3. Simplified 95.9%

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

4. Final simplification 95.9%

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

Alternative 4: 93.2% accurate, 0.1× speedup

Math

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

FPCore

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

C

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

Julia

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

Wolfram

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

Derivation

1. Initial program 91.3%

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

   1. associate-+l+ 91.3%

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

   2. associate-*l* 93.1%

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

3. Simplified 93.1%

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

   1. fma-def 95.1%

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

5. Applied egg-rr 95.1%

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

6. Final simplification 95.1%

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

Alternative 5: 91.9% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    code = ((a * (z * b)) + (a * t)) + (x + (z * y))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 91.3%

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

   1. associate-+l+ 91.3%

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

   2. associate-*l* 93.1%

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

3. Simplified 93.1%

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

4. Final simplification 93.1%

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

Alternative 6: 38.5% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -4.4 \cdot 10^{+76}:\\ \;\;\;\;z \cdot y\\ \mathbf{elif}\;y \leq -2.7 \cdot 10^{-214}:\\ \;\;\;\;x\\ \mathbf{elif}\;y \leq -1.5 \cdot 10^{-259}:\\ \;\;\;\;a \cdot \left(z \cdot b\right)\\ \mathbf{elif}\;y \leq 1.05 \cdot 10^{-248}:\\ \;\;\;\;x\\ \mathbf{elif}\;y \leq 3.25 \cdot 10^{+35}:\\ \;\;\;\;a \cdot t\\ \mathbf{else}:\\ \;\;\;\;z \cdot y\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= y -4.4e+76)
   (* z y)
   (if (<= y -2.7e-214)
     x
     (if (<= y -1.5e-259)
       (* a (* z b))
       (if (<= y 1.05e-248) x (if (<= y 3.25e+35) (* a t) (* z y)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (y <= -4.4e+76) {
		tmp = z * y;
	} else if (y <= -2.7e-214) {
		tmp = x;
	} else if (y <= -1.5e-259) {
		tmp = a * (z * b);
	} else if (y <= 1.05e-248) {
		tmp = x;
	} else if (y <= 3.25e+35) {
		tmp = a * t;
	} else {
		tmp = z * y;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (y <= (-4.4d+76)) then
        tmp = z * y
    else if (y <= (-2.7d-214)) then
        tmp = x
    else if (y <= (-1.5d-259)) then
        tmp = a * (z * b)
    else if (y <= 1.05d-248) then
        tmp = x
    else if (y <= 3.25d+35) then
        tmp = a * t
    else
        tmp = z * y
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (y <= -4.4e+76) {
		tmp = z * y;
	} else if (y <= -2.7e-214) {
		tmp = x;
	} else if (y <= -1.5e-259) {
		tmp = a * (z * b);
	} else if (y <= 1.05e-248) {
		tmp = x;
	} else if (y <= 3.25e+35) {
		tmp = a * t;
	} else {
		tmp = z * y;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if y <= -4.4e+76:
		tmp = z * y
	elif y <= -2.7e-214:
		tmp = x
	elif y <= -1.5e-259:
		tmp = a * (z * b)
	elif y <= 1.05e-248:
		tmp = x
	elif y <= 3.25e+35:
		tmp = a * t
	else:
		tmp = z * y
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (y <= -4.4e+76)
		tmp = Float64(z * y);
	elseif (y <= -2.7e-214)
		tmp = x;
	elseif (y <= -1.5e-259)
		tmp = Float64(a * Float64(z * b));
	elseif (y <= 1.05e-248)
		tmp = x;
	elseif (y <= 3.25e+35)
		tmp = Float64(a * t);
	else
		tmp = Float64(z * y);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (y <= -4.4e+76)
		tmp = z * y;
	elseif (y <= -2.7e-214)
		tmp = x;
	elseif (y <= -1.5e-259)
		tmp = a * (z * b);
	elseif (y <= 1.05e-248)
		tmp = x;
	elseif (y <= 3.25e+35)
		tmp = a * t;
	else
		tmp = z * y;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[y, -4.4e+76], N[(z * y), $MachinePrecision], If[LessEqual[y, -2.7e-214], x, If[LessEqual[y, -1.5e-259], N[(a * N[(z * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.05e-248], x, If[LessEqual[y, 3.25e+35], N[(a * t), $MachinePrecision], N[(z * y), $MachinePrecision]]]]]]

Derivation

1. Split input into 4 regimes

2. if y < -4.4000000000000001e76 or 3.2500000000000002e35 < y

   1. Initial program 91.4%

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

      1. associate-+l+ 91.4%

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

      2. associate-*l* 92.4%

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

   3. Simplified 92.4%

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

   4. Taylor expanded in y around inf 61.1%

      \[\leadsto \color{blue}{y \cdot z} \]
   5. Step-by-step derivation

      1. *-commutative 61.1%

         \[\leadsto \color{blue}{z \cdot y} \]

   6. Simplified 61.1%

      \[\leadsto \color{blue}{z \cdot y} \]

   if -4.4000000000000001e76 < y < -2.7000000000000001e-214 or -1.5000000000000001e-259 < y < 1.05e-248

   1. Initial program 89.3%

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

      1. associate-+l+ 89.3%

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

      2. associate-*l* 90.6%

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

   3. Simplified 90.6%

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

   4. Taylor expanded in x around inf 40.2%

      \[\leadsto \color{blue}{x} \]

   if -2.7000000000000001e-214 < y < -1.5000000000000001e-259

   1. Initial program 90.1%

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

      1. associate-+l+ 90.1%

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

      2. associate-*l* 99.5%

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

   3. Simplified 99.5%

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

      1. fma-def 99.7%

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

   5. Applied egg-rr 99.7%

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

   6. Taylor expanded in b around inf 72.1%

      \[\leadsto \color{blue}{a \cdot \left(b \cdot z\right)} \]

   if 1.05e-248 < y < 3.2500000000000002e35

   1. Initial program 93.8%

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

      1. associate-+l+ 93.8%

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

      2. associate-*l* 96.7%

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

   3. Simplified 96.7%

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

   4. Taylor expanded in t around inf 40.0%

      \[\leadsto \color{blue}{a \cdot t} \]
3. Recombined 4 regimes into one program.

4. Final simplification 50.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -4.4 \cdot 10^{+76}:\\ \;\;\;\;z \cdot y\\ \mathbf{elif}\;y \leq -2.7 \cdot 10^{-214}:\\ \;\;\;\;x\\ \mathbf{elif}\;y \leq -1.5 \cdot 10^{-259}:\\ \;\;\;\;a \cdot \left(z \cdot b\right)\\ \mathbf{elif}\;y \leq 1.05 \cdot 10^{-248}:\\ \;\;\;\;x\\ \mathbf{elif}\;y \leq 3.25 \cdot 10^{+35}:\\ \;\;\;\;a \cdot t\\ \mathbf{else}:\\ \;\;\;\;z \cdot y\\ \end{array} \]

Alternative 7: 59.2% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -3.1 \cdot 10^{+85}:\\ \;\;\;\;z \cdot y\\ \mathbf{elif}\;z \leq 4.8 \cdot 10^{+51}:\\ \;\;\;\;x + a \cdot t\\ \mathbf{elif}\;z \leq 1.35 \cdot 10^{+252}:\\ \;\;\;\;z \cdot y\\ \mathbf{elif}\;z \leq 5.4 \cdot 10^{+293}:\\ \;\;\;\;z \cdot \left(a \cdot b\right)\\ \mathbf{else}:\\ \;\;\;\;z \cdot y\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= z -3.1e+85)
   (* z y)
   (if (<= z 4.8e+51)
     (+ x (* a t))
     (if (<= z 1.35e+252)
       (* z y)
       (if (<= z 5.4e+293) (* z (* a b)) (* z y))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (z <= -3.1e+85) {
		tmp = z * y;
	} else if (z <= 4.8e+51) {
		tmp = x + (a * t);
	} else if (z <= 1.35e+252) {
		tmp = z * y;
	} else if (z <= 5.4e+293) {
		tmp = z * (a * b);
	} else {
		tmp = z * y;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (z <= (-3.1d+85)) then
        tmp = z * y
    else if (z <= 4.8d+51) then
        tmp = x + (a * t)
    else if (z <= 1.35d+252) then
        tmp = z * y
    else if (z <= 5.4d+293) then
        tmp = z * (a * b)
    else
        tmp = z * y
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (z <= -3.1e+85) {
		tmp = z * y;
	} else if (z <= 4.8e+51) {
		tmp = x + (a * t);
	} else if (z <= 1.35e+252) {
		tmp = z * y;
	} else if (z <= 5.4e+293) {
		tmp = z * (a * b);
	} else {
		tmp = z * y;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if z <= -3.1e+85:
		tmp = z * y
	elif z <= 4.8e+51:
		tmp = x + (a * t)
	elif z <= 1.35e+252:
		tmp = z * y
	elif z <= 5.4e+293:
		tmp = z * (a * b)
	else:
		tmp = z * y
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (z <= -3.1e+85)
		tmp = Float64(z * y);
	elseif (z <= 4.8e+51)
		tmp = Float64(x + Float64(a * t));
	elseif (z <= 1.35e+252)
		tmp = Float64(z * y);
	elseif (z <= 5.4e+293)
		tmp = Float64(z * Float64(a * b));
	else
		tmp = Float64(z * y);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (z <= -3.1e+85)
		tmp = z * y;
	elseif (z <= 4.8e+51)
		tmp = x + (a * t);
	elseif (z <= 1.35e+252)
		tmp = z * y;
	elseif (z <= 5.4e+293)
		tmp = z * (a * b);
	else
		tmp = z * y;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[z, -3.1e+85], N[(z * y), $MachinePrecision], If[LessEqual[z, 4.8e+51], N[(x + N[(a * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.35e+252], N[(z * y), $MachinePrecision], If[LessEqual[z, 5.4e+293], N[(z * N[(a * b), $MachinePrecision]), $MachinePrecision], N[(z * y), $MachinePrecision]]]]]

Derivation

1. Split input into 3 regimes

2. if z < -3.10000000000000011e85 or 4.7999999999999997e51 < z < 1.35000000000000005e252 or 5.4000000000000002e293 < z

   1. Initial program 85.7%

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

      1. associate-+l+ 85.7%

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

      2. associate-*l* 87.1%

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

   3. Simplified 87.1%

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

   4. Taylor expanded in y around inf 52.3%

      \[\leadsto \color{blue}{y \cdot z} \]
   5. Step-by-step derivation

      1. *-commutative 52.3%

         \[\leadsto \color{blue}{z \cdot y} \]

   6. Simplified 52.3%

      \[\leadsto \color{blue}{z \cdot y} \]

   if -3.10000000000000011e85 < z < 4.7999999999999997e51

   1. Initial program 97.4%

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

      1. associate-+l+ 97.4%

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

      2. associate-*l* 97.9%

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

   3. Simplified 97.9%

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

   4. Taylor expanded in z around 0 72.2%

      \[\leadsto \color{blue}{a \cdot t + x} \]

   if 1.35000000000000005e252 < z < 5.4000000000000002e293

   1. Initial program 46.3%

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

      1. associate-+l+ 46.3%

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

      2. associate-*l* 85.7%

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

   3. Simplified 85.7%

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

      1. fma-def 85.7%

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

   5. Applied egg-rr 85.7%

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

   6. Taylor expanded in b around inf 64.8%

      \[\leadsto \color{blue}{a \cdot \left(b \cdot z\right)} \]
   7. Step-by-step derivation

      1. associate-*r* 64.9%

         \[\leadsto \color{blue}{\left(a \cdot b\right) \cdot z} \]

      2. *-commutative 64.9%

         \[\leadsto \color{blue}{z \cdot \left(a \cdot b\right)} \]

   8. Simplified 64.9%

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

4. Final simplification 63.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -3.1 \cdot 10^{+85}:\\ \;\;\;\;z \cdot y\\ \mathbf{elif}\;z \leq 4.8 \cdot 10^{+51}:\\ \;\;\;\;x + a \cdot t\\ \mathbf{elif}\;z \leq 1.35 \cdot 10^{+252}:\\ \;\;\;\;z \cdot y\\ \mathbf{elif}\;z \leq 5.4 \cdot 10^{+293}:\\ \;\;\;\;z \cdot \left(a \cdot b\right)\\ \mathbf{else}:\\ \;\;\;\;z \cdot y\\ \end{array} \]

Alternative 8: 63.1% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + a \cdot t\\ t_2 := x + z \cdot y\\ \mathbf{if}\;y \leq -2.2 \cdot 10^{+61}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y \leq -7.2 \cdot 10^{-235}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq -1.9 \cdot 10^{-250}:\\ \;\;\;\;a \cdot \left(z \cdot b\right)\\ \mathbf{elif}\;y \leq 8.4 \cdot 10^{+30}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ x (* a t))) (t_2 (+ x (* z y))))
   (if (<= y -2.2e+61)
     t_2
     (if (<= y -7.2e-235)
       t_1
       (if (<= y -1.9e-250) (* a (* z b)) (if (<= y 8.4e+30) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x + (a * t);
	double t_2 = x + (z * y);
	double tmp;
	if (y <= -2.2e+61) {
		tmp = t_2;
	} else if (y <= -7.2e-235) {
		tmp = t_1;
	} else if (y <= -1.9e-250) {
		tmp = a * (z * b);
	} else if (y <= 8.4e+30) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = x + (a * t)
    t_2 = x + (z * y)
    if (y <= (-2.2d+61)) then
        tmp = t_2
    else if (y <= (-7.2d-235)) then
        tmp = t_1
    else if (y <= (-1.9d-250)) then
        tmp = a * (z * b)
    else if (y <= 8.4d+30) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x + (a * t);
	double t_2 = x + (z * y);
	double tmp;
	if (y <= -2.2e+61) {
		tmp = t_2;
	} else if (y <= -7.2e-235) {
		tmp = t_1;
	} else if (y <= -1.9e-250) {
		tmp = a * (z * b);
	} else if (y <= 8.4e+30) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x + (a * t)
	t_2 = x + (z * y)
	tmp = 0
	if y <= -2.2e+61:
		tmp = t_2
	elif y <= -7.2e-235:
		tmp = t_1
	elif y <= -1.9e-250:
		tmp = a * (z * b)
	elif y <= 8.4e+30:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x + Float64(a * t))
	t_2 = Float64(x + Float64(z * y))
	tmp = 0.0
	if (y <= -2.2e+61)
		tmp = t_2;
	elseif (y <= -7.2e-235)
		tmp = t_1;
	elseif (y <= -1.9e-250)
		tmp = Float64(a * Float64(z * b));
	elseif (y <= 8.4e+30)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x + (a * t);
	t_2 = x + (z * y);
	tmp = 0.0;
	if (y <= -2.2e+61)
		tmp = t_2;
	elseif (y <= -7.2e-235)
		tmp = t_1;
	elseif (y <= -1.9e-250)
		tmp = a * (z * b);
	elseif (y <= 8.4e+30)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(a * t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(z * y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2.2e+61], t$95$2, If[LessEqual[y, -7.2e-235], t$95$1, If[LessEqual[y, -1.9e-250], N[(a * N[(z * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 8.4e+30], t$95$1, t$95$2]]]]]]

Derivation

1. Split input into 3 regimes

2. if y < -2.2e61 or 8.4000000000000001e30 < y

   1. Initial program 91.6%

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

      1. associate-+l+ 91.6%

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

      2. associate-*l* 92.6%

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

   3. Simplified 92.6%

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

   4. Taylor expanded in a around 0 78.8%

      \[\leadsto \color{blue}{y \cdot z + x} \]

   if -2.2e61 < y < -7.19999999999999998e-235 or -1.89999999999999985e-250 < y < 8.4000000000000001e30

   1. Initial program 91.3%

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

      1. associate-+l+ 91.3%

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

      2. associate-*l* 93.2%

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

   3. Simplified 93.2%

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

   4. Taylor expanded in z around 0 63.7%

      \[\leadsto \color{blue}{a \cdot t + x} \]

   if -7.19999999999999998e-235 < y < -1.89999999999999985e-250

   1. Initial program 84.1%

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

      1. associate-+l+ 84.1%

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

      2. associate-*l* 99.7%

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

   3. Simplified 99.7%

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

      1. fma-def 99.7%

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

   5. Applied egg-rr 99.7%

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

   6. Taylor expanded in b around inf 99.7%

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

4. Final simplification 70.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -2.2 \cdot 10^{+61}:\\ \;\;\;\;x + z \cdot y\\ \mathbf{elif}\;y \leq -7.2 \cdot 10^{-235}:\\ \;\;\;\;x + a \cdot t\\ \mathbf{elif}\;y \leq -1.9 \cdot 10^{-250}:\\ \;\;\;\;a \cdot \left(z \cdot b\right)\\ \mathbf{elif}\;y \leq 8.4 \cdot 10^{+30}:\\ \;\;\;\;x + a \cdot t\\ \mathbf{else}:\\ \;\;\;\;x + z \cdot y\\ \end{array} \]

Alternative 9: 78.0% accurate, 1.1× speedup

Math

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

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= y -4.1e+77) (not (<= y 3e+36)))
   (+ x (* z y))
   (+ x (* a (+ t (* z b))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((y <= -4.1e+77) || !(y <= 3e+36)) {
		tmp = x + (z * y);
	} else {
		tmp = x + (a * (t + (z * b)));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if ((y <= (-4.1d+77)) .or. (.not. (y <= 3d+36))) then
        tmp = x + (z * y)
    else
        tmp = x + (a * (t + (z * b)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((y <= -4.1e+77) || !(y <= 3e+36)) {
		tmp = x + (z * y);
	} else {
		tmp = x + (a * (t + (z * b)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (y <= -4.1e+77) or not (y <= 3e+36):
		tmp = x + (z * y)
	else:
		tmp = x + (a * (t + (z * b)))
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((y <= -4.1e+77) || !(y <= 3e+36))
		tmp = Float64(x + Float64(z * y));
	else
		tmp = Float64(x + Float64(a * Float64(t + Float64(z * b))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((y <= -4.1e+77) || ~((y <= 3e+36)))
		tmp = x + (z * y);
	else
		tmp = x + (a * (t + (z * b)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[y, -4.1e+77], N[Not[LessEqual[y, 3e+36]], $MachinePrecision]], N[(x + N[(z * y), $MachinePrecision]), $MachinePrecision], N[(x + N[(a * N[(t + N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if y < -4.1000000000000001e77 or 3e36 < y

   1. Initial program 91.3%

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

      1. associate-+l+ 91.3%

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

      2. associate-*l* 92.4%

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

   3. Simplified 92.4%

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

   4. Taylor expanded in a around 0 79.9%

      \[\leadsto \color{blue}{y \cdot z + x} \]

   if -4.1000000000000001e77 < y < 3e36

   1. Initial program 91.2%

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

      1. associate-+l+ 91.2%

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

      2. +-commutative 91.2%

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

      3. *-commutative 91.2%

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

      4. associate-*l* 93.7%

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

      5. distribute-lft-out 95.7%

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

      6. fma-def 95.7%

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

      7. +-commutative 95.7%

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

      8. fma-def 95.7%

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

   3. Simplified 95.7%

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

   4. Taylor expanded in y around 0 89.0%

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

4. Final simplification 85.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -4.1 \cdot 10^{+77} \lor \neg \left(y \leq 3 \cdot 10^{+36}\right):\\ \;\;\;\;x + z \cdot y\\ \mathbf{else}:\\ \;\;\;\;x + a \cdot \left(t + z \cdot b\right)\\ \end{array} \]

Alternative 10: 38.6% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -7.6 \cdot 10^{+72}:\\ \;\;\;\;z \cdot y\\ \mathbf{elif}\;y \leq -7.5 \cdot 10^{-259}:\\ \;\;\;\;z \cdot \left(a \cdot b\right)\\ \mathbf{elif}\;y \leq 3.6 \cdot 10^{-255}:\\ \;\;\;\;x\\ \mathbf{elif}\;y \leq 3 \cdot 10^{+33}:\\ \;\;\;\;a \cdot t\\ \mathbf{else}:\\ \;\;\;\;z \cdot y\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= y -7.6e+72)
   (* z y)
   (if (<= y -7.5e-259)
     (* z (* a b))
     (if (<= y 3.6e-255) x (if (<= y 3e+33) (* a t) (* z y))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (y <= -7.6e+72) {
		tmp = z * y;
	} else if (y <= -7.5e-259) {
		tmp = z * (a * b);
	} else if (y <= 3.6e-255) {
		tmp = x;
	} else if (y <= 3e+33) {
		tmp = a * t;
	} else {
		tmp = z * y;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (y <= (-7.6d+72)) then
        tmp = z * y
    else if (y <= (-7.5d-259)) then
        tmp = z * (a * b)
    else if (y <= 3.6d-255) then
        tmp = x
    else if (y <= 3d+33) then
        tmp = a * t
    else
        tmp = z * y
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (y <= -7.6e+72) {
		tmp = z * y;
	} else if (y <= -7.5e-259) {
		tmp = z * (a * b);
	} else if (y <= 3.6e-255) {
		tmp = x;
	} else if (y <= 3e+33) {
		tmp = a * t;
	} else {
		tmp = z * y;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if y <= -7.6e+72:
		tmp = z * y
	elif y <= -7.5e-259:
		tmp = z * (a * b)
	elif y <= 3.6e-255:
		tmp = x
	elif y <= 3e+33:
		tmp = a * t
	else:
		tmp = z * y
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (y <= -7.6e+72)
		tmp = Float64(z * y);
	elseif (y <= -7.5e-259)
		tmp = Float64(z * Float64(a * b));
	elseif (y <= 3.6e-255)
		tmp = x;
	elseif (y <= 3e+33)
		tmp = Float64(a * t);
	else
		tmp = Float64(z * y);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (y <= -7.6e+72)
		tmp = z * y;
	elseif (y <= -7.5e-259)
		tmp = z * (a * b);
	elseif (y <= 3.6e-255)
		tmp = x;
	elseif (y <= 3e+33)
		tmp = a * t;
	else
		tmp = z * y;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[y, -7.6e+72], N[(z * y), $MachinePrecision], If[LessEqual[y, -7.5e-259], N[(z * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.6e-255], x, If[LessEqual[y, 3e+33], N[(a * t), $MachinePrecision], N[(z * y), $MachinePrecision]]]]]

Derivation

1. Split input into 4 regimes

2. if y < -7.60000000000000012e72 or 2.99999999999999984e33 < y

   1. Initial program 91.5%

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

      1. associate-+l+ 91.5%

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

      2. associate-*l* 92.5%

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

   3. Simplified 92.5%

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

   4. Taylor expanded in y around inf 60.5%

      \[\leadsto \color{blue}{y \cdot z} \]
   5. Step-by-step derivation

      1. *-commutative 60.5%

         \[\leadsto \color{blue}{z \cdot y} \]

   6. Simplified 60.5%

      \[\leadsto \color{blue}{z \cdot y} \]

   if -7.60000000000000012e72 < y < -7.50000000000000052e-259

   1. Initial program 90.1%

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

      1. associate-+l+ 90.1%

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

      2. associate-*l* 91.5%

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

   3. Simplified 91.5%

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

      1. fma-def 93.0%

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

   5. Applied egg-rr 93.0%

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

   6. Taylor expanded in b around inf 34.4%

      \[\leadsto \color{blue}{a \cdot \left(b \cdot z\right)} \]
   7. Step-by-step derivation

      1. associate-*r* 38.4%

         \[\leadsto \color{blue}{\left(a \cdot b\right) \cdot z} \]

      2. *-commutative 38.4%

         \[\leadsto \color{blue}{z \cdot \left(a \cdot b\right)} \]

   8. Simplified 38.4%

      \[\leadsto \color{blue}{z \cdot \left(a \cdot b\right)} \]

   if -7.50000000000000052e-259 < y < 3.6000000000000002e-255

   1. Initial program 86.7%

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

      1. associate-+l+ 86.7%

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

      2. associate-*l* 91.3%

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

   3. Simplified 91.3%

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

   4. Taylor expanded in x around inf 55.5%

      \[\leadsto \color{blue}{x} \]

   if 3.6000000000000002e-255 < y < 2.99999999999999984e33

   1. Initial program 93.8%

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

      1. associate-+l+ 93.8%

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

      2. associate-*l* 96.7%

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

   3. Simplified 96.7%

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

   4. Taylor expanded in t around inf 40.0%

      \[\leadsto \color{blue}{a \cdot t} \]
3. Recombined 4 regimes into one program.

4. Final simplification 49.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -7.6 \cdot 10^{+72}:\\ \;\;\;\;z \cdot y\\ \mathbf{elif}\;y \leq -7.5 \cdot 10^{-259}:\\ \;\;\;\;z \cdot \left(a \cdot b\right)\\ \mathbf{elif}\;y \leq 3.6 \cdot 10^{-255}:\\ \;\;\;\;x\\ \mathbf{elif}\;y \leq 3 \cdot 10^{+33}:\\ \;\;\;\;a \cdot t\\ \mathbf{else}:\\ \;\;\;\;z \cdot y\\ \end{array} \]

Alternative 11: 73.6% accurate, 1.3× speedup

Math

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

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= z -6.4e+73) (not (<= z 7e-32)))
   (* z (+ y (* a b)))
   (+ x (* a t))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -6.4e+73) || !(z <= 7e-32)) {
		tmp = z * (y + (a * b));
	} else {
		tmp = x + (a * t);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if ((z <= (-6.4d+73)) .or. (.not. (z <= 7d-32))) then
        tmp = z * (y + (a * b))
    else
        tmp = x + (a * t)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((z <= -6.4e+73) || !(z <= 7e-32)) {
		tmp = z * (y + (a * b));
	} else {
		tmp = x + (a * t);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (z <= -6.4e+73) or not (z <= 7e-32):
		tmp = z * (y + (a * b))
	else:
		tmp = x + (a * t)
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((z <= -6.4e+73) || !(z <= 7e-32))
		tmp = Float64(z * Float64(y + Float64(a * b)));
	else
		tmp = Float64(x + Float64(a * t));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((z <= -6.4e+73) || ~((z <= 7e-32)))
		tmp = z * (y + (a * b));
	else
		tmp = x + (a * t);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[z, -6.4e+73], N[Not[LessEqual[z, 7e-32]], $MachinePrecision]], N[(z * N[(y + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(a * t), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if z < -6.39999999999999964e73 or 6.9999999999999997e-32 < z

   1. Initial program 84.1%

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

      1. associate-+l+ 84.1%

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

      2. associate-*l* 88.1%

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

   3. Simplified 88.1%

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

   4. Taylor expanded in z around inf 79.0%

      \[\leadsto \color{blue}{z \cdot \left(a \cdot b + y\right)} \]

   if -6.39999999999999964e73 < z < 6.9999999999999997e-32

   1. Initial program 98.6%

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

      1. associate-+l+ 98.6%

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

      2. associate-*l* 98.4%

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

   3. Simplified 98.4%

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

   4. Taylor expanded in z around 0 77.7%

      \[\leadsto \color{blue}{a \cdot t + x} \]
3. Recombined 2 regimes into one program.

4. Final simplification 78.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -6.4 \cdot 10^{+73} \lor \neg \left(z \leq 7 \cdot 10^{-32}\right):\\ \;\;\;\;z \cdot \left(y + a \cdot b\right)\\ \mathbf{else}:\\ \;\;\;\;x + a \cdot t\\ \end{array} \]

Alternative 12: 38.4% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -2.05 \cdot 10^{+77}:\\ \;\;\;\;z \cdot y\\ \mathbf{elif}\;y \leq 1.52 \cdot 10^{-260}:\\ \;\;\;\;x\\ \mathbf{elif}\;y \leq 4.15 \cdot 10^{+33}:\\ \;\;\;\;a \cdot t\\ \mathbf{else}:\\ \;\;\;\;z \cdot y\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= y -2.05e+77)
   (* z y)
   (if (<= y 1.52e-260) x (if (<= y 4.15e+33) (* a t) (* z y)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (y <= -2.05e+77) {
		tmp = z * y;
	} else if (y <= 1.52e-260) {
		tmp = x;
	} else if (y <= 4.15e+33) {
		tmp = a * t;
	} else {
		tmp = z * y;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (y <= (-2.05d+77)) then
        tmp = z * y
    else if (y <= 1.52d-260) then
        tmp = x
    else if (y <= 4.15d+33) then
        tmp = a * t
    else
        tmp = z * y
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (y <= -2.05e+77) {
		tmp = z * y;
	} else if (y <= 1.52e-260) {
		tmp = x;
	} else if (y <= 4.15e+33) {
		tmp = a * t;
	} else {
		tmp = z * y;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if y <= -2.05e+77:
		tmp = z * y
	elif y <= 1.52e-260:
		tmp = x
	elif y <= 4.15e+33:
		tmp = a * t
	else:
		tmp = z * y
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (y <= -2.05e+77)
		tmp = Float64(z * y);
	elseif (y <= 1.52e-260)
		tmp = x;
	elseif (y <= 4.15e+33)
		tmp = Float64(a * t);
	else
		tmp = Float64(z * y);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (y <= -2.05e+77)
		tmp = z * y;
	elseif (y <= 1.52e-260)
		tmp = x;
	elseif (y <= 4.15e+33)
		tmp = a * t;
	else
		tmp = z * y;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[y, -2.05e+77], N[(z * y), $MachinePrecision], If[LessEqual[y, 1.52e-260], x, If[LessEqual[y, 4.15e+33], N[(a * t), $MachinePrecision], N[(z * y), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if y < -2.05e77 or 4.14999999999999975e33 < y

   1. Initial program 91.4%

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

      1. associate-+l+ 91.4%

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

      2. associate-*l* 92.4%

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

   3. Simplified 92.4%

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

   4. Taylor expanded in y around inf 61.1%

      \[\leadsto \color{blue}{y \cdot z} \]
   5. Step-by-step derivation

      1. *-commutative 61.1%

         \[\leadsto \color{blue}{z \cdot y} \]

   6. Simplified 61.1%

      \[\leadsto \color{blue}{z \cdot y} \]

   if -2.05e77 < y < 1.52e-260

   1. Initial program 89.4%

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

      1. associate-+l+ 89.4%

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

      2. associate-*l* 91.6%

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

   3. Simplified 91.6%

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

   4. Taylor expanded in x around inf 37.1%

      \[\leadsto \color{blue}{x} \]

   if 1.52e-260 < y < 4.14999999999999975e33

   1. Initial program 93.8%

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

      1. associate-+l+ 93.8%

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

      2. associate-*l* 96.7%

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

   3. Simplified 96.7%

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

   4. Taylor expanded in t around inf 40.0%

      \[\leadsto \color{blue}{a \cdot t} \]
3. Recombined 3 regimes into one program.

4. Final simplification 47.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -2.05 \cdot 10^{+77}:\\ \;\;\;\;z \cdot y\\ \mathbf{elif}\;y \leq 1.52 \cdot 10^{-260}:\\ \;\;\;\;x\\ \mathbf{elif}\;y \leq 4.15 \cdot 10^{+33}:\\ \;\;\;\;a \cdot t\\ \mathbf{else}:\\ \;\;\;\;z \cdot y\\ \end{array} \]

Alternative 13: 39.1% accurate, 2.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -3 \cdot 10^{+136}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 7.5 \cdot 10^{-21}:\\ \;\;\;\;a \cdot t\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= x -3e+136) x (if (<= x 7.5e-21) (* a t) x)))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (x <= -3e+136) {
		tmp = x;
	} else if (x <= 7.5e-21) {
		tmp = a * t;
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (x <= (-3d+136)) then
        tmp = x
    else if (x <= 7.5d-21) then
        tmp = a * t
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (x <= -3e+136) {
		tmp = x;
	} else if (x <= 7.5e-21) {
		tmp = a * t;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if x <= -3e+136:
		tmp = x
	elif x <= 7.5e-21:
		tmp = a * t
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (x <= -3e+136)
		tmp = x;
	elseif (x <= 7.5e-21)
		tmp = Float64(a * t);
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (x <= -3e+136)
		tmp = x;
	elseif (x <= 7.5e-21)
		tmp = a * t;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[x, -3e+136], x, If[LessEqual[x, 7.5e-21], N[(a * t), $MachinePrecision], x]]

Derivation

1. Split input into 2 regimes

2. if x < -2.99999999999999979e136 or 7.50000000000000072e-21 < x

   1. Initial program 90.8%

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

      1. associate-+l+ 90.8%

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

      2. associate-*l* 90.9%

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

   3. Simplified 90.9%

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

   4. Taylor expanded in x around inf 50.4%

      \[\leadsto \color{blue}{x} \]

   if -2.99999999999999979e136 < x < 7.50000000000000072e-21

   1. Initial program 91.6%

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

      1. associate-+l+ 91.6%

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

      2. associate-*l* 94.7%

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

   3. Simplified 94.7%

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

   4. Taylor expanded in t around inf 35.1%

      \[\leadsto \color{blue}{a \cdot t} \]
3. Recombined 2 regimes into one program.

4. Final simplification 41.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -3 \cdot 10^{+136}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 7.5 \cdot 10^{-21}:\\ \;\;\;\;a \cdot t\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]

Alternative 14: 26.5% accurate, 15.0× speedup

Math

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

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    code = x
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 91.3%

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

   1. associate-+l+ 91.3%

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

   2. associate-*l* 93.1%

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

3. Simplified 93.1%

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

4. Taylor expanded in x around inf 27.3%

   \[\leadsto \color{blue}{x} \]

5. Final simplification 27.3%

   \[\leadsto x \]

Developer target: 97.3% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := z \cdot \left(b \cdot a + y\right) + \left(x + t \cdot a\right)\\ \mathbf{if}\;z < -11820553527347888000:\\ \;\;\;\;t_1\\ \mathbf{elif}\;z < 4.7589743188364287 \cdot 10^{-122}:\\ \;\;\;\;\left(b \cdot z + t\right) \cdot a + \left(z \cdot y + x\right)\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ (* z (+ (* b a) y)) (+ x (* t a)))))
   (if (< z -11820553527347888000.0)
     t_1
     (if (< z 4.7589743188364287e-122)
       (+ (* (+ (* b z) t) a) (+ (* z y) x))
       t_1))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (z * ((b * a) + y)) + (x + (t * a));
	double tmp;
	if (z < -11820553527347888000.0) {
		tmp = t_1;
	} else if (z < 4.7589743188364287e-122) {
		tmp = (((b * z) + t) * a) + ((z * y) + x);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (z * ((b * a) + y)) + (x + (t * a))
    if (z < (-11820553527347888000.0d0)) then
        tmp = t_1
    else if (z < 4.7589743188364287d-122) then
        tmp = (((b * z) + t) * a) + ((z * y) + x)
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (z * ((b * a) + y)) + (x + (t * a));
	double tmp;
	if (z < -11820553527347888000.0) {
		tmp = t_1;
	} else if (z < 4.7589743188364287e-122) {
		tmp = (((b * z) + t) * a) + ((z * y) + x);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (z * ((b * a) + y)) + (x + (t * a))
	tmp = 0
	if z < -11820553527347888000.0:
		tmp = t_1
	elif z < 4.7589743188364287e-122:
		tmp = (((b * z) + t) * a) + ((z * y) + x)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(z * Float64(Float64(b * a) + y)) + Float64(x + Float64(t * a)))
	tmp = 0.0
	if (z < -11820553527347888000.0)
		tmp = t_1;
	elseif (z < 4.7589743188364287e-122)
		tmp = Float64(Float64(Float64(Float64(b * z) + t) * a) + Float64(Float64(z * y) + x));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (z * ((b * a) + y)) + (x + (t * a));
	tmp = 0.0;
	if (z < -11820553527347888000.0)
		tmp = t_1;
	elseif (z < 4.7589743188364287e-122)
		tmp = (((b * z) + t) * a) + ((z * y) + x);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(z * N[(N[(b * a), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision] + N[(x + N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[z, -11820553527347888000.0], t$95$1, If[Less[z, 4.7589743188364287e-122], N[(N[(N[(N[(b * z), $MachinePrecision] + t), $MachinePrecision] * a), $MachinePrecision] + N[(N[(z * y), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision], t$95$1]]]

Reproduce

herbie shell --seed 2023228 
(FPCore (x y z t a b)
  :name "Graphics.Rasterific.CubicBezier:cachedBezierAt from Rasterific-0.6.1"
  :precision binary64

  :herbie-target
  (if (< z -11820553527347888000.0) (+ (* z (+ (* b a) y)) (+ x (* t a))) (if (< z 4.7589743188364287e-122) (+ (* (+ (* b z) t) a) (+ (* z y) x)) (+ (* z (+ (* b a) y)) (+ x (* t a)))))

  (+ (+ (+ x (* y z)) (* t a)) (* (* a z) b)))