
(FPCore (x y z) :precision binary64 (+ 1.0 (/ (* 4.0 (- (+ x (* y 0.75)) z)) y)))
double code(double x, double y, double z) {
return 1.0 + ((4.0 * ((x + (y * 0.75)) - z)) / y);
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = 1.0d0 + ((4.0d0 * ((x + (y * 0.75d0)) - z)) / y)
end function
public static double code(double x, double y, double z) {
return 1.0 + ((4.0 * ((x + (y * 0.75)) - z)) / y);
}
def code(x, y, z): return 1.0 + ((4.0 * ((x + (y * 0.75)) - z)) / y)
function code(x, y, z) return Float64(1.0 + Float64(Float64(4.0 * Float64(Float64(x + Float64(y * 0.75)) - z)) / y)) end
function tmp = code(x, y, z) tmp = 1.0 + ((4.0 * ((x + (y * 0.75)) - z)) / y); end
code[x_, y_, z_] := N[(1.0 + N[(N[(4.0 * N[(N[(x + N[(y * 0.75), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + \frac{4 \cdot \left(\left(x + y \cdot 0.75\right) - z\right)}{y}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 10 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z) :precision binary64 (+ 1.0 (/ (* 4.0 (- (+ x (* y 0.75)) z)) y)))
double code(double x, double y, double z) {
return 1.0 + ((4.0 * ((x + (y * 0.75)) - z)) / y);
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = 1.0d0 + ((4.0d0 * ((x + (y * 0.75d0)) - z)) / y)
end function
public static double code(double x, double y, double z) {
return 1.0 + ((4.0 * ((x + (y * 0.75)) - z)) / y);
}
def code(x, y, z): return 1.0 + ((4.0 * ((x + (y * 0.75)) - z)) / y)
function code(x, y, z) return Float64(1.0 + Float64(Float64(4.0 * Float64(Float64(x + Float64(y * 0.75)) - z)) / y)) end
function tmp = code(x, y, z) tmp = 1.0 + ((4.0 * ((x + (y * 0.75)) - z)) / y); end
code[x_, y_, z_] := N[(1.0 + N[(N[(4.0 * N[(N[(x + N[(y * 0.75), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
1 + \frac{4 \cdot \left(\left(x + y \cdot 0.75\right) - z\right)}{y}
\end{array}
(FPCore (x y z) :precision binary64 (fma 4.0 (/ (- x z) y) 4.0))
double code(double x, double y, double z) {
return fma(4.0, ((x - z) / y), 4.0);
}
function code(x, y, z) return fma(4.0, Float64(Float64(x - z) / y), 4.0) end
code[x_, y_, z_] := N[(4.0 * N[(N[(x - z), $MachinePrecision] / y), $MachinePrecision] + 4.0), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(4, \frac{x - z}{y}, 4\right)
\end{array}
Initial program 99.1%
Taylor expanded in x around 0
Applied rewrites100.0%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (* 4.0 (/ x y)))
(t_1 (/ (* 4.0 (- (+ x (* y 0.75)) z)) y))
(t_2 (/ z (* y -0.25))))
(if (<= t_1 (- INFINITY))
t_0
(if (<= t_1 -1e+16)
t_2
(if (<= t_1 5.0)
4.0
(if (<= t_1 5e+95) (* z (/ -4.0 y)) (if (<= t_1 5e+267) t_0 t_2)))))))
double code(double x, double y, double z) {
double t_0 = 4.0 * (x / y);
double t_1 = (4.0 * ((x + (y * 0.75)) - z)) / y;
double t_2 = z / (y * -0.25);
double tmp;
if (t_1 <= -((double) INFINITY)) {
tmp = t_0;
} else if (t_1 <= -1e+16) {
tmp = t_2;
} else if (t_1 <= 5.0) {
tmp = 4.0;
} else if (t_1 <= 5e+95) {
tmp = z * (-4.0 / y);
} else if (t_1 <= 5e+267) {
tmp = t_0;
} else {
tmp = t_2;
}
return tmp;
}
public static double code(double x, double y, double z) {
double t_0 = 4.0 * (x / y);
double t_1 = (4.0 * ((x + (y * 0.75)) - z)) / y;
double t_2 = z / (y * -0.25);
double tmp;
if (t_1 <= -Double.POSITIVE_INFINITY) {
tmp = t_0;
} else if (t_1 <= -1e+16) {
tmp = t_2;
} else if (t_1 <= 5.0) {
tmp = 4.0;
} else if (t_1 <= 5e+95) {
tmp = z * (-4.0 / y);
} else if (t_1 <= 5e+267) {
tmp = t_0;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z): t_0 = 4.0 * (x / y) t_1 = (4.0 * ((x + (y * 0.75)) - z)) / y t_2 = z / (y * -0.25) tmp = 0 if t_1 <= -math.inf: tmp = t_0 elif t_1 <= -1e+16: tmp = t_2 elif t_1 <= 5.0: tmp = 4.0 elif t_1 <= 5e+95: tmp = z * (-4.0 / y) elif t_1 <= 5e+267: tmp = t_0 else: tmp = t_2 return tmp
function code(x, y, z) t_0 = Float64(4.0 * Float64(x / y)) t_1 = Float64(Float64(4.0 * Float64(Float64(x + Float64(y * 0.75)) - z)) / y) t_2 = Float64(z / Float64(y * -0.25)) tmp = 0.0 if (t_1 <= Float64(-Inf)) tmp = t_0; elseif (t_1 <= -1e+16) tmp = t_2; elseif (t_1 <= 5.0) tmp = 4.0; elseif (t_1 <= 5e+95) tmp = Float64(z * Float64(-4.0 / y)); elseif (t_1 <= 5e+267) tmp = t_0; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z) t_0 = 4.0 * (x / y); t_1 = (4.0 * ((x + (y * 0.75)) - z)) / y; t_2 = z / (y * -0.25); tmp = 0.0; if (t_1 <= -Inf) tmp = t_0; elseif (t_1 <= -1e+16) tmp = t_2; elseif (t_1 <= 5.0) tmp = 4.0; elseif (t_1 <= 5e+95) tmp = z * (-4.0 / y); elseif (t_1 <= 5e+267) tmp = t_0; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(4.0 * N[(x / y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(4.0 * N[(N[(x + N[(y * 0.75), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, Block[{t$95$2 = N[(z / N[(y * -0.25), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, (-Infinity)], t$95$0, If[LessEqual[t$95$1, -1e+16], t$95$2, If[LessEqual[t$95$1, 5.0], 4.0, If[LessEqual[t$95$1, 5e+95], N[(z * N[(-4.0 / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 5e+267], t$95$0, t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 4 \cdot \frac{x}{y}\\
t_1 := \frac{4 \cdot \left(\left(x + y \cdot 0.75\right) - z\right)}{y}\\
t_2 := \frac{z}{y \cdot -0.25}\\
\mathbf{if}\;t\_1 \leq -\infty:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;t\_1 \leq -1 \cdot 10^{+16}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq 5:\\
\;\;\;\;4\\
\mathbf{elif}\;t\_1 \leq 5 \cdot 10^{+95}:\\
\;\;\;\;z \cdot \frac{-4}{y}\\
\mathbf{elif}\;t\_1 \leq 5 \cdot 10^{+267}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if (/.f64 (*.f64 #s(literal 4 binary64) (-.f64 (+.f64 x (*.f64 y #s(literal 3/4 binary64))) z)) y) < -inf.0 or 5.00000000000000025e95 < (/.f64 (*.f64 #s(literal 4 binary64) (-.f64 (+.f64 x (*.f64 y #s(literal 3/4 binary64))) z)) y) < 4.9999999999999999e267Initial program 100.0%
Taylor expanded in x around inf
associate-*r/N/A
lower-/.f64N/A
lower-*.f6468.9
Applied rewrites68.9%
Applied rewrites68.9%
if -inf.0 < (/.f64 (*.f64 #s(literal 4 binary64) (-.f64 (+.f64 x (*.f64 y #s(literal 3/4 binary64))) z)) y) < -1e16 or 4.9999999999999999e267 < (/.f64 (*.f64 #s(literal 4 binary64) (-.f64 (+.f64 x (*.f64 y #s(literal 3/4 binary64))) z)) y) Initial program 97.8%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
clear-numN/A
lift-*.f64N/A
associate-/r*N/A
associate-/r/N/A
clear-numN/A
lower-fma.f64N/A
lower-/.f6499.8
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6499.8
Applied rewrites99.8%
Taylor expanded in z around inf
*-lft-identityN/A
associate-*l/N/A
associate-*r*N/A
metadata-evalN/A
distribute-lft-neg-inN/A
*-commutativeN/A
lower-*.f64N/A
associate-*r/N/A
metadata-evalN/A
distribute-neg-fracN/A
metadata-evalN/A
lower-/.f6466.0
Applied rewrites66.0%
Applied rewrites66.1%
if -1e16 < (/.f64 (*.f64 #s(literal 4 binary64) (-.f64 (+.f64 x (*.f64 y #s(literal 3/4 binary64))) z)) y) < 5Initial program 99.8%
Taylor expanded in y around inf
Applied rewrites96.9%
if 5 < (/.f64 (*.f64 #s(literal 4 binary64) (-.f64 (+.f64 x (*.f64 y #s(literal 3/4 binary64))) z)) y) < 5.00000000000000025e95Initial program 99.7%
Taylor expanded in z around inf
*-lft-identityN/A
associate-*l/N/A
associate-*l*N/A
metadata-evalN/A
distribute-lft-neg-inN/A
*-commutativeN/A
lower-*.f64N/A
associate-*r/N/A
metadata-evalN/A
distribute-neg-fracN/A
metadata-evalN/A
lower-/.f6469.1
Applied rewrites69.1%
Final simplification77.8%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (* 4.0 (/ x y)))
(t_1 (/ (* 4.0 (- (+ x (* y 0.75)) z)) y))
(t_2 (* z (/ -4.0 y))))
(if (<= t_1 (- INFINITY))
t_0
(if (<= t_1 -1e+16)
t_2
(if (<= t_1 5.0)
4.0
(if (<= t_1 5e+95) t_2 (if (<= t_1 5e+267) t_0 t_2)))))))
double code(double x, double y, double z) {
double t_0 = 4.0 * (x / y);
double t_1 = (4.0 * ((x + (y * 0.75)) - z)) / y;
double t_2 = z * (-4.0 / y);
double tmp;
if (t_1 <= -((double) INFINITY)) {
tmp = t_0;
} else if (t_1 <= -1e+16) {
tmp = t_2;
} else if (t_1 <= 5.0) {
tmp = 4.0;
} else if (t_1 <= 5e+95) {
tmp = t_2;
} else if (t_1 <= 5e+267) {
tmp = t_0;
} else {
tmp = t_2;
}
return tmp;
}
public static double code(double x, double y, double z) {
double t_0 = 4.0 * (x / y);
double t_1 = (4.0 * ((x + (y * 0.75)) - z)) / y;
double t_2 = z * (-4.0 / y);
double tmp;
if (t_1 <= -Double.POSITIVE_INFINITY) {
tmp = t_0;
} else if (t_1 <= -1e+16) {
tmp = t_2;
} else if (t_1 <= 5.0) {
tmp = 4.0;
} else if (t_1 <= 5e+95) {
tmp = t_2;
} else if (t_1 <= 5e+267) {
tmp = t_0;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z): t_0 = 4.0 * (x / y) t_1 = (4.0 * ((x + (y * 0.75)) - z)) / y t_2 = z * (-4.0 / y) tmp = 0 if t_1 <= -math.inf: tmp = t_0 elif t_1 <= -1e+16: tmp = t_2 elif t_1 <= 5.0: tmp = 4.0 elif t_1 <= 5e+95: tmp = t_2 elif t_1 <= 5e+267: tmp = t_0 else: tmp = t_2 return tmp
function code(x, y, z) t_0 = Float64(4.0 * Float64(x / y)) t_1 = Float64(Float64(4.0 * Float64(Float64(x + Float64(y * 0.75)) - z)) / y) t_2 = Float64(z * Float64(-4.0 / y)) tmp = 0.0 if (t_1 <= Float64(-Inf)) tmp = t_0; elseif (t_1 <= -1e+16) tmp = t_2; elseif (t_1 <= 5.0) tmp = 4.0; elseif (t_1 <= 5e+95) tmp = t_2; elseif (t_1 <= 5e+267) tmp = t_0; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z) t_0 = 4.0 * (x / y); t_1 = (4.0 * ((x + (y * 0.75)) - z)) / y; t_2 = z * (-4.0 / y); tmp = 0.0; if (t_1 <= -Inf) tmp = t_0; elseif (t_1 <= -1e+16) tmp = t_2; elseif (t_1 <= 5.0) tmp = 4.0; elseif (t_1 <= 5e+95) tmp = t_2; elseif (t_1 <= 5e+267) tmp = t_0; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(4.0 * N[(x / y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(4.0 * N[(N[(x + N[(y * 0.75), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, Block[{t$95$2 = N[(z * N[(-4.0 / y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, (-Infinity)], t$95$0, If[LessEqual[t$95$1, -1e+16], t$95$2, If[LessEqual[t$95$1, 5.0], 4.0, If[LessEqual[t$95$1, 5e+95], t$95$2, If[LessEqual[t$95$1, 5e+267], t$95$0, t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 4 \cdot \frac{x}{y}\\
t_1 := \frac{4 \cdot \left(\left(x + y \cdot 0.75\right) - z\right)}{y}\\
t_2 := z \cdot \frac{-4}{y}\\
\mathbf{if}\;t\_1 \leq -\infty:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;t\_1 \leq -1 \cdot 10^{+16}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq 5:\\
\;\;\;\;4\\
\mathbf{elif}\;t\_1 \leq 5 \cdot 10^{+95}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq 5 \cdot 10^{+267}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if (/.f64 (*.f64 #s(literal 4 binary64) (-.f64 (+.f64 x (*.f64 y #s(literal 3/4 binary64))) z)) y) < -inf.0 or 5.00000000000000025e95 < (/.f64 (*.f64 #s(literal 4 binary64) (-.f64 (+.f64 x (*.f64 y #s(literal 3/4 binary64))) z)) y) < 4.9999999999999999e267Initial program 100.0%
Taylor expanded in x around inf
associate-*r/N/A
lower-/.f64N/A
lower-*.f6468.9
Applied rewrites68.9%
Applied rewrites68.9%
if -inf.0 < (/.f64 (*.f64 #s(literal 4 binary64) (-.f64 (+.f64 x (*.f64 y #s(literal 3/4 binary64))) z)) y) < -1e16 or 5 < (/.f64 (*.f64 #s(literal 4 binary64) (-.f64 (+.f64 x (*.f64 y #s(literal 3/4 binary64))) z)) y) < 5.00000000000000025e95 or 4.9999999999999999e267 < (/.f64 (*.f64 #s(literal 4 binary64) (-.f64 (+.f64 x (*.f64 y #s(literal 3/4 binary64))) z)) y) Initial program 98.1%
Taylor expanded in z around inf
*-lft-identityN/A
associate-*l/N/A
associate-*l*N/A
metadata-evalN/A
distribute-lft-neg-inN/A
*-commutativeN/A
lower-*.f64N/A
associate-*r/N/A
metadata-evalN/A
distribute-neg-fracN/A
metadata-evalN/A
lower-/.f6466.5
Applied rewrites66.5%
if -1e16 < (/.f64 (*.f64 #s(literal 4 binary64) (-.f64 (+.f64 x (*.f64 y #s(literal 3/4 binary64))) z)) y) < 5Initial program 99.8%
Taylor expanded in y around inf
Applied rewrites96.9%
Final simplification77.8%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (/ (* 4.0 (- (+ x (* y 0.75)) z)) y)))
(if (<= t_0 -2e+19)
(/ (* 4.0 (- x z)) y)
(if (<= t_0 50000000000.0)
(fma -4.0 (/ z y) 4.0)
(* (- x z) (/ 4.0 y))))))
double code(double x, double y, double z) {
double t_0 = (4.0 * ((x + (y * 0.75)) - z)) / y;
double tmp;
if (t_0 <= -2e+19) {
tmp = (4.0 * (x - z)) / y;
} else if (t_0 <= 50000000000.0) {
tmp = fma(-4.0, (z / y), 4.0);
} else {
tmp = (x - z) * (4.0 / y);
}
return tmp;
}
function code(x, y, z) t_0 = Float64(Float64(4.0 * Float64(Float64(x + Float64(y * 0.75)) - z)) / y) tmp = 0.0 if (t_0 <= -2e+19) tmp = Float64(Float64(4.0 * Float64(x - z)) / y); elseif (t_0 <= 50000000000.0) tmp = fma(-4.0, Float64(z / y), 4.0); else tmp = Float64(Float64(x - z) * Float64(4.0 / y)); end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(4.0 * N[(N[(x + N[(y * 0.75), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[t$95$0, -2e+19], N[(N[(4.0 * N[(x - z), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[t$95$0, 50000000000.0], N[(-4.0 * N[(z / y), $MachinePrecision] + 4.0), $MachinePrecision], N[(N[(x - z), $MachinePrecision] * N[(4.0 / y), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{4 \cdot \left(\left(x + y \cdot 0.75\right) - z\right)}{y}\\
\mathbf{if}\;t\_0 \leq -2 \cdot 10^{+19}:\\
\;\;\;\;\frac{4 \cdot \left(x - z\right)}{y}\\
\mathbf{elif}\;t\_0 \leq 50000000000:\\
\;\;\;\;\mathsf{fma}\left(-4, \frac{z}{y}, 4\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x - z\right) \cdot \frac{4}{y}\\
\end{array}
\end{array}
if (/.f64 (*.f64 #s(literal 4 binary64) (-.f64 (+.f64 x (*.f64 y #s(literal 3/4 binary64))) z)) y) < -2e19Initial program 100.0%
Taylor expanded in y around 0
associate-*r/N/A
lower-/.f64N/A
Applied rewrites100.0%
if -2e19 < (/.f64 (*.f64 #s(literal 4 binary64) (-.f64 (+.f64 x (*.f64 y #s(literal 3/4 binary64))) z)) y) < 5e10Initial program 99.7%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
clear-numN/A
lift-*.f64N/A
associate-/r*N/A
associate-/r/N/A
clear-numN/A
lower-fma.f64N/A
lower-/.f6499.7
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6499.7
Applied rewrites99.7%
Taylor expanded in x around 0
div-subN/A
sub-negN/A
+-commutativeN/A
associate-/l*N/A
*-inversesN/A
metadata-evalN/A
+-commutativeN/A
sub-negN/A
sub-negN/A
distribute-lft-inN/A
distribute-rgt-neg-inN/A
distribute-lft-neg-inN/A
metadata-evalN/A
associate-+r+N/A
metadata-evalN/A
metadata-evalN/A
+-commutativeN/A
Applied rewrites98.9%
Taylor expanded in y around 0
Applied rewrites98.8%
Taylor expanded in x around 0
div-subN/A
sub-negN/A
distribute-lft-inN/A
associate-*r/N/A
*-inversesN/A
metadata-evalN/A
distribute-rgt-neg-inN/A
distribute-lft-neg-inN/A
metadata-evalN/A
associate-+r+N/A
metadata-evalN/A
metadata-evalN/A
+-commutativeN/A
lower-fma.f64N/A
lower-/.f6498.9
Applied rewrites98.9%
if 5e10 < (/.f64 (*.f64 #s(literal 4 binary64) (-.f64 (+.f64 x (*.f64 y #s(literal 3/4 binary64))) z)) y) Initial program 97.6%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
clear-numN/A
lift-*.f64N/A
associate-/r*N/A
associate-/r/N/A
clear-numN/A
lower-fma.f64N/A
lower-/.f6499.7
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6499.7
Applied rewrites99.7%
Taylor expanded in z around inf
*-lft-identityN/A
associate-*l/N/A
associate-*r*N/A
metadata-evalN/A
distribute-lft-neg-inN/A
*-commutativeN/A
lower-*.f64N/A
associate-*r/N/A
metadata-evalN/A
distribute-neg-fracN/A
metadata-evalN/A
lower-/.f6455.0
Applied rewrites55.0%
Taylor expanded in y around 0
associate-*r/N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f6497.0
Applied rewrites97.0%
Applied rewrites99.1%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (/ (* 4.0 (- x z)) y)) (t_1 (/ (* 4.0 (- (+ x (* y 0.75)) z)) y)))
(if (<= t_1 -2e+19)
t_0
(if (<= t_1 50000000000.0) (fma -4.0 (/ z y) 4.0) t_0))))
double code(double x, double y, double z) {
double t_0 = (4.0 * (x - z)) / y;
double t_1 = (4.0 * ((x + (y * 0.75)) - z)) / y;
double tmp;
if (t_1 <= -2e+19) {
tmp = t_0;
} else if (t_1 <= 50000000000.0) {
tmp = fma(-4.0, (z / y), 4.0);
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y, z) t_0 = Float64(Float64(4.0 * Float64(x - z)) / y) t_1 = Float64(Float64(4.0 * Float64(Float64(x + Float64(y * 0.75)) - z)) / y) tmp = 0.0 if (t_1 <= -2e+19) tmp = t_0; elseif (t_1 <= 50000000000.0) tmp = fma(-4.0, Float64(z / y), 4.0); else tmp = t_0; end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(4.0 * N[(x - z), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, Block[{t$95$1 = N[(N[(4.0 * N[(N[(x + N[(y * 0.75), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[t$95$1, -2e+19], t$95$0, If[LessEqual[t$95$1, 50000000000.0], N[(-4.0 * N[(z / y), $MachinePrecision] + 4.0), $MachinePrecision], t$95$0]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{4 \cdot \left(x - z\right)}{y}\\
t_1 := \frac{4 \cdot \left(\left(x + y \cdot 0.75\right) - z\right)}{y}\\
\mathbf{if}\;t\_1 \leq -2 \cdot 10^{+19}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;t\_1 \leq 50000000000:\\
\;\;\;\;\mathsf{fma}\left(-4, \frac{z}{y}, 4\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if (/.f64 (*.f64 #s(literal 4 binary64) (-.f64 (+.f64 x (*.f64 y #s(literal 3/4 binary64))) z)) y) < -2e19 or 5e10 < (/.f64 (*.f64 #s(literal 4 binary64) (-.f64 (+.f64 x (*.f64 y #s(literal 3/4 binary64))) z)) y) Initial program 98.8%
Taylor expanded in y around 0
associate-*r/N/A
lower-/.f64N/A
Applied rewrites98.5%
if -2e19 < (/.f64 (*.f64 #s(literal 4 binary64) (-.f64 (+.f64 x (*.f64 y #s(literal 3/4 binary64))) z)) y) < 5e10Initial program 99.7%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
clear-numN/A
lift-*.f64N/A
associate-/r*N/A
associate-/r/N/A
clear-numN/A
lower-fma.f64N/A
lower-/.f6499.7
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6499.7
Applied rewrites99.7%
Taylor expanded in x around 0
div-subN/A
sub-negN/A
+-commutativeN/A
associate-/l*N/A
*-inversesN/A
metadata-evalN/A
+-commutativeN/A
sub-negN/A
sub-negN/A
distribute-lft-inN/A
distribute-rgt-neg-inN/A
distribute-lft-neg-inN/A
metadata-evalN/A
associate-+r+N/A
metadata-evalN/A
metadata-evalN/A
+-commutativeN/A
Applied rewrites98.9%
Taylor expanded in y around 0
Applied rewrites98.8%
Taylor expanded in x around 0
div-subN/A
sub-negN/A
distribute-lft-inN/A
associate-*r/N/A
*-inversesN/A
metadata-evalN/A
distribute-rgt-neg-inN/A
distribute-lft-neg-inN/A
metadata-evalN/A
associate-+r+N/A
metadata-evalN/A
metadata-evalN/A
+-commutativeN/A
lower-fma.f64N/A
lower-/.f6498.9
Applied rewrites98.9%
(FPCore (x y z) :precision binary64 (let* ((t_0 (* z (/ -4.0 y))) (t_1 (/ (* 4.0 (- (+ x (* y 0.75)) z)) y))) (if (<= t_1 -1e+16) t_0 (if (<= t_1 5.0) 4.0 t_0))))
double code(double x, double y, double z) {
double t_0 = z * (-4.0 / y);
double t_1 = (4.0 * ((x + (y * 0.75)) - z)) / y;
double tmp;
if (t_1 <= -1e+16) {
tmp = t_0;
} else if (t_1 <= 5.0) {
tmp = 4.0;
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = z * ((-4.0d0) / y)
t_1 = (4.0d0 * ((x + (y * 0.75d0)) - z)) / y
if (t_1 <= (-1d+16)) then
tmp = t_0
else if (t_1 <= 5.0d0) then
tmp = 4.0d0
else
tmp = t_0
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = z * (-4.0 / y);
double t_1 = (4.0 * ((x + (y * 0.75)) - z)) / y;
double tmp;
if (t_1 <= -1e+16) {
tmp = t_0;
} else if (t_1 <= 5.0) {
tmp = 4.0;
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y, z): t_0 = z * (-4.0 / y) t_1 = (4.0 * ((x + (y * 0.75)) - z)) / y tmp = 0 if t_1 <= -1e+16: tmp = t_0 elif t_1 <= 5.0: tmp = 4.0 else: tmp = t_0 return tmp
function code(x, y, z) t_0 = Float64(z * Float64(-4.0 / y)) t_1 = Float64(Float64(4.0 * Float64(Float64(x + Float64(y * 0.75)) - z)) / y) tmp = 0.0 if (t_1 <= -1e+16) tmp = t_0; elseif (t_1 <= 5.0) tmp = 4.0; else tmp = t_0; end return tmp end
function tmp_2 = code(x, y, z) t_0 = z * (-4.0 / y); t_1 = (4.0 * ((x + (y * 0.75)) - z)) / y; tmp = 0.0; if (t_1 <= -1e+16) tmp = t_0; elseif (t_1 <= 5.0) tmp = 4.0; else tmp = t_0; end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(z * N[(-4.0 / y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(4.0 * N[(N[(x + N[(y * 0.75), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[t$95$1, -1e+16], t$95$0, If[LessEqual[t$95$1, 5.0], 4.0, t$95$0]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := z \cdot \frac{-4}{y}\\
t_1 := \frac{4 \cdot \left(\left(x + y \cdot 0.75\right) - z\right)}{y}\\
\mathbf{if}\;t\_1 \leq -1 \cdot 10^{+16}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;t\_1 \leq 5:\\
\;\;\;\;4\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if (/.f64 (*.f64 #s(literal 4 binary64) (-.f64 (+.f64 x (*.f64 y #s(literal 3/4 binary64))) z)) y) < -1e16 or 5 < (/.f64 (*.f64 #s(literal 4 binary64) (-.f64 (+.f64 x (*.f64 y #s(literal 3/4 binary64))) z)) y) Initial program 98.8%
Taylor expanded in z around inf
*-lft-identityN/A
associate-*l/N/A
associate-*l*N/A
metadata-evalN/A
distribute-lft-neg-inN/A
*-commutativeN/A
lower-*.f64N/A
associate-*r/N/A
metadata-evalN/A
distribute-neg-fracN/A
metadata-evalN/A
lower-/.f6454.8
Applied rewrites54.8%
if -1e16 < (/.f64 (*.f64 #s(literal 4 binary64) (-.f64 (+.f64 x (*.f64 y #s(literal 3/4 binary64))) z)) y) < 5Initial program 99.8%
Taylor expanded in y around inf
Applied rewrites96.9%
(FPCore (x y z) :precision binary64 (let* ((t_0 (fma -4.0 (/ z y) 4.0))) (if (<= z -6.5e-27) t_0 (if (<= z 0.16) (fma 4.0 (/ x y) 4.0) t_0))))
double code(double x, double y, double z) {
double t_0 = fma(-4.0, (z / y), 4.0);
double tmp;
if (z <= -6.5e-27) {
tmp = t_0;
} else if (z <= 0.16) {
tmp = fma(4.0, (x / y), 4.0);
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y, z) t_0 = fma(-4.0, Float64(z / y), 4.0) tmp = 0.0 if (z <= -6.5e-27) tmp = t_0; elseif (z <= 0.16) tmp = fma(4.0, Float64(x / y), 4.0); else tmp = t_0; end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(-4.0 * N[(z / y), $MachinePrecision] + 4.0), $MachinePrecision]}, If[LessEqual[z, -6.5e-27], t$95$0, If[LessEqual[z, 0.16], N[(4.0 * N[(x / y), $MachinePrecision] + 4.0), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(-4, \frac{z}{y}, 4\right)\\
\mathbf{if}\;z \leq -6.5 \cdot 10^{-27}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;z \leq 0.16:\\
\;\;\;\;\mathsf{fma}\left(4, \frac{x}{y}, 4\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if z < -6.50000000000000025e-27 or 0.160000000000000003 < z Initial program 98.5%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
clear-numN/A
lift-*.f64N/A
associate-/r*N/A
associate-/r/N/A
clear-numN/A
lower-fma.f64N/A
lower-/.f6499.7
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6499.8
Applied rewrites99.8%
Taylor expanded in x around 0
div-subN/A
sub-negN/A
+-commutativeN/A
associate-/l*N/A
*-inversesN/A
metadata-evalN/A
+-commutativeN/A
sub-negN/A
sub-negN/A
distribute-lft-inN/A
distribute-rgt-neg-inN/A
distribute-lft-neg-inN/A
metadata-evalN/A
associate-+r+N/A
metadata-evalN/A
metadata-evalN/A
+-commutativeN/A
Applied rewrites87.9%
Taylor expanded in y around 0
Applied rewrites87.2%
Taylor expanded in x around 0
div-subN/A
sub-negN/A
distribute-lft-inN/A
associate-*r/N/A
*-inversesN/A
metadata-evalN/A
distribute-rgt-neg-inN/A
distribute-lft-neg-inN/A
metadata-evalN/A
associate-+r+N/A
metadata-evalN/A
metadata-evalN/A
+-commutativeN/A
lower-fma.f64N/A
lower-/.f6488.0
Applied rewrites88.0%
if -6.50000000000000025e-27 < z < 0.160000000000000003Initial program 99.9%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
clear-numN/A
lift-*.f64N/A
associate-/r*N/A
associate-/r/N/A
clear-numN/A
lower-fma.f64N/A
lower-/.f6499.7
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6499.7
Applied rewrites99.7%
Taylor expanded in z around 0
+-commutativeN/A
remove-double-negN/A
mul-1-negN/A
unsub-negN/A
div-subN/A
associate-/l*N/A
*-inversesN/A
metadata-evalN/A
associate-*r/N/A
unsub-negN/A
metadata-evalN/A
distribute-neg-inN/A
+-commutativeN/A
metadata-evalN/A
sub-negN/A
neg-sub0N/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
mul-1-negN/A
Applied rewrites94.1%
(FPCore (x y z) :precision binary64 (let* ((t_0 (* 4.0 (/ x y)))) (if (<= x -1.1e+141) t_0 (if (<= x 6.5e+141) (fma -4.0 (/ z y) 4.0) t_0))))
double code(double x, double y, double z) {
double t_0 = 4.0 * (x / y);
double tmp;
if (x <= -1.1e+141) {
tmp = t_0;
} else if (x <= 6.5e+141) {
tmp = fma(-4.0, (z / y), 4.0);
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y, z) t_0 = Float64(4.0 * Float64(x / y)) tmp = 0.0 if (x <= -1.1e+141) tmp = t_0; elseif (x <= 6.5e+141) tmp = fma(-4.0, Float64(z / y), 4.0); else tmp = t_0; end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(4.0 * N[(x / y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.1e+141], t$95$0, If[LessEqual[x, 6.5e+141], N[(-4.0 * N[(z / y), $MachinePrecision] + 4.0), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 4 \cdot \frac{x}{y}\\
\mathbf{if}\;x \leq -1.1 \cdot 10^{+141}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;x \leq 6.5 \cdot 10^{+141}:\\
\;\;\;\;\mathsf{fma}\left(-4, \frac{z}{y}, 4\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if x < -1.1e141 or 6.50000000000000053e141 < x Initial program 97.5%
Taylor expanded in x around inf
associate-*r/N/A
lower-/.f64N/A
lower-*.f6479.7
Applied rewrites79.7%
Applied rewrites81.0%
if -1.1e141 < x < 6.50000000000000053e141Initial program 99.9%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
clear-numN/A
lift-*.f64N/A
associate-/r*N/A
associate-/r/N/A
clear-numN/A
lower-fma.f64N/A
lower-/.f6499.7
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6499.7
Applied rewrites99.7%
Taylor expanded in x around 0
div-subN/A
sub-negN/A
+-commutativeN/A
associate-/l*N/A
*-inversesN/A
metadata-evalN/A
+-commutativeN/A
sub-negN/A
sub-negN/A
distribute-lft-inN/A
distribute-rgt-neg-inN/A
distribute-lft-neg-inN/A
metadata-evalN/A
associate-+r+N/A
metadata-evalN/A
metadata-evalN/A
+-commutativeN/A
Applied rewrites90.7%
Taylor expanded in y around 0
Applied rewrites90.8%
Taylor expanded in x around 0
div-subN/A
sub-negN/A
distribute-lft-inN/A
associate-*r/N/A
*-inversesN/A
metadata-evalN/A
distribute-rgt-neg-inN/A
distribute-lft-neg-inN/A
metadata-evalN/A
associate-+r+N/A
metadata-evalN/A
metadata-evalN/A
+-commutativeN/A
lower-fma.f64N/A
lower-/.f6490.8
Applied rewrites90.8%
Final simplification87.9%
(FPCore (x y z) :precision binary64 (let* ((t_0 (* 4.0 (/ x y)))) (if (<= x -1.1e+141) t_0 (if (<= x 6.5e+141) (fma z (/ -4.0 y) 4.0) t_0))))
double code(double x, double y, double z) {
double t_0 = 4.0 * (x / y);
double tmp;
if (x <= -1.1e+141) {
tmp = t_0;
} else if (x <= 6.5e+141) {
tmp = fma(z, (-4.0 / y), 4.0);
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y, z) t_0 = Float64(4.0 * Float64(x / y)) tmp = 0.0 if (x <= -1.1e+141) tmp = t_0; elseif (x <= 6.5e+141) tmp = fma(z, Float64(-4.0 / y), 4.0); else tmp = t_0; end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(4.0 * N[(x / y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.1e+141], t$95$0, If[LessEqual[x, 6.5e+141], N[(z * N[(-4.0 / y), $MachinePrecision] + 4.0), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 4 \cdot \frac{x}{y}\\
\mathbf{if}\;x \leq -1.1 \cdot 10^{+141}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;x \leq 6.5 \cdot 10^{+141}:\\
\;\;\;\;\mathsf{fma}\left(z, \frac{-4}{y}, 4\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if x < -1.1e141 or 6.50000000000000053e141 < x Initial program 97.5%
Taylor expanded in x around inf
associate-*r/N/A
lower-/.f64N/A
lower-*.f6479.7
Applied rewrites79.7%
Applied rewrites81.0%
if -1.1e141 < x < 6.50000000000000053e141Initial program 99.9%
Taylor expanded in x around 0
+-commutativeN/A
*-commutativeN/A
div-subN/A
associate-/l*N/A
*-inversesN/A
metadata-evalN/A
*-commutativeN/A
sub-negN/A
+-commutativeN/A
distribute-rgt-inN/A
*-commutativeN/A
*-lft-identityN/A
associate-*l/N/A
distribute-rgt-neg-inN/A
associate-*l*N/A
metadata-evalN/A
associate-+l+N/A
Applied rewrites90.7%
Final simplification87.8%
(FPCore (x y z) :precision binary64 4.0)
double code(double x, double y, double z) {
return 4.0;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = 4.0d0
end function
public static double code(double x, double y, double z) {
return 4.0;
}
def code(x, y, z): return 4.0
function code(x, y, z) return 4.0 end
function tmp = code(x, y, z) tmp = 4.0; end
code[x_, y_, z_] := 4.0
\begin{array}{l}
\\
4
\end{array}
Initial program 99.1%
Taylor expanded in y around inf
Applied rewrites35.9%
herbie shell --seed 2024219
(FPCore (x y z)
:name "Data.Array.Repa.Algorithms.ColorRamp:rampColorHotToCold from repa-algorithms-3.4.0.1, A"
:precision binary64
(+ 1.0 (/ (* 4.0 (- (+ x (* y 0.75)) z)) y)))