Diagrams.Solve.Polynomial:quartForm from diagrams-solve-0.1, C

Percentage Accurate: 97.7% → 98.9%

Time: 8.4s

Alternatives: 12

Speedup: 1.0×

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

Specification

Math

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

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (+ (- (+ (* x y) (/ (* z t) 16.0)) (/ (* a b) 4.0)) c))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	return (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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
    code = (((x * y) + ((z * t) / 16.0d0)) - ((a * b) / 4.0d0)) + c
end function

Java

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

Python

def code(x, y, z, t, a, b, c):
	return (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c

Julia

function code(x, y, z, t, a, b, c)
	return Float64(Float64(Float64(Float64(x * y) + Float64(Float64(z * t) / 16.0)) - Float64(Float64(a * b) / 4.0)) + c)
end

MATLAB

function tmp = code(x, y, z, t, a, b, c)
	tmp = (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c;
end

Wolfram

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

Initial Program: 97.7% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (+ (- (+ (* x y) (/ (* z t) 16.0)) (/ (* a b) 4.0)) c))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	return (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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
    code = (((x * y) + ((z * t) / 16.0d0)) - ((a * b) / 4.0d0)) + c
end function

Java

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

Python

def code(x, y, z, t, a, b, c):
	return (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c

Julia

function code(x, y, z, t, a, b, c)
	return Float64(Float64(Float64(Float64(x * y) + Float64(Float64(z * t) / 16.0)) - Float64(Float64(a * b) / 4.0)) + c)
end

MATLAB

function tmp = code(x, y, z, t, a, b, c)
	tmp = (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c;
end

Wolfram

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

Alternative 1: 98.9% accurate, 0.1× speedup

Math

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

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (+ (fma x y (fma z (* t 0.0625) (* b (* a -0.25)))) c))

C

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

Julia

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

Wolfram

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

Derivation

1. Initial program 98.4%

   \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
2. Step-by-step derivation

   1. associate--l+ 98.4%

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

3. Simplified 100.0%

   \[\leadsto \color{blue}{\mathsf{fma}\left(x, y, \mathsf{fma}\left(z, t \cdot 0.0625, b \cdot \left(a \cdot -0.25\right)\right)\right) + c} \]
4. Add Preprocessing
5. Add Preprocessing

Alternative 2: 64.0% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := c + a \cdot \left(b \cdot -0.25\right)\\ t_2 := c + 0.0625 \cdot \left(z \cdot t\right)\\ \mathbf{if}\;x \cdot y \leq -4.3 \cdot 10^{+106}:\\ \;\;\;\;c + x \cdot y\\ \mathbf{elif}\;x \cdot y \leq -7.6 \cdot 10^{-147}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \cdot y \leq 5.9 \cdot 10^{-282}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;x \cdot y \leq 1.75 \cdot 10^{-146}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \cdot y \leq 2.5 \cdot 10^{+18}:\\ \;\;\;\;t\_2\\ \mathbf{else}:\\ \;\;\;\;b \cdot \left(\frac{x \cdot y}{b} - a \cdot 0.25\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (let* ((t_1 (+ c (* a (* b -0.25)))) (t_2 (+ c (* 0.0625 (* z t)))))
   (if (<= (* x y) -4.3e+106)
     (+ c (* x y))
     (if (<= (* x y) -7.6e-147)
       t_1
       (if (<= (* x y) 5.9e-282)
         t_2
         (if (<= (* x y) 1.75e-146)
           t_1
           (if (<= (* x y) 2.5e+18)
             t_2
             (* b (- (/ (* x y) b) (* a 0.25))))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = c + (a * (b * -0.25));
	double t_2 = c + (0.0625 * (z * t));
	double tmp;
	if ((x * y) <= -4.3e+106) {
		tmp = c + (x * y);
	} else if ((x * y) <= -7.6e-147) {
		tmp = t_1;
	} else if ((x * y) <= 5.9e-282) {
		tmp = t_2;
	} else if ((x * y) <= 1.75e-146) {
		tmp = t_1;
	} else if ((x * y) <= 2.5e+18) {
		tmp = t_2;
	} else {
		tmp = b * (((x * y) / b) - (a * 0.25));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = c + (a * (b * (-0.25d0)))
    t_2 = c + (0.0625d0 * (z * t))
    if ((x * y) <= (-4.3d+106)) then
        tmp = c + (x * y)
    else if ((x * y) <= (-7.6d-147)) then
        tmp = t_1
    else if ((x * y) <= 5.9d-282) then
        tmp = t_2
    else if ((x * y) <= 1.75d-146) then
        tmp = t_1
    else if ((x * y) <= 2.5d+18) then
        tmp = t_2
    else
        tmp = b * (((x * y) / b) - (a * 0.25d0))
    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 t_1 = c + (a * (b * -0.25));
	double t_2 = c + (0.0625 * (z * t));
	double tmp;
	if ((x * y) <= -4.3e+106) {
		tmp = c + (x * y);
	} else if ((x * y) <= -7.6e-147) {
		tmp = t_1;
	} else if ((x * y) <= 5.9e-282) {
		tmp = t_2;
	} else if ((x * y) <= 1.75e-146) {
		tmp = t_1;
	} else if ((x * y) <= 2.5e+18) {
		tmp = t_2;
	} else {
		tmp = b * (((x * y) / b) - (a * 0.25));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	t_1 = c + (a * (b * -0.25))
	t_2 = c + (0.0625 * (z * t))
	tmp = 0
	if (x * y) <= -4.3e+106:
		tmp = c + (x * y)
	elif (x * y) <= -7.6e-147:
		tmp = t_1
	elif (x * y) <= 5.9e-282:
		tmp = t_2
	elif (x * y) <= 1.75e-146:
		tmp = t_1
	elif (x * y) <= 2.5e+18:
		tmp = t_2
	else:
		tmp = b * (((x * y) / b) - (a * 0.25))
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(c + Float64(a * Float64(b * -0.25)))
	t_2 = Float64(c + Float64(0.0625 * Float64(z * t)))
	tmp = 0.0
	if (Float64(x * y) <= -4.3e+106)
		tmp = Float64(c + Float64(x * y));
	elseif (Float64(x * y) <= -7.6e-147)
		tmp = t_1;
	elseif (Float64(x * y) <= 5.9e-282)
		tmp = t_2;
	elseif (Float64(x * y) <= 1.75e-146)
		tmp = t_1;
	elseif (Float64(x * y) <= 2.5e+18)
		tmp = t_2;
	else
		tmp = Float64(b * Float64(Float64(Float64(x * y) / b) - Float64(a * 0.25)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	t_1 = c + (a * (b * -0.25));
	t_2 = c + (0.0625 * (z * t));
	tmp = 0.0;
	if ((x * y) <= -4.3e+106)
		tmp = c + (x * y);
	elseif ((x * y) <= -7.6e-147)
		tmp = t_1;
	elseif ((x * y) <= 5.9e-282)
		tmp = t_2;
	elseif ((x * y) <= 1.75e-146)
		tmp = t_1;
	elseif ((x * y) <= 2.5e+18)
		tmp = t_2;
	else
		tmp = b * (((x * y) / b) - (a * 0.25));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(c + N[(a * N[(b * -0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(c + N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(x * y), $MachinePrecision], -4.3e+106], N[(c + N[(x * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], -7.6e-147], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], 5.9e-282], t$95$2, If[LessEqual[N[(x * y), $MachinePrecision], 1.75e-146], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], 2.5e+18], t$95$2, N[(b * N[(N[(N[(x * y), $MachinePrecision] / b), $MachinePrecision] - N[(a * 0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if (*.f64 x y) < -4.3e106

   1. Initial program 98.0%

      \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 90.1%

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

   if -4.3e106 < (*.f64 x y) < -7.60000000000000055e-147 or 5.8999999999999997e-282 < (*.f64 x y) < 1.7500000000000001e-146

   1. Initial program 98.5%

      \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
   2. Add Preprocessing

   3. Taylor expanded in a around inf 79.8%

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

      1. *-commutative 79.8%

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

      2. associate-*r* 79.8%

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

   5. Simplified 79.8%

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

   if -7.60000000000000055e-147 < (*.f64 x y) < 5.8999999999999997e-282 or 1.7500000000000001e-146 < (*.f64 x y) < 2.5e18

   1. Initial program 100.0%

      \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 78.9%

      \[\leadsto \color{blue}{0.0625 \cdot \left(t \cdot z\right)} + c \]

   if 2.5e18 < (*.f64 x y)

   1. Initial program 96.4%

      \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
   2. Add Preprocessing

   3. Taylor expanded in z around 0 82.8%

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

   4. Taylor expanded in b around inf 67.8%

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

   5. Taylor expanded in c around 0 64.1%

      \[\leadsto \color{blue}{b \cdot \left(\frac{x \cdot y}{b} - 0.25 \cdot a\right)} \]
3. Recombined 4 regimes into one program.

4. Final simplification 78.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \cdot y \leq -4.3 \cdot 10^{+106}:\\ \;\;\;\;c + x \cdot y\\ \mathbf{elif}\;x \cdot y \leq -7.6 \cdot 10^{-147}:\\ \;\;\;\;c + a \cdot \left(b \cdot -0.25\right)\\ \mathbf{elif}\;x \cdot y \leq 5.9 \cdot 10^{-282}:\\ \;\;\;\;c + 0.0625 \cdot \left(z \cdot t\right)\\ \mathbf{elif}\;x \cdot y \leq 1.75 \cdot 10^{-146}:\\ \;\;\;\;c + a \cdot \left(b \cdot -0.25\right)\\ \mathbf{elif}\;x \cdot y \leq 2.5 \cdot 10^{+18}:\\ \;\;\;\;c + 0.0625 \cdot \left(z \cdot t\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot \left(\frac{x \cdot y}{b} - a \cdot 0.25\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 65.0% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := c + a \cdot \left(b \cdot -0.25\right)\\ t_2 := c + 0.0625 \cdot \left(z \cdot t\right)\\ t_3 := c + x \cdot y\\ \mathbf{if}\;x \cdot y \leq -7 \cdot 10^{+100}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;x \cdot y \leq -4.2 \cdot 10^{-147}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \cdot y \leq 1.45 \cdot 10^{-283}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;x \cdot y \leq 1.35 \cdot 10^{-146}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \cdot y \leq 4.2 \cdot 10^{+23}:\\ \;\;\;\;t\_2\\ \mathbf{else}:\\ \;\;\;\;t\_3\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (let* ((t_1 (+ c (* a (* b -0.25))))
        (t_2 (+ c (* 0.0625 (* z t))))
        (t_3 (+ c (* x y))))
   (if (<= (* x y) -7e+100)
     t_3
     (if (<= (* x y) -4.2e-147)
       t_1
       (if (<= (* x y) 1.45e-283)
         t_2
         (if (<= (* x y) 1.35e-146) t_1 (if (<= (* x y) 4.2e+23) t_2 t_3)))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = c + (a * (b * -0.25));
	double t_2 = c + (0.0625 * (z * t));
	double t_3 = c + (x * y);
	double tmp;
	if ((x * y) <= -7e+100) {
		tmp = t_3;
	} else if ((x * y) <= -4.2e-147) {
		tmp = t_1;
	} else if ((x * y) <= 1.45e-283) {
		tmp = t_2;
	} else if ((x * y) <= 1.35e-146) {
		tmp = t_1;
	} else if ((x * y) <= 4.2e+23) {
		tmp = t_2;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_1 = c + (a * (b * (-0.25d0)))
    t_2 = c + (0.0625d0 * (z * t))
    t_3 = c + (x * y)
    if ((x * y) <= (-7d+100)) then
        tmp = t_3
    else if ((x * y) <= (-4.2d-147)) then
        tmp = t_1
    else if ((x * y) <= 1.45d-283) then
        tmp = t_2
    else if ((x * y) <= 1.35d-146) then
        tmp = t_1
    else if ((x * y) <= 4.2d+23) then
        tmp = t_2
    else
        tmp = t_3
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = c + (a * (b * -0.25));
	double t_2 = c + (0.0625 * (z * t));
	double t_3 = c + (x * y);
	double tmp;
	if ((x * y) <= -7e+100) {
		tmp = t_3;
	} else if ((x * y) <= -4.2e-147) {
		tmp = t_1;
	} else if ((x * y) <= 1.45e-283) {
		tmp = t_2;
	} else if ((x * y) <= 1.35e-146) {
		tmp = t_1;
	} else if ((x * y) <= 4.2e+23) {
		tmp = t_2;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	t_1 = c + (a * (b * -0.25))
	t_2 = c + (0.0625 * (z * t))
	t_3 = c + (x * y)
	tmp = 0
	if (x * y) <= -7e+100:
		tmp = t_3
	elif (x * y) <= -4.2e-147:
		tmp = t_1
	elif (x * y) <= 1.45e-283:
		tmp = t_2
	elif (x * y) <= 1.35e-146:
		tmp = t_1
	elif (x * y) <= 4.2e+23:
		tmp = t_2
	else:
		tmp = t_3
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(c + Float64(a * Float64(b * -0.25)))
	t_2 = Float64(c + Float64(0.0625 * Float64(z * t)))
	t_3 = Float64(c + Float64(x * y))
	tmp = 0.0
	if (Float64(x * y) <= -7e+100)
		tmp = t_3;
	elseif (Float64(x * y) <= -4.2e-147)
		tmp = t_1;
	elseif (Float64(x * y) <= 1.45e-283)
		tmp = t_2;
	elseif (Float64(x * y) <= 1.35e-146)
		tmp = t_1;
	elseif (Float64(x * y) <= 4.2e+23)
		tmp = t_2;
	else
		tmp = t_3;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	t_1 = c + (a * (b * -0.25));
	t_2 = c + (0.0625 * (z * t));
	t_3 = c + (x * y);
	tmp = 0.0;
	if ((x * y) <= -7e+100)
		tmp = t_3;
	elseif ((x * y) <= -4.2e-147)
		tmp = t_1;
	elseif ((x * y) <= 1.45e-283)
		tmp = t_2;
	elseif ((x * y) <= 1.35e-146)
		tmp = t_1;
	elseif ((x * y) <= 4.2e+23)
		tmp = t_2;
	else
		tmp = t_3;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(c + N[(a * N[(b * -0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(c + N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(c + N[(x * y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(x * y), $MachinePrecision], -7e+100], t$95$3, If[LessEqual[N[(x * y), $MachinePrecision], -4.2e-147], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], 1.45e-283], t$95$2, If[LessEqual[N[(x * y), $MachinePrecision], 1.35e-146], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], 4.2e+23], t$95$2, t$95$3]]]]]]]]

Derivation

1. Split input into 3 regimes

2. if (*.f64 x y) < -6.99999999999999953e100 or 4.2000000000000003e23 < (*.f64 x y)

   1. Initial program 97.1%

      \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 76.7%

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

   if -6.99999999999999953e100 < (*.f64 x y) < -4.2e-147 or 1.44999999999999994e-283 < (*.f64 x y) < 1.34999999999999997e-146

   1. Initial program 98.5%

      \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
   2. Add Preprocessing

   3. Taylor expanded in a around inf 79.8%

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

      1. *-commutative 79.8%

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

      2. associate-*r* 79.8%

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

   5. Simplified 79.8%

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

   if -4.2e-147 < (*.f64 x y) < 1.44999999999999994e-283 or 1.34999999999999997e-146 < (*.f64 x y) < 4.2000000000000003e23

   1. Initial program 100.0%

      \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 78.2%

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

4. Final simplification 78.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \cdot y \leq -7 \cdot 10^{+100}:\\ \;\;\;\;c + x \cdot y\\ \mathbf{elif}\;x \cdot y \leq -4.2 \cdot 10^{-147}:\\ \;\;\;\;c + a \cdot \left(b \cdot -0.25\right)\\ \mathbf{elif}\;x \cdot y \leq 1.45 \cdot 10^{-283}:\\ \;\;\;\;c + 0.0625 \cdot \left(z \cdot t\right)\\ \mathbf{elif}\;x \cdot y \leq 1.35 \cdot 10^{-146}:\\ \;\;\;\;c + a \cdot \left(b \cdot -0.25\right)\\ \mathbf{elif}\;x \cdot y \leq 4.2 \cdot 10^{+23}:\\ \;\;\;\;c + 0.0625 \cdot \left(z \cdot t\right)\\ \mathbf{else}:\\ \;\;\;\;c + x \cdot y\\ \end{array} \]
5. Add Preprocessing

Alternative 4: 89.4% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := 0.0625 \cdot \left(z \cdot t\right)\\ t_2 := \left(b \cdot a\right) \cdot 0.25\\ \mathbf{if}\;x \cdot y \leq -1.05 \cdot 10^{+90}:\\ \;\;\;\;c + \left(x \cdot y + t\_1\right)\\ \mathbf{elif}\;x \cdot y \leq 5 \cdot 10^{+23}:\\ \;\;\;\;c + \left(t\_1 - t\_2\right)\\ \mathbf{else}:\\ \;\;\;\;c + \left(x \cdot y - t\_2\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (let* ((t_1 (* 0.0625 (* z t))) (t_2 (* (* b a) 0.25)))
   (if (<= (* x y) -1.05e+90)
     (+ c (+ (* x y) t_1))
     (if (<= (* x y) 5e+23) (+ c (- t_1 t_2)) (+ c (- (* x y) t_2))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = 0.0625 * (z * t);
	double t_2 = (b * a) * 0.25;
	double tmp;
	if ((x * y) <= -1.05e+90) {
		tmp = c + ((x * y) + t_1);
	} else if ((x * y) <= 5e+23) {
		tmp = c + (t_1 - t_2);
	} else {
		tmp = c + ((x * y) - t_2);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = 0.0625d0 * (z * t)
    t_2 = (b * a) * 0.25d0
    if ((x * y) <= (-1.05d+90)) then
        tmp = c + ((x * y) + t_1)
    else if ((x * y) <= 5d+23) then
        tmp = c + (t_1 - t_2)
    else
        tmp = c + ((x * y) - t_2)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = 0.0625 * (z * t);
	double t_2 = (b * a) * 0.25;
	double tmp;
	if ((x * y) <= -1.05e+90) {
		tmp = c + ((x * y) + t_1);
	} else if ((x * y) <= 5e+23) {
		tmp = c + (t_1 - t_2);
	} else {
		tmp = c + ((x * y) - t_2);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	t_1 = 0.0625 * (z * t)
	t_2 = (b * a) * 0.25
	tmp = 0
	if (x * y) <= -1.05e+90:
		tmp = c + ((x * y) + t_1)
	elif (x * y) <= 5e+23:
		tmp = c + (t_1 - t_2)
	else:
		tmp = c + ((x * y) - t_2)
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(0.0625 * Float64(z * t))
	t_2 = Float64(Float64(b * a) * 0.25)
	tmp = 0.0
	if (Float64(x * y) <= -1.05e+90)
		tmp = Float64(c + Float64(Float64(x * y) + t_1));
	elseif (Float64(x * y) <= 5e+23)
		tmp = Float64(c + Float64(t_1 - t_2));
	else
		tmp = Float64(c + Float64(Float64(x * y) - t_2));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	t_1 = 0.0625 * (z * t);
	t_2 = (b * a) * 0.25;
	tmp = 0.0;
	if ((x * y) <= -1.05e+90)
		tmp = c + ((x * y) + t_1);
	elseif ((x * y) <= 5e+23)
		tmp = c + (t_1 - t_2);
	else
		tmp = c + ((x * y) - t_2);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(b * a), $MachinePrecision] * 0.25), $MachinePrecision]}, If[LessEqual[N[(x * y), $MachinePrecision], -1.05e+90], N[(c + N[(N[(x * y), $MachinePrecision] + t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 5e+23], N[(c + N[(t$95$1 - t$95$2), $MachinePrecision]), $MachinePrecision], N[(c + N[(N[(x * y), $MachinePrecision] - t$95$2), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

1. Split input into 3 regimes

2. if (*.f64 x y) < -1.0499999999999999e90

   1. Initial program 98.1%

      \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
   2. Add Preprocessing

   3. Taylor expanded in a around 0 98.0%

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

   if -1.0499999999999999e90 < (*.f64 x y) < 4.9999999999999999e23

   1. Initial program 99.3%

      \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0 98.0%

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

   if 4.9999999999999999e23 < (*.f64 x y)

   1. Initial program 96.3%

      \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
   2. Add Preprocessing

   3. Taylor expanded in z around 0 84.0%

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

4. Final simplification 95.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \cdot y \leq -1.05 \cdot 10^{+90}:\\ \;\;\;\;c + \left(x \cdot y + 0.0625 \cdot \left(z \cdot t\right)\right)\\ \mathbf{elif}\;x \cdot y \leq 5 \cdot 10^{+23}:\\ \;\;\;\;c + \left(0.0625 \cdot \left(z \cdot t\right) - \left(b \cdot a\right) \cdot 0.25\right)\\ \mathbf{else}:\\ \;\;\;\;c + \left(x \cdot y - \left(b \cdot a\right) \cdot 0.25\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 5: 89.7% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b \cdot a \leq -5 \cdot 10^{+60}:\\ \;\;\;\;c + \left(x \cdot y - \left(b \cdot a\right) \cdot 0.25\right)\\ \mathbf{elif}\;b \cdot a \leq 2 \cdot 10^{+98}:\\ \;\;\;\;c + \left(x \cdot y + 0.0625 \cdot \left(z \cdot t\right)\right)\\ \mathbf{else}:\\ \;\;\;\;c + b \cdot \left(\frac{x \cdot y}{b} - a \cdot 0.25\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (if (<= (* b a) -5e+60)
   (+ c (- (* x y) (* (* b a) 0.25)))
   (if (<= (* b a) 2e+98)
     (+ c (+ (* x y) (* 0.0625 (* z t))))
     (+ c (* b (- (/ (* x y) b) (* a 0.25)))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if ((b * a) <= -5e+60) {
		tmp = c + ((x * y) - ((b * a) * 0.25));
	} else if ((b * a) <= 2e+98) {
		tmp = c + ((x * y) + (0.0625 * (z * t)));
	} else {
		tmp = c + (b * (((x * y) / b) - (a * 0.25)));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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) :: tmp
    if ((b * a) <= (-5d+60)) then
        tmp = c + ((x * y) - ((b * a) * 0.25d0))
    else if ((b * a) <= 2d+98) then
        tmp = c + ((x * y) + (0.0625d0 * (z * t)))
    else
        tmp = c + (b * (((x * y) / b) - (a * 0.25d0)))
    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 tmp;
	if ((b * a) <= -5e+60) {
		tmp = c + ((x * y) - ((b * a) * 0.25));
	} else if ((b * a) <= 2e+98) {
		tmp = c + ((x * y) + (0.0625 * (z * t)));
	} else {
		tmp = c + (b * (((x * y) / b) - (a * 0.25)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	tmp = 0
	if (b * a) <= -5e+60:
		tmp = c + ((x * y) - ((b * a) * 0.25))
	elif (b * a) <= 2e+98:
		tmp = c + ((x * y) + (0.0625 * (z * t)))
	else:
		tmp = c + (b * (((x * y) / b) - (a * 0.25)))
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	tmp = 0.0
	if (Float64(b * a) <= -5e+60)
		tmp = Float64(c + Float64(Float64(x * y) - Float64(Float64(b * a) * 0.25)));
	elseif (Float64(b * a) <= 2e+98)
		tmp = Float64(c + Float64(Float64(x * y) + Float64(0.0625 * Float64(z * t))));
	else
		tmp = Float64(c + Float64(b * Float64(Float64(Float64(x * y) / b) - Float64(a * 0.25))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	tmp = 0.0;
	if ((b * a) <= -5e+60)
		tmp = c + ((x * y) - ((b * a) * 0.25));
	elseif ((b * a) <= 2e+98)
		tmp = c + ((x * y) + (0.0625 * (z * t)));
	else
		tmp = c + (b * (((x * y) / b) - (a * 0.25)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[N[(b * a), $MachinePrecision], -5e+60], N[(c + N[(N[(x * y), $MachinePrecision] - N[(N[(b * a), $MachinePrecision] * 0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b * a), $MachinePrecision], 2e+98], N[(c + N[(N[(x * y), $MachinePrecision] + N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(c + N[(b * N[(N[(N[(x * y), $MachinePrecision] / b), $MachinePrecision] - N[(a * 0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if (*.f64 a b) < -4.99999999999999975e60

   1. Initial program 98.1%

      \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
   2. Add Preprocessing

   3. Taylor expanded in z around 0 89.3%

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

   if -4.99999999999999975e60 < (*.f64 a b) < 2e98

   1. Initial program 99.4%

      \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
   2. Add Preprocessing

   3. Taylor expanded in a around 0 95.7%

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

   if 2e98 < (*.f64 a b)

   1. Initial program 93.3%

      \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
   2. Add Preprocessing

   3. Taylor expanded in z around 0 87.1%

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

   4. Taylor expanded in b around inf 87.1%

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

4. Final simplification 93.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \cdot a \leq -5 \cdot 10^{+60}:\\ \;\;\;\;c + \left(x \cdot y - \left(b \cdot a\right) \cdot 0.25\right)\\ \mathbf{elif}\;b \cdot a \leq 2 \cdot 10^{+98}:\\ \;\;\;\;c + \left(x \cdot y + 0.0625 \cdot \left(z \cdot t\right)\right)\\ \mathbf{else}:\\ \;\;\;\;c + b \cdot \left(\frac{x \cdot y}{b} - a \cdot 0.25\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 6: 89.6% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b \cdot a \leq -5 \cdot 10^{+60} \lor \neg \left(b \cdot a \leq 2 \cdot 10^{+98}\right):\\ \;\;\;\;c + \left(x \cdot y - \left(b \cdot a\right) \cdot 0.25\right)\\ \mathbf{else}:\\ \;\;\;\;c + \left(x \cdot y + 0.0625 \cdot \left(z \cdot t\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (if (or (<= (* b a) -5e+60) (not (<= (* b a) 2e+98)))
   (+ c (- (* x y) (* (* b a) 0.25)))
   (+ c (+ (* x y) (* 0.0625 (* z t))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if (((b * a) <= -5e+60) || !((b * a) <= 2e+98)) {
		tmp = c + ((x * y) - ((b * a) * 0.25));
	} else {
		tmp = c + ((x * y) + (0.0625 * (z * t)));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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) :: tmp
    if (((b * a) <= (-5d+60)) .or. (.not. ((b * a) <= 2d+98))) then
        tmp = c + ((x * y) - ((b * a) * 0.25d0))
    else
        tmp = c + ((x * y) + (0.0625d0 * (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 tmp;
	if (((b * a) <= -5e+60) || !((b * a) <= 2e+98)) {
		tmp = c + ((x * y) - ((b * a) * 0.25));
	} else {
		tmp = c + ((x * y) + (0.0625 * (z * t)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	tmp = 0
	if ((b * a) <= -5e+60) or not ((b * a) <= 2e+98):
		tmp = c + ((x * y) - ((b * a) * 0.25))
	else:
		tmp = c + ((x * y) + (0.0625 * (z * t)))
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	tmp = 0.0
	if ((Float64(b * a) <= -5e+60) || !(Float64(b * a) <= 2e+98))
		tmp = Float64(c + Float64(Float64(x * y) - Float64(Float64(b * a) * 0.25)));
	else
		tmp = Float64(c + Float64(Float64(x * y) + Float64(0.0625 * Float64(z * t))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	tmp = 0.0;
	if (((b * a) <= -5e+60) || ~(((b * a) <= 2e+98)))
		tmp = c + ((x * y) - ((b * a) * 0.25));
	else
		tmp = c + ((x * y) + (0.0625 * (z * t)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := If[Or[LessEqual[N[(b * a), $MachinePrecision], -5e+60], N[Not[LessEqual[N[(b * a), $MachinePrecision], 2e+98]], $MachinePrecision]], N[(c + N[(N[(x * y), $MachinePrecision] - N[(N[(b * a), $MachinePrecision] * 0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(c + N[(N[(x * y), $MachinePrecision] + N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if (*.f64 a b) < -4.99999999999999975e60 or 2e98 < (*.f64 a b)

   1. Initial program 96.4%

      \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
   2. Add Preprocessing

   3. Taylor expanded in z around 0 88.5%

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

   if -4.99999999999999975e60 < (*.f64 a b) < 2e98

   1. Initial program 99.4%

      \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
   2. Add Preprocessing

   3. Taylor expanded in a around 0 95.7%

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

4. Final simplification 93.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \cdot a \leq -5 \cdot 10^{+60} \lor \neg \left(b \cdot a \leq 2 \cdot 10^{+98}\right):\\ \;\;\;\;c + \left(x \cdot y - \left(b \cdot a\right) \cdot 0.25\right)\\ \mathbf{else}:\\ \;\;\;\;c + \left(x \cdot y + 0.0625 \cdot \left(z \cdot t\right)\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 7: 64.8% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \cdot y \leq -6 \cdot 10^{+103} \lor \neg \left(x \cdot y \leq 4.8 \cdot 10^{+23}\right):\\ \;\;\;\;c + x \cdot y\\ \mathbf{else}:\\ \;\;\;\;c + 0.0625 \cdot \left(z \cdot t\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (if (or (<= (* x y) -6e+103) (not (<= (* x y) 4.8e+23)))
   (+ c (* x y))
   (+ c (* 0.0625 (* z t)))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if (((x * y) <= -6e+103) || !((x * y) <= 4.8e+23)) {
		tmp = c + (x * y);
	} else {
		tmp = c + (0.0625 * (z * t));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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) :: tmp
    if (((x * y) <= (-6d+103)) .or. (.not. ((x * y) <= 4.8d+23))) then
        tmp = c + (x * y)
    else
        tmp = c + (0.0625d0 * (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 tmp;
	if (((x * y) <= -6e+103) || !((x * y) <= 4.8e+23)) {
		tmp = c + (x * y);
	} else {
		tmp = c + (0.0625 * (z * t));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	tmp = 0
	if ((x * y) <= -6e+103) or not ((x * y) <= 4.8e+23):
		tmp = c + (x * y)
	else:
		tmp = c + (0.0625 * (z * t))
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	tmp = 0.0
	if ((Float64(x * y) <= -6e+103) || !(Float64(x * y) <= 4.8e+23))
		tmp = Float64(c + Float64(x * y));
	else
		tmp = Float64(c + Float64(0.0625 * Float64(z * t)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	tmp = 0.0;
	if (((x * y) <= -6e+103) || ~(((x * y) <= 4.8e+23)))
		tmp = c + (x * y);
	else
		tmp = c + (0.0625 * (z * t));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := If[Or[LessEqual[N[(x * y), $MachinePrecision], -6e+103], N[Not[LessEqual[N[(x * y), $MachinePrecision], 4.8e+23]], $MachinePrecision]], N[(c + N[(x * y), $MachinePrecision]), $MachinePrecision], N[(c + N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if (*.f64 x y) < -6e103 or 4.8e23 < (*.f64 x y)

   1. Initial program 97.1%

      \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 76.7%

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

   if -6e103 < (*.f64 x y) < 4.8e23

   1. Initial program 99.3%

      \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf 69.0%

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

4. Final simplification 72.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \cdot y \leq -6 \cdot 10^{+103} \lor \neg \left(x \cdot y \leq 4.8 \cdot 10^{+23}\right):\\ \;\;\;\;c + x \cdot y\\ \mathbf{else}:\\ \;\;\;\;c + 0.0625 \cdot \left(z \cdot t\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 8: 75.8% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b \leq -1.95 \cdot 10^{-50}:\\ \;\;\;\;c + a \cdot \left(b \cdot -0.25\right)\\ \mathbf{elif}\;b \leq 1.85 \cdot 10^{+205}:\\ \;\;\;\;c + \left(x \cdot y + 0.0625 \cdot \left(z \cdot t\right)\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot \left(\frac{x \cdot y}{b} - a \cdot 0.25\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (if (<= b -1.95e-50)
   (+ c (* a (* b -0.25)))
   (if (<= b 1.85e+205)
     (+ c (+ (* x y) (* 0.0625 (* z t))))
     (* b (- (/ (* x y) b) (* a 0.25))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if (b <= -1.95e-50) {
		tmp = c + (a * (b * -0.25));
	} else if (b <= 1.85e+205) {
		tmp = c + ((x * y) + (0.0625 * (z * t)));
	} else {
		tmp = b * (((x * y) / b) - (a * 0.25));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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) :: tmp
    if (b <= (-1.95d-50)) then
        tmp = c + (a * (b * (-0.25d0)))
    else if (b <= 1.85d+205) then
        tmp = c + ((x * y) + (0.0625d0 * (z * t)))
    else
        tmp = b * (((x * y) / b) - (a * 0.25d0))
    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 tmp;
	if (b <= -1.95e-50) {
		tmp = c + (a * (b * -0.25));
	} else if (b <= 1.85e+205) {
		tmp = c + ((x * y) + (0.0625 * (z * t)));
	} else {
		tmp = b * (((x * y) / b) - (a * 0.25));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	tmp = 0
	if b <= -1.95e-50:
		tmp = c + (a * (b * -0.25))
	elif b <= 1.85e+205:
		tmp = c + ((x * y) + (0.0625 * (z * t)))
	else:
		tmp = b * (((x * y) / b) - (a * 0.25))
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	tmp = 0.0
	if (b <= -1.95e-50)
		tmp = Float64(c + Float64(a * Float64(b * -0.25)));
	elseif (b <= 1.85e+205)
		tmp = Float64(c + Float64(Float64(x * y) + Float64(0.0625 * Float64(z * t))));
	else
		tmp = Float64(b * Float64(Float64(Float64(x * y) / b) - Float64(a * 0.25)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	tmp = 0.0;
	if (b <= -1.95e-50)
		tmp = c + (a * (b * -0.25));
	elseif (b <= 1.85e+205)
		tmp = c + ((x * y) + (0.0625 * (z * t)));
	else
		tmp = b * (((x * y) / b) - (a * 0.25));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[b, -1.95e-50], N[(c + N[(a * N[(b * -0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.85e+205], N[(c + N[(N[(x * y), $MachinePrecision] + N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(b * N[(N[(N[(x * y), $MachinePrecision] / b), $MachinePrecision] - N[(a * 0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if b < -1.9500000000000001e-50

   1. Initial program 97.7%

      \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
   2. Add Preprocessing

   3. Taylor expanded in a around inf 51.4%

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

      1. *-commutative 51.4%

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

      2. associate-*r* 51.4%

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

   5. Simplified 51.4%

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

   if -1.9500000000000001e-50 < b < 1.8499999999999999e205

   1. Initial program 99.3%

      \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
   2. Add Preprocessing

   3. Taylor expanded in a around 0 89.7%

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

   if 1.8499999999999999e205 < b

   1. Initial program 95.0%

      \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
   2. Add Preprocessing

   3. Taylor expanded in z around 0 85.8%

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

   4. Taylor expanded in b around inf 85.8%

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

   5. Taylor expanded in c around 0 81.2%

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

4. Final simplification 76.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -1.95 \cdot 10^{-50}:\\ \;\;\;\;c + a \cdot \left(b \cdot -0.25\right)\\ \mathbf{elif}\;b \leq 1.85 \cdot 10^{+205}:\\ \;\;\;\;c + \left(x \cdot y + 0.0625 \cdot \left(z \cdot t\right)\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot \left(\frac{x \cdot y}{b} - a \cdot 0.25\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 9: 97.7% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (+ c (- (+ (* x y) (/ (* z t) 16.0)) (/ (* b a) 4.0))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	return c + (((x * y) + ((z * t) / 16.0)) - ((b * a) / 4.0));
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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
    code = c + (((x * y) + ((z * t) / 16.0d0)) - ((b * a) / 4.0d0))
end function

Java

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

Python

def code(x, y, z, t, a, b, c):
	return c + (((x * y) + ((z * t) / 16.0)) - ((b * a) / 4.0))

Julia

function code(x, y, z, t, a, b, c)
	return Float64(c + Float64(Float64(Float64(x * y) + Float64(Float64(z * t) / 16.0)) - Float64(Float64(b * a) / 4.0)))
end

MATLAB

function tmp = code(x, y, z, t, a, b, c)
	tmp = c + (((x * y) + ((z * t) / 16.0)) - ((b * a) / 4.0));
end

Wolfram

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

Derivation

1. Initial program 98.4%

   \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
2. Add Preprocessing

3. Final simplification 98.4%

   \[\leadsto c + \left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{b \cdot a}{4}\right) \]
4. Add Preprocessing

Alternative 10: 53.1% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b \leq -1.95 \cdot 10^{-50} \lor \neg \left(b \leq 2.4 \cdot 10^{+189}\right):\\ \;\;\;\;b \cdot \left(a \cdot -0.25\right)\\ \mathbf{else}:\\ \;\;\;\;c + x \cdot y\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (if (or (<= b -1.95e-50) (not (<= b 2.4e+189)))
   (* b (* a -0.25))
   (+ c (* x y))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if ((b <= -1.95e-50) || !(b <= 2.4e+189)) {
		tmp = b * (a * -0.25);
	} else {
		tmp = c + (x * y);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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) :: tmp
    if ((b <= (-1.95d-50)) .or. (.not. (b <= 2.4d+189))) then
        tmp = b * (a * (-0.25d0))
    else
        tmp = c + (x * y)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if ((b <= -1.95e-50) || !(b <= 2.4e+189)) {
		tmp = b * (a * -0.25);
	} else {
		tmp = c + (x * y);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	tmp = 0
	if (b <= -1.95e-50) or not (b <= 2.4e+189):
		tmp = b * (a * -0.25)
	else:
		tmp = c + (x * y)
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	tmp = 0.0
	if ((b <= -1.95e-50) || !(b <= 2.4e+189))
		tmp = Float64(b * Float64(a * -0.25));
	else
		tmp = Float64(c + Float64(x * y));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	tmp = 0.0;
	if ((b <= -1.95e-50) || ~((b <= 2.4e+189)))
		tmp = b * (a * -0.25);
	else
		tmp = c + (x * y);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := If[Or[LessEqual[b, -1.95e-50], N[Not[LessEqual[b, 2.4e+189]], $MachinePrecision]], N[(b * N[(a * -0.25), $MachinePrecision]), $MachinePrecision], N[(c + N[(x * y), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if b < -1.9500000000000001e-50 or 2.4000000000000001e189 < b

   1. Initial program 97.3%

      \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
   2. Add Preprocessing

   3. Taylor expanded in z around 0 76.9%

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

   4. Taylor expanded in b around inf 76.9%

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

   5. Taylor expanded in c around 0 63.8%

      \[\leadsto \color{blue}{b \cdot \left(\frac{x \cdot y}{b} - 0.25 \cdot a\right)} \]

   6. Taylor expanded in x around 0 41.7%

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

   if -1.9500000000000001e-50 < b < 2.4000000000000001e189

   1. Initial program 99.3%

      \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 63.9%

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

4. Final simplification 54.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -1.95 \cdot 10^{-50} \lor \neg \left(b \leq 2.4 \cdot 10^{+189}\right):\\ \;\;\;\;b \cdot \left(a \cdot -0.25\right)\\ \mathbf{else}:\\ \;\;\;\;c + x \cdot y\\ \end{array} \]
5. Add Preprocessing

Alternative 11: 38.6% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;c \leq -1.06 \cdot 10^{+73} \lor \neg \left(c \leq 7 \cdot 10^{+83}\right):\\ \;\;\;\;c\\ \mathbf{else}:\\ \;\;\;\;b \cdot \left(a \cdot -0.25\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (if (or (<= c -1.06e+73) (not (<= c 7e+83))) c (* b (* a -0.25))))

C

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

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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) :: tmp
    if ((c <= (-1.06d+73)) .or. (.not. (c <= 7d+83))) then
        tmp = c
    else
        tmp = b * (a * (-0.25d0))
    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 tmp;
	if ((c <= -1.06e+73) || !(c <= 7e+83)) {
		tmp = c;
	} else {
		tmp = b * (a * -0.25);
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := If[Or[LessEqual[c, -1.06e+73], N[Not[LessEqual[c, 7e+83]], $MachinePrecision]], c, N[(b * N[(a * -0.25), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if c < -1.0600000000000001e73 or 6.99999999999999954e83 < c

   1. Initial program 100.0%

      \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 76.9%

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

   4. Taylor expanded in x around 0 52.5%

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

   if -1.0600000000000001e73 < c < 6.99999999999999954e83

   1. Initial program 97.4%

      \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
   2. Add Preprocessing

   3. Taylor expanded in z around 0 65.3%

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

   4. Taylor expanded in b around inf 59.8%

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

   5. Taylor expanded in c around 0 54.1%

      \[\leadsto \color{blue}{b \cdot \left(\frac{x \cdot y}{b} - 0.25 \cdot a\right)} \]

   6. Taylor expanded in x around 0 31.7%

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

4. Final simplification 40.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;c \leq -1.06 \cdot 10^{+73} \lor \neg \left(c \leq 7 \cdot 10^{+83}\right):\\ \;\;\;\;c\\ \mathbf{else}:\\ \;\;\;\;b \cdot \left(a \cdot -0.25\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 12: 22.0% accurate, 17.0× speedup

Math

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

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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
    code = c
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 98.4%

   \[\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c \]
2. Add Preprocessing

3. Taylor expanded in x around inf 53.2%

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

4. Taylor expanded in x around 0 25.6%

   \[\leadsto \color{blue}{c} \]
5. Add Preprocessing

Reproduce

herbie shell --seed 2024096 
(FPCore (x y z t a b c)
  :name "Diagrams.Solve.Polynomial:quartForm  from diagrams-solve-0.1, C"
  :precision binary64
  (+ (- (+ (* x y) (/ (* z t) 16.0)) (/ (* a b) 4.0)) c))