Graphics.Rendering.Plot.Render.Plot.Legend:renderLegendOutside from plot-0.2.3.4, B

Percentage Accurate: 99.8% → 99.9%

Time: 2.4s

Alternatives: 13

Speedup: 1.2×

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

Specification

Math

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

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (+ (* x (+ (+ (+ (+ y z) z) y) t)) (* y 5.0)))

C

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

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = (x * ((((y + z) + z) + y) + t)) + (y * 5.0d0)
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	(x * ((((y + z) + z) + y) + t)) + (y * (5))
END code

Initial Program: 99.8% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (+ (* x (+ (+ (+ (+ y z) z) y) t)) (* y 5.0)))

C

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

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = (x * ((((y + z) + z) + y) + t)) + (y * 5.0d0)
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	(x * ((((y + z) + z) + y) + t)) + (y * (5))
END code

Alternative 1: 99.9% accurate, 1.0× speedup

Math

\[\mathsf{fma}\left(y, 5 + x, \mathsf{fma}\left(2, z, t + y\right) \cdot x\right) \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (fma y (+ 5.0 x) (* (fma 2.0 z (+ t y)) x)))

C

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

Julia

function code(x, y, z, t)
	return fma(y, Float64(5.0 + x), Float64(fma(2.0, z, Float64(t + y)) * x))
end

Wolfram

code[x_, y_, z_, t_] := N[(y * N[(5.0 + x), $MachinePrecision] + N[(N[(2.0 * z + N[(t + y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	(y * ((5) + x)) + ((((2) * z) + (t + y)) * x)
END code

Derivation

1. Initial program 99.8%

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

3. Applied rewrites 99.9%

   \[\leadsto \mathsf{fma}\left(y, 5 + x, \mathsf{fma}\left(2, z, t + y\right) \cdot x\right) \]
4. Add Preprocessing

Alternative 2: 99.8% accurate, 1.2× speedup

Math

\[\mathsf{fma}\left(x, \mathsf{fma}\left(2, z + y, t\right), 5 \cdot y\right) \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (fma x (fma 2.0 (+ z y) t) (* 5.0 y)))

C

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

Julia

function code(x, y, z, t)
	return fma(x, fma(2.0, Float64(z + y), t), Float64(5.0 * y))
end

Wolfram

code[x_, y_, z_, t_] := N[(x * N[(2.0 * N[(z + y), $MachinePrecision] + t), $MachinePrecision] + N[(5.0 * y), $MachinePrecision]), $MachinePrecision]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	(x * (((2) * (z + y)) + t)) + ((5) * y)
END code

Derivation

1. Initial program 99.8%

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

3. Applied rewrites 99.8%

   \[\leadsto \mathsf{fma}\left(x, \mathsf{fma}\left(2, z + y, t\right), 5 \cdot y\right) \]
4. Add Preprocessing

Alternative 3: 99.1% accurate, 0.9× speedup

Math

\[\begin{array}{l} \mathbf{if}\;x \leq -433194.69583954895:\\ \;\;\;\;x \cdot \left(t + 2 \cdot \left(y + z\right)\right)\\ \mathbf{elif}\;x \leq 0.007817243203751165:\\ \;\;\;\;\mathsf{fma}\left(x, \mathsf{fma}\left(2, z, t\right), 5 \cdot y\right)\\ \mathbf{else}:\\ \;\;\;\;x \cdot \left(z + \left(\mathsf{fma}\left(2, y, z\right) + t\right)\right)\\ \end{array} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (if (<= x -433194.69583954895)
  (* x (+ t (* 2.0 (+ y z))))
  (if (<= x 0.007817243203751165)
    (fma x (fma 2.0 z t) (* 5.0 y))
    (* x (+ z (+ (fma 2.0 y z) t))))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (x <= -433194.69583954895) {
		tmp = x * (t + (2.0 * (y + z)));
	} else if (x <= 0.007817243203751165) {
		tmp = fma(x, fma(2.0, z, t), (5.0 * y));
	} else {
		tmp = x * (z + (fma(2.0, y, z) + t));
	}
	return tmp;
}

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (x <= -433194.69583954895)
		tmp = Float64(x * Float64(t + Float64(2.0 * Float64(y + z))));
	elseif (x <= 0.007817243203751165)
		tmp = fma(x, fma(2.0, z, t), Float64(5.0 * y));
	else
		tmp = Float64(x * Float64(z + Float64(fma(2.0, y, z) + t)));
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[x, -433194.69583954895], N[(x * N[(t + N[(2.0 * N[(y + z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 0.007817243203751165], N[(x * N[(2.0 * z + t), $MachinePrecision] + N[(5.0 * y), $MachinePrecision]), $MachinePrecision], N[(x * N[(z + N[(N[(2.0 * y + z), $MachinePrecision] + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	LET tmp_1 = IF (x <= (781724320375116500658752016761354752816259860992431640625e-59)) THEN ((x * (((2) * z) + t)) + ((5) * y)) ELSE (x * (z + ((((2) * y) + z) + t))) ENDIF IN
	LET tmp = IF (x <= (-4331946958395489491522312164306640625e-31)) THEN (x * (t + ((2) * (y + z)))) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if x < -433194.69583954895

   1. Initial program 99.8%

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

   3. Applied rewrites 99.8%

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

   4. Taylor expanded in x around inf

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

   6. Applied rewrites 72.3%

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

   if -433194.69583954895 < x < 0.007817243203751165

   1. Initial program 99.8%

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

   3. Applied rewrites 99.8%

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

   4. Taylor expanded in y around 0

      \[\leadsto \mathsf{fma}\left(x, \mathsf{fma}\left(2, z, t\right), 5 \cdot y\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 84.0%

      \[\leadsto \mathsf{fma}\left(x, \mathsf{fma}\left(2, z, t\right), 5 \cdot y\right) \]

   if 0.007817243203751165 < x

   1. Initial program 99.8%

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

   3. Applied rewrites 99.8%

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

   4. Taylor expanded in x around inf

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

   6. Applied rewrites 72.3%

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

   8. Applied rewrites 72.3%

      \[\leadsto x \cdot \left(z + \left(\mathsf{fma}\left(2, y, z\right) + t\right)\right) \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 4: 99.1% accurate, 0.9× speedup

Math

\[\begin{array}{l} t_1 := x \cdot \left(t + 2 \cdot \left(y + z\right)\right)\\ \mathbf{if}\;x \leq -433194.69583954895:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \leq 0.007817243203751165:\\ \;\;\;\;\mathsf{fma}\left(x, \mathsf{fma}\left(2, z, t\right), 5 \cdot y\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* x (+ t (* 2.0 (+ y z))))))
  (if (<= x -433194.69583954895)
    t_1
    (if (<= x 0.007817243203751165)
      (fma x (fma 2.0 z t) (* 5.0 y))
      t_1))))

C

double code(double x, double y, double z, double t) {
	double t_1 = x * (t + (2.0 * (y + z)));
	double tmp;
	if (x <= -433194.69583954895) {
		tmp = t_1;
	} else if (x <= 0.007817243203751165) {
		tmp = fma(x, fma(2.0, z, t), (5.0 * y));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

function code(x, y, z, t)
	t_1 = Float64(x * Float64(t + Float64(2.0 * Float64(y + z))))
	tmp = 0.0
	if (x <= -433194.69583954895)
		tmp = t_1;
	elseif (x <= 0.007817243203751165)
		tmp = fma(x, fma(2.0, z, t), Float64(5.0 * y));
	else
		tmp = t_1;
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(x * N[(t + N[(2.0 * N[(y + z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -433194.69583954895], t$95$1, If[LessEqual[x, 0.007817243203751165], N[(x * N[(2.0 * z + t), $MachinePrecision] + N[(5.0 * y), $MachinePrecision]), $MachinePrecision], t$95$1]]]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	LET t_1 = (x * (t + ((2) * (y + z)))) IN
		LET tmp_1 = IF (x <= (781724320375116500658752016761354752816259860992431640625e-59)) THEN ((x * (((2) * z) + t)) + ((5) * y)) ELSE t_1 ENDIF IN
		LET tmp = IF (x <= (-4331946958395489491522312164306640625e-31)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if x < -433194.69583954895 or 0.007817243203751165 < x

   1. Initial program 99.8%

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

   3. Applied rewrites 99.8%

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

   4. Taylor expanded in x around inf

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

   6. Applied rewrites 72.3%

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

   if -433194.69583954895 < x < 0.007817243203751165

   1. Initial program 99.8%

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

   3. Applied rewrites 99.8%

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

   4. Taylor expanded in y around 0

      \[\leadsto \mathsf{fma}\left(x, \mathsf{fma}\left(2, z, t\right), 5 \cdot y\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 84.0%

      \[\leadsto \mathsf{fma}\left(x, \mathsf{fma}\left(2, z, t\right), 5 \cdot y\right) \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 5: 88.7% accurate, 0.8× speedup

Math

\[\begin{array}{l} t_1 := x \cdot \left(t + 2 \cdot \left(y + z\right)\right)\\ \mathbf{if}\;x \leq -8.632607868762993 \cdot 10^{-31}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \leq -3.180897278887981 \cdot 10^{-296}:\\ \;\;\;\;t \cdot x + y \cdot 5\\ \mathbf{elif}\;x \leq 3.8772841432359074 \cdot 10^{-19}:\\ \;\;\;\;\mathsf{fma}\left(5, y, \left(x + x\right) \cdot z\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* x (+ t (* 2.0 (+ y z))))))
  (if (<= x -8.632607868762993e-31)
    t_1
    (if (<= x -3.180897278887981e-296)
      (+ (* t x) (* y 5.0))
      (if (<= x 3.8772841432359074e-19)
        (fma 5.0 y (* (+ x x) z))
        t_1)))))

C

double code(double x, double y, double z, double t) {
	double t_1 = x * (t + (2.0 * (y + z)));
	double tmp;
	if (x <= -8.632607868762993e-31) {
		tmp = t_1;
	} else if (x <= -3.180897278887981e-296) {
		tmp = (t * x) + (y * 5.0);
	} else if (x <= 3.8772841432359074e-19) {
		tmp = fma(5.0, y, ((x + x) * z));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

function code(x, y, z, t)
	t_1 = Float64(x * Float64(t + Float64(2.0 * Float64(y + z))))
	tmp = 0.0
	if (x <= -8.632607868762993e-31)
		tmp = t_1;
	elseif (x <= -3.180897278887981e-296)
		tmp = Float64(Float64(t * x) + Float64(y * 5.0));
	elseif (x <= 3.8772841432359074e-19)
		tmp = fma(5.0, y, Float64(Float64(x + x) * z));
	else
		tmp = t_1;
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(x * N[(t + N[(2.0 * N[(y + z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -8.632607868762993e-31], t$95$1, If[LessEqual[x, -3.180897278887981e-296], N[(N[(t * x), $MachinePrecision] + N[(y * 5.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 3.8772841432359074e-19], N[(5.0 * y + N[(N[(x + x), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	LET t_1 = (x * (t + ((2) * (y + z)))) IN
		LET tmp_2 = IF (x <= (387728414323590737510452304127777740313002621624127231637901846994509469368495047092437744140625e-114)) THEN (((5) * y) + ((x + x) * z)) ELSE t_1 ENDIF IN
		LET tmp_1 = IF (x <= (-31808972788879807819369654463873409794328202473911330935776019935047554361833414234427996648659295993740153759382544224035077727035031975800651334935368242240000781228908947625706219195378343944486817283763430124019886660588951546248403341501353667983935006472983428546089878761845281123317879056133319093510902688283452991296622990951929497089264549836273652925304380666217889751296703534874440455396344103809772654350930513530438251436289498590723595399815693456333849989020075122525533364937436050171057019298849189639182985028628892777469993460992768132017457347731618115501252715976776175323135653584889920656190565807540863430771158142458605962136140642013406192551764126268085876158775372919695900719716519233770668506622314453125e-1032)) THEN ((t * x) + (y * (5))) ELSE tmp_2 ENDIF IN
		LET tmp = IF (x <= (-8632607868762992664727499985123051859847114065889524315761629795630093639856989483349902769759864895604550838470458984375e-151)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if x < -8.6326078687629927e-31 or 3.8772841432359074e-19 < x

   1. Initial program 99.8%

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

   3. Applied rewrites 99.8%

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

   4. Taylor expanded in x around inf

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

   6. Applied rewrites 72.3%

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

   if -8.6326078687629927e-31 < x < -3.1808972788879808e-296

   1. Initial program 99.8%

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

   2. Taylor expanded in t around inf

      \[\leadsto t \cdot x + y \cdot 5 \]
   3. Step-by-step derivation

   4. Applied rewrites 58.2%

      \[\leadsto t \cdot x + y \cdot 5 \]

   if -3.1808972788879808e-296 < x < 3.8772841432359074e-19

   1. Initial program 99.8%

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

   2. Taylor expanded in z around inf

      \[\leadsto 2 \cdot \left(x \cdot z\right) + y \cdot 5 \]
   3. Step-by-step derivation

   4. Applied rewrites 56.7%

      \[\leadsto 2 \cdot \left(x \cdot z\right) + y \cdot 5 \]
   5. Step-by-step derivation

   6. Applied rewrites 56.7%

      \[\leadsto \mathsf{fma}\left(5, y, \left(x + x\right) \cdot z\right) \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 6: 78.8% accurate, 0.9× speedup

Math

\[\begin{array}{l} \mathbf{if}\;x \leq -8.632607868762993 \cdot 10^{-31}:\\ \;\;\;\;\mathsf{fma}\left(2, z, t\right) \cdot x\\ \mathbf{elif}\;x \leq -3.180897278887981 \cdot 10^{-296}:\\ \;\;\;\;t \cdot x + y \cdot 5\\ \mathbf{elif}\;x \leq 132945528.09762461:\\ \;\;\;\;\mathsf{fma}\left(5, y, \left(x + x\right) \cdot z\right)\\ \mathbf{else}:\\ \;\;\;\;x \cdot \left(y + \left(t + y\right)\right)\\ \end{array} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (if (<= x -8.632607868762993e-31)
  (* (fma 2.0 z t) x)
  (if (<= x -3.180897278887981e-296)
    (+ (* t x) (* y 5.0))
    (if (<= x 132945528.09762461)
      (fma 5.0 y (* (+ x x) z))
      (* x (+ y (+ t y)))))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (x <= -8.632607868762993e-31) {
		tmp = fma(2.0, z, t) * x;
	} else if (x <= -3.180897278887981e-296) {
		tmp = (t * x) + (y * 5.0);
	} else if (x <= 132945528.09762461) {
		tmp = fma(5.0, y, ((x + x) * z));
	} else {
		tmp = x * (y + (t + y));
	}
	return tmp;
}

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (x <= -8.632607868762993e-31)
		tmp = Float64(fma(2.0, z, t) * x);
	elseif (x <= -3.180897278887981e-296)
		tmp = Float64(Float64(t * x) + Float64(y * 5.0));
	elseif (x <= 132945528.09762461)
		tmp = fma(5.0, y, Float64(Float64(x + x) * z));
	else
		tmp = Float64(x * Float64(y + Float64(t + y)));
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[x, -8.632607868762993e-31], N[(N[(2.0 * z + t), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[x, -3.180897278887981e-296], N[(N[(t * x), $MachinePrecision] + N[(y * 5.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 132945528.09762461], N[(5.0 * y + N[(N[(x + x), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision], N[(x * N[(y + N[(t + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	LET tmp_2 = IF (x <= (13294552809762461483478546142578125e-26)) THEN (((5) * y) + ((x + x) * z)) ELSE (x * (y + (t + y))) ENDIF IN
	LET tmp_1 = IF (x <= (-31808972788879807819369654463873409794328202473911330935776019935047554361833414234427996648659295993740153759382544224035077727035031975800651334935368242240000781228908947625706219195378343944486817283763430124019886660588951546248403341501353667983935006472983428546089878761845281123317879056133319093510902688283452991296622990951929497089264549836273652925304380666217889751296703534874440455396344103809772654350930513530438251436289498590723595399815693456333849989020075122525533364937436050171057019298849189639182985028628892777469993460992768132017457347731618115501252715976776175323135653584889920656190565807540863430771158142458605962136140642013406192551764126268085876158775372919695900719716519233770668506622314453125e-1032)) THEN ((t * x) + (y * (5))) ELSE tmp_2 ENDIF IN
	LET tmp = IF (x <= (-8632607868762992664727499985123051859847114065889524315761629795630093639856989483349902769759864895604550838470458984375e-151)) THEN ((((2) * z) + t) * x) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 4 regimes

2. if x < -8.6326078687629927e-31

   1. Initial program 99.8%

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

   2. Taylor expanded in x around 0

      \[\leadsto 5 \cdot y \]
   3. Step-by-step derivation

   4. Applied rewrites 29.3%

      \[\leadsto 5 \cdot y \]

   5. Taylor expanded in y around 0

      \[\leadsto x \cdot \left(t + 2 \cdot z\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 56.9%

      \[\leadsto x \cdot \left(t + 2 \cdot z\right) \]
   8. Step-by-step derivation

   9. Applied rewrites 56.9%

      \[\leadsto \mathsf{fma}\left(2, z, t\right) \cdot x \]

   if -8.6326078687629927e-31 < x < -3.1808972788879808e-296

   1. Initial program 99.8%

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

   2. Taylor expanded in t around inf

      \[\leadsto t \cdot x + y \cdot 5 \]
   3. Step-by-step derivation

   4. Applied rewrites 58.2%

      \[\leadsto t \cdot x + y \cdot 5 \]

   if -3.1808972788879808e-296 < x < 132945528.09762461

   1. Initial program 99.8%

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

   2. Taylor expanded in z around inf

      \[\leadsto 2 \cdot \left(x \cdot z\right) + y \cdot 5 \]
   3. Step-by-step derivation

   4. Applied rewrites 56.7%

      \[\leadsto 2 \cdot \left(x \cdot z\right) + y \cdot 5 \]
   5. Step-by-step derivation

   6. Applied rewrites 56.7%

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

   if 132945528.09762461 < x

   1. Initial program 99.8%

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

   2. Taylor expanded in z around 0

      \[\leadsto 5 \cdot y + x \cdot \left(t + 2 \cdot y\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 74.9%

      \[\leadsto \mathsf{fma}\left(5, y, x \cdot \left(t + 2 \cdot y\right)\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 74.1%

      \[\leadsto \mathsf{fma}\left(y, \mathsf{fma}\left(2, x, 5\right), t \cdot x\right) \]

   7. Taylor expanded in x around inf

      \[\leadsto x \cdot \left(t + 2 \cdot y\right) \]
   8. Step-by-step derivation

   9. Applied rewrites 47.7%

      \[\leadsto x \cdot \left(t + 2 \cdot y\right) \]
   10. Step-by-step derivation

   11. Applied rewrites 47.7%

       \[\leadsto x \cdot \left(y + \left(t + y\right)\right) \]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 7: 78.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \mathbf{if}\;y \leq -2.217273480512582 \cdot 10^{+28}:\\ \;\;\;\;\mathsf{fma}\left(2, x, 5\right) \cdot y\\ \mathbf{elif}\;y \leq 4.744592432800514 \cdot 10^{+33}:\\ \;\;\;\;\mathsf{fma}\left(2, z, t\right) \cdot x\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(5, y, \left(y + y\right) \cdot x\right)\\ \end{array} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (if (<= y -2.217273480512582e+28)
  (* (fma 2.0 x 5.0) y)
  (if (<= y 4.744592432800514e+33)
    (* (fma 2.0 z t) x)
    (fma 5.0 y (* (+ y y) x)))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -2.217273480512582e+28) {
		tmp = fma(2.0, x, 5.0) * y;
	} else if (y <= 4.744592432800514e+33) {
		tmp = fma(2.0, z, t) * x;
	} else {
		tmp = fma(5.0, y, ((y + y) * x));
	}
	return tmp;
}

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (y <= -2.217273480512582e+28)
		tmp = Float64(fma(2.0, x, 5.0) * y);
	elseif (y <= 4.744592432800514e+33)
		tmp = Float64(fma(2.0, z, t) * x);
	else
		tmp = fma(5.0, y, Float64(Float64(y + y) * x));
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[y, -2.217273480512582e+28], N[(N[(2.0 * x + 5.0), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[y, 4.744592432800514e+33], N[(N[(2.0 * z + t), $MachinePrecision] * x), $MachinePrecision], N[(5.0 * y + N[(N[(y + y), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision]]]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	LET tmp_1 = IF (y <= (4744592432800513898359117991378944)) THEN ((((2) * z) + t) * x) ELSE (((5) * y) + ((y + y) * x)) ENDIF IN
	LET tmp = IF (y <= (-22172734805125818052805394432)) THEN ((((2) * x) + (5)) * y) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if y < -2.2172734805125818e28

   1. Initial program 99.8%

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

   2. Taylor expanded in y around inf

      \[\leadsto y \cdot \left(5 + 2 \cdot x\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 47.8%

      \[\leadsto y \cdot \left(5 + 2 \cdot x\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 47.8%

      \[\leadsto \mathsf{fma}\left(2, x, 5\right) \cdot y \]

   if -2.2172734805125818e28 < y < 4.7445924328005139e33

   1. Initial program 99.8%

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

   2. Taylor expanded in x around 0

      \[\leadsto 5 \cdot y \]
   3. Step-by-step derivation

   4. Applied rewrites 29.3%

      \[\leadsto 5 \cdot y \]

   5. Taylor expanded in y around 0

      \[\leadsto x \cdot \left(t + 2 \cdot z\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 56.9%

      \[\leadsto x \cdot \left(t + 2 \cdot z\right) \]
   8. Step-by-step derivation

   9. Applied rewrites 56.9%

      \[\leadsto \mathsf{fma}\left(2, z, t\right) \cdot x \]

   if 4.7445924328005139e33 < y

   1. Initial program 99.8%

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

   2. Taylor expanded in y around inf

      \[\leadsto y \cdot \left(5 + 2 \cdot x\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 47.8%

      \[\leadsto y \cdot \left(5 + 2 \cdot x\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 47.7%

      \[\leadsto \mathsf{fma}\left(5, y, \left(y + y\right) \cdot x\right) \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 8: 73.4% accurate, 1.2× speedup

Math

\[\begin{array}{l} t_1 := \mathsf{fma}\left(2, x, 5\right) \cdot y\\ \mathbf{if}\;y \leq -2.217273480512582 \cdot 10^{+28}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;y \leq 4.744592432800514 \cdot 10^{+33}:\\ \;\;\;\;\mathsf{fma}\left(2, z, t\right) \cdot x\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* (fma 2.0 x 5.0) y)))
  (if (<= y -2.217273480512582e+28)
    t_1
    (if (<= y 4.744592432800514e+33) (* (fma 2.0 z t) x) t_1))))

C

double code(double x, double y, double z, double t) {
	double t_1 = fma(2.0, x, 5.0) * y;
	double tmp;
	if (y <= -2.217273480512582e+28) {
		tmp = t_1;
	} else if (y <= 4.744592432800514e+33) {
		tmp = fma(2.0, z, t) * x;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

function code(x, y, z, t)
	t_1 = Float64(fma(2.0, x, 5.0) * y)
	tmp = 0.0
	if (y <= -2.217273480512582e+28)
		tmp = t_1;
	elseif (y <= 4.744592432800514e+33)
		tmp = Float64(fma(2.0, z, t) * x);
	else
		tmp = t_1;
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(2.0 * x + 5.0), $MachinePrecision] * y), $MachinePrecision]}, If[LessEqual[y, -2.217273480512582e+28], t$95$1, If[LessEqual[y, 4.744592432800514e+33], N[(N[(2.0 * z + t), $MachinePrecision] * x), $MachinePrecision], t$95$1]]]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	LET t_1 = ((((2) * x) + (5)) * y) IN
		LET tmp_1 = IF (y <= (4744592432800513898359117991378944)) THEN ((((2) * z) + t) * x) ELSE t_1 ENDIF IN
		LET tmp = IF (y <= (-22172734805125818052805394432)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if y < -2.2172734805125818e28 or 4.7445924328005139e33 < y

   1. Initial program 99.8%

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

   2. Taylor expanded in y around inf

      \[\leadsto y \cdot \left(5 + 2 \cdot x\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 47.8%

      \[\leadsto y \cdot \left(5 + 2 \cdot x\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 47.8%

      \[\leadsto \mathsf{fma}\left(2, x, 5\right) \cdot y \]

   if -2.2172734805125818e28 < y < 4.7445924328005139e33

   1. Initial program 99.8%

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

   2. Taylor expanded in x around 0

      \[\leadsto 5 \cdot y \]
   3. Step-by-step derivation

   4. Applied rewrites 29.3%

      \[\leadsto 5 \cdot y \]

   5. Taylor expanded in y around 0

      \[\leadsto x \cdot \left(t + 2 \cdot z\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 56.9%

      \[\leadsto x \cdot \left(t + 2 \cdot z\right) \]
   8. Step-by-step derivation

   9. Applied rewrites 56.9%

      \[\leadsto \mathsf{fma}\left(2, z, t\right) \cdot x \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 9: 64.9% accurate, 1.2× speedup

Math

\[\begin{array}{l} t_1 := \mathsf{fma}\left(2, z, t\right) \cdot x\\ \mathbf{if}\;x \leq -8.632607868762993 \cdot 10^{-31}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \leq 3.2735522738260035 \cdot 10^{-63}:\\ \;\;\;\;5 \cdot y\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* (fma 2.0 z t) x)))
  (if (<= x -8.632607868762993e-31)
    t_1
    (if (<= x 3.2735522738260035e-63) (* 5.0 y) t_1))))

C

double code(double x, double y, double z, double t) {
	double t_1 = fma(2.0, z, t) * x;
	double tmp;
	if (x <= -8.632607868762993e-31) {
		tmp = t_1;
	} else if (x <= 3.2735522738260035e-63) {
		tmp = 5.0 * y;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

function code(x, y, z, t)
	t_1 = Float64(fma(2.0, z, t) * x)
	tmp = 0.0
	if (x <= -8.632607868762993e-31)
		tmp = t_1;
	elseif (x <= 3.2735522738260035e-63)
		tmp = Float64(5.0 * y);
	else
		tmp = t_1;
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(2.0 * z + t), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -8.632607868762993e-31], t$95$1, If[LessEqual[x, 3.2735522738260035e-63], N[(5.0 * y), $MachinePrecision], t$95$1]]]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	LET t_1 = ((((2) * z) + t) * x) IN
		LET tmp_1 = IF (x <= (327355227382600348764269205950672903482237317517422033296356558825990319881144835267123017359055681233069794405434154593226753877402813208956384697723160175607259869678955510607920587062835693359375e-260)) THEN ((5) * y) ELSE t_1 ENDIF IN
		LET tmp = IF (x <= (-8632607868762992664727499985123051859847114065889524315761629795630093639856989483349902769759864895604550838470458984375e-151)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if x < -8.6326078687629927e-31 or 3.2735522738260035e-63 < x

   1. Initial program 99.8%

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

   2. Taylor expanded in x around 0

      \[\leadsto 5 \cdot y \]
   3. Step-by-step derivation

   4. Applied rewrites 29.3%

      \[\leadsto 5 \cdot y \]

   5. Taylor expanded in y around 0

      \[\leadsto x \cdot \left(t + 2 \cdot z\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 56.9%

      \[\leadsto x \cdot \left(t + 2 \cdot z\right) \]
   8. Step-by-step derivation

   9. Applied rewrites 56.9%

      \[\leadsto \mathsf{fma}\left(2, z, t\right) \cdot x \]

   if -8.6326078687629927e-31 < x < 3.2735522738260035e-63

   1. Initial program 99.8%

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

   2. Taylor expanded in x around 0

      \[\leadsto 5 \cdot y \]
   3. Step-by-step derivation

   4. Applied rewrites 29.3%

      \[\leadsto 5 \cdot y \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 10: 47.6% accurate, 0.9× speedup

Math

\[\begin{array}{l} t_1 := 2 \cdot \left(x \cdot z\right)\\ \mathbf{if}\;x \leq -5.380532369385036 \cdot 10^{+103}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \leq -1.4144549925363773 \cdot 10^{-30}:\\ \;\;\;\;x \cdot t\\ \mathbf{elif}\;x \leq 3.2735522738260035 \cdot 10^{-63}:\\ \;\;\;\;5 \cdot y\\ \mathbf{elif}\;x \leq 3.705788431061786 \cdot 10^{+185}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;x \cdot t\\ \end{array} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* 2.0 (* x z))))
  (if (<= x -5.380532369385036e+103)
    t_1
    (if (<= x -1.4144549925363773e-30)
      (* x t)
      (if (<= x 3.2735522738260035e-63)
        (* 5.0 y)
        (if (<= x 3.705788431061786e+185) t_1 (* x t)))))))

C

double code(double x, double y, double z, double t) {
	double t_1 = 2.0 * (x * z);
	double tmp;
	if (x <= -5.380532369385036e+103) {
		tmp = t_1;
	} else if (x <= -1.4144549925363773e-30) {
		tmp = x * t;
	} else if (x <= 3.2735522738260035e-63) {
		tmp = 5.0 * y;
	} else if (x <= 3.705788431061786e+185) {
		tmp = t_1;
	} else {
		tmp = x * t;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: t_1
    real(8) :: tmp
    t_1 = 2.0d0 * (x * z)
    if (x <= (-5.380532369385036d+103)) then
        tmp = t_1
    else if (x <= (-1.4144549925363773d-30)) then
        tmp = x * t
    else if (x <= 3.2735522738260035d-63) then
        tmp = 5.0d0 * y
    else if (x <= 3.705788431061786d+185) then
        tmp = t_1
    else
        tmp = x * t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = 2.0 * (x * z);
	double tmp;
	if (x <= -5.380532369385036e+103) {
		tmp = t_1;
	} else if (x <= -1.4144549925363773e-30) {
		tmp = x * t;
	} else if (x <= 3.2735522738260035e-63) {
		tmp = 5.0 * y;
	} else if (x <= 3.705788431061786e+185) {
		tmp = t_1;
	} else {
		tmp = x * t;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = 2.0 * (x * z)
	tmp = 0
	if x <= -5.380532369385036e+103:
		tmp = t_1
	elif x <= -1.4144549925363773e-30:
		tmp = x * t
	elif x <= 3.2735522738260035e-63:
		tmp = 5.0 * y
	elif x <= 3.705788431061786e+185:
		tmp = t_1
	else:
		tmp = x * t
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(2.0 * Float64(x * z))
	tmp = 0.0
	if (x <= -5.380532369385036e+103)
		tmp = t_1;
	elseif (x <= -1.4144549925363773e-30)
		tmp = Float64(x * t);
	elseif (x <= 3.2735522738260035e-63)
		tmp = Float64(5.0 * y);
	elseif (x <= 3.705788431061786e+185)
		tmp = t_1;
	else
		tmp = Float64(x * t);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = 2.0 * (x * z);
	tmp = 0.0;
	if (x <= -5.380532369385036e+103)
		tmp = t_1;
	elseif (x <= -1.4144549925363773e-30)
		tmp = x * t;
	elseif (x <= 3.2735522738260035e-63)
		tmp = 5.0 * y;
	elseif (x <= 3.705788431061786e+185)
		tmp = t_1;
	else
		tmp = x * t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(2.0 * N[(x * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -5.380532369385036e+103], t$95$1, If[LessEqual[x, -1.4144549925363773e-30], N[(x * t), $MachinePrecision], If[LessEqual[x, 3.2735522738260035e-63], N[(5.0 * y), $MachinePrecision], If[LessEqual[x, 3.705788431061786e+185], t$95$1, N[(x * t), $MachinePrecision]]]]]]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	LET t_1 = ((2) * (x * z)) IN
		LET tmp_3 = IF (x <= (370578843106178627251225249752288746886111620606894860905311311106307344631750485018381761507348573162355552658256071470749894951720118486466994469052226135546715707566875143785431433216)) THEN t_1 ELSE (x * t) ENDIF IN
		LET tmp_2 = IF (x <= (327355227382600348764269205950672903482237317517422033296356558825990319881144835267123017359055681233069794405434154593226753877402813208956384697723160175607259869678955510607920587062835693359375e-260)) THEN ((5) * y) ELSE tmp_3 ENDIF IN
		LET tmp_1 = IF (x <= (-141445499253637733099709247296896930359347581010892645013777460556542730528832596016697298324515941203571856021881103515625e-152)) THEN (x * t) ELSE tmp_2 ENDIF IN
		LET tmp = IF (x <= (-53805323693850357970507221659670597134492024471905090390629149393145074103958851127666113325456345268224)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if x < -5.3805323693850358e103 or 3.2735522738260035e-63 < x < 3.7057884310617863e185

   1. Initial program 99.8%

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

   2. Taylor expanded in x around 0

      \[\leadsto 5 \cdot y \]
   3. Step-by-step derivation

   4. Applied rewrites 29.3%

      \[\leadsto 5 \cdot y \]

   5. Taylor expanded in y around 0

      \[\leadsto x \cdot \left(t + 2 \cdot z\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 56.9%

      \[\leadsto x \cdot \left(t + 2 \cdot z\right) \]
   8. Step-by-step derivation

   9. Applied rewrites 56.9%

      \[\leadsto \mathsf{fma}\left(2, z, t\right) \cdot x \]

   10. Taylor expanded in z around inf

       \[\leadsto 2 \cdot \left(x \cdot z\right) \]
   11. Step-by-step derivation

   12. Applied rewrites 29.9%

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

   if -5.3805323693850358e103 < x < -1.4144549925363773e-30 or 3.7057884310617863e185 < x

   1. Initial program 99.8%

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

   2. Taylor expanded in x around 0

      \[\leadsto 5 \cdot y \]
   3. Step-by-step derivation

   4. Applied rewrites 29.3%

      \[\leadsto 5 \cdot y \]

   5. Taylor expanded in y around 0

      \[\leadsto x \cdot \left(t + 2 \cdot z\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 56.9%

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

   8. Taylor expanded in z around 0

      \[\leadsto x \cdot t \]
   9. Step-by-step derivation

   10. Applied rewrites 31.2%

       \[\leadsto x \cdot t \]

   if -1.4144549925363773e-30 < x < 3.2735522738260035e-63

   1. Initial program 99.8%

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

   2. Taylor expanded in x around 0

      \[\leadsto 5 \cdot y \]
   3. Step-by-step derivation

   4. Applied rewrites 29.3%

      \[\leadsto 5 \cdot y \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 11: 47.3% accurate, 1.1× speedup

Math

\[\begin{array}{l} \mathbf{if}\;x \leq -1.4144549925363773 \cdot 10^{-30}:\\ \;\;\;\;x \cdot t\\ \mathbf{elif}\;x \leq 56554.17358162966:\\ \;\;\;\;5 \cdot y\\ \mathbf{elif}\;x \leq 6.49814949834068 \cdot 10^{+69}:\\ \;\;\;\;\left(x + x\right) \cdot y\\ \mathbf{else}:\\ \;\;\;\;x \cdot t\\ \end{array} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (if (<= x -1.4144549925363773e-30)
  (* x t)
  (if (<= x 56554.17358162966)
    (* 5.0 y)
    (if (<= x 6.49814949834068e+69) (* (+ x x) y) (* x t)))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (x <= -1.4144549925363773e-30) {
		tmp = x * t;
	} else if (x <= 56554.17358162966) {
		tmp = 5.0 * y;
	} else if (x <= 6.49814949834068e+69) {
		tmp = (x + x) * y;
	} else {
		tmp = x * t;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: tmp
    if (x <= (-1.4144549925363773d-30)) then
        tmp = x * t
    else if (x <= 56554.17358162966d0) then
        tmp = 5.0d0 * y
    else if (x <= 6.49814949834068d+69) then
        tmp = (x + x) * y
    else
        tmp = x * t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (x <= -1.4144549925363773e-30) {
		tmp = x * t;
	} else if (x <= 56554.17358162966) {
		tmp = 5.0 * y;
	} else if (x <= 6.49814949834068e+69) {
		tmp = (x + x) * y;
	} else {
		tmp = x * t;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if x <= -1.4144549925363773e-30:
		tmp = x * t
	elif x <= 56554.17358162966:
		tmp = 5.0 * y
	elif x <= 6.49814949834068e+69:
		tmp = (x + x) * y
	else:
		tmp = x * t
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (x <= -1.4144549925363773e-30)
		tmp = Float64(x * t);
	elseif (x <= 56554.17358162966)
		tmp = Float64(5.0 * y);
	elseif (x <= 6.49814949834068e+69)
		tmp = Float64(Float64(x + x) * y);
	else
		tmp = Float64(x * t);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (x <= -1.4144549925363773e-30)
		tmp = x * t;
	elseif (x <= 56554.17358162966)
		tmp = 5.0 * y;
	elseif (x <= 6.49814949834068e+69)
		tmp = (x + x) * y;
	else
		tmp = x * t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[x, -1.4144549925363773e-30], N[(x * t), $MachinePrecision], If[LessEqual[x, 56554.17358162966], N[(5.0 * y), $MachinePrecision], If[LessEqual[x, 6.49814949834068e+69], N[(N[(x + x), $MachinePrecision] * y), $MachinePrecision], N[(x * t), $MachinePrecision]]]]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	LET tmp_2 = IF (x <= (6498149498340680008560378704271546944266471215783290466827077372870656)) THEN ((x + x) * y) ELSE (x * t) ENDIF IN
	LET tmp_1 = IF (x <= (56554173581629656837321817874908447265625e-36)) THEN ((5) * y) ELSE tmp_2 ENDIF IN
	LET tmp = IF (x <= (-141445499253637733099709247296896930359347581010892645013777460556542730528832596016697298324515941203571856021881103515625e-152)) THEN (x * t) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if x < -1.4144549925363773e-30 or 6.49814949834068e69 < x

   1. Initial program 99.8%

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

   2. Taylor expanded in x around 0

      \[\leadsto 5 \cdot y \]
   3. Step-by-step derivation

   4. Applied rewrites 29.3%

      \[\leadsto 5 \cdot y \]

   5. Taylor expanded in y around 0

      \[\leadsto x \cdot \left(t + 2 \cdot z\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 56.9%

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

   8. Taylor expanded in z around 0

      \[\leadsto x \cdot t \]
   9. Step-by-step derivation

   10. Applied rewrites 31.2%

       \[\leadsto x \cdot t \]

   if -1.4144549925363773e-30 < x < 56554.173581629657

   1. Initial program 99.8%

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

   2. Taylor expanded in x around 0

      \[\leadsto 5 \cdot y \]
   3. Step-by-step derivation

   4. Applied rewrites 29.3%

      \[\leadsto 5 \cdot y \]

   if 56554.173581629657 < x < 6.49814949834068e69

   1. Initial program 99.8%

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

   2. Taylor expanded in y around inf

      \[\leadsto y \cdot \left(5 + 2 \cdot x\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 47.8%

      \[\leadsto y \cdot \left(5 + 2 \cdot x\right) \]

   5. Taylor expanded in x around inf

      \[\leadsto 2 \cdot \left(x \cdot y\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 20.8%

      \[\leadsto 2 \cdot \left(x \cdot y\right) \]
   8. Step-by-step derivation

   9. Applied rewrites 20.9%

      \[\leadsto \left(x + x\right) \cdot y \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 12: 46.5% accurate, 1.7× speedup

Math

\[\begin{array}{l} \mathbf{if}\;x \leq -1.4144549925363773 \cdot 10^{-30}:\\ \;\;\;\;x \cdot t\\ \mathbf{elif}\;x \leq 3.8772841432359074 \cdot 10^{-19}:\\ \;\;\;\;5 \cdot y\\ \mathbf{else}:\\ \;\;\;\;x \cdot t\\ \end{array} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (if (<= x -1.4144549925363773e-30)
  (* x t)
  (if (<= x 3.8772841432359074e-19) (* 5.0 y) (* x t))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (x <= -1.4144549925363773e-30) {
		tmp = x * t;
	} else if (x <= 3.8772841432359074e-19) {
		tmp = 5.0 * y;
	} else {
		tmp = x * t;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8) :: tmp
    if (x <= (-1.4144549925363773d-30)) then
        tmp = x * t
    else if (x <= 3.8772841432359074d-19) then
        tmp = 5.0d0 * y
    else
        tmp = x * t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (x <= -1.4144549925363773e-30) {
		tmp = x * t;
	} else if (x <= 3.8772841432359074e-19) {
		tmp = 5.0 * y;
	} else {
		tmp = x * t;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if x <= -1.4144549925363773e-30:
		tmp = x * t
	elif x <= 3.8772841432359074e-19:
		tmp = 5.0 * y
	else:
		tmp = x * t
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (x <= -1.4144549925363773e-30)
		tmp = Float64(x * t);
	elseif (x <= 3.8772841432359074e-19)
		tmp = Float64(5.0 * y);
	else
		tmp = Float64(x * t);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (x <= -1.4144549925363773e-30)
		tmp = x * t;
	elseif (x <= 3.8772841432359074e-19)
		tmp = 5.0 * y;
	else
		tmp = x * t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[x, -1.4144549925363773e-30], N[(x * t), $MachinePrecision], If[LessEqual[x, 3.8772841432359074e-19], N[(5.0 * y), $MachinePrecision], N[(x * t), $MachinePrecision]]]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	LET tmp_1 = IF (x <= (387728414323590737510452304127777740313002621624127231637901846994509469368495047092437744140625e-114)) THEN ((5) * y) ELSE (x * t) ENDIF IN
	LET tmp = IF (x <= (-141445499253637733099709247296896930359347581010892645013777460556542730528832596016697298324515941203571856021881103515625e-152)) THEN (x * t) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if x < -1.4144549925363773e-30 or 3.8772841432359074e-19 < x

   1. Initial program 99.8%

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

   2. Taylor expanded in x around 0

      \[\leadsto 5 \cdot y \]
   3. Step-by-step derivation

   4. Applied rewrites 29.3%

      \[\leadsto 5 \cdot y \]

   5. Taylor expanded in y around 0

      \[\leadsto x \cdot \left(t + 2 \cdot z\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 56.9%

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

   8. Taylor expanded in z around 0

      \[\leadsto x \cdot t \]
   9. Step-by-step derivation

   10. Applied rewrites 31.2%

       \[\leadsto x \cdot t \]

   if -1.4144549925363773e-30 < x < 3.8772841432359074e-19

   1. Initial program 99.8%

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

   2. Taylor expanded in x around 0

      \[\leadsto 5 \cdot y \]
   3. Step-by-step derivation

   4. Applied rewrites 29.3%

      \[\leadsto 5 \cdot y \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 13: 29.3% accurate, 5.0× speedup

Math

\[5 \cdot y \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (* 5.0 y))

C

double code(double x, double y, double z, double t) {
	return 5.0 * y;
}

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = 5.0d0 * y
end function

Java

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

Python

def code(x, y, z, t):
	return 5.0 * y

Julia

function code(x, y, z, t)
	return Float64(5.0 * y)
end

MATLAB

function tmp = code(x, y, z, t)
	tmp = 5.0 * y;
end

Wolfram

code[x_, y_, z_, t_] := N[(5.0 * y), $MachinePrecision]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	(5) * y
END code

Derivation

1. Initial program 99.8%

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

2. Taylor expanded in x around 0

   \[\leadsto 5 \cdot y \]
3. Step-by-step derivation

4. Applied rewrites 29.3%

   \[\leadsto 5 \cdot y \]
5. Add Preprocessing

Reproduce

herbie shell --seed 2026092 
(FPCore (x y z t)
  :name "Graphics.Rendering.Plot.Render.Plot.Legend:renderLegendOutside from plot-0.2.3.4, B"
  :precision binary64
  (+ (* x (+ (+ (+ (+ y z) z) y) t)) (* y 5.0)))