
(FPCore (x y z) :precision binary64 (* x (- 1.0 (* y z))))
double code(double x, double y, double z) {
return x * (1.0 - (y * z));
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = x * (1.0d0 - (y * z))
end function
public static double code(double x, double y, double z) {
return x * (1.0 - (y * z));
}
def code(x, y, z): return x * (1.0 - (y * z))
function code(x, y, z) return Float64(x * Float64(1.0 - Float64(y * z))) end
function tmp = code(x, y, z) tmp = x * (1.0 - (y * z)); end
code[x_, y_, z_] := N[(x * N[(1.0 - N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot \left(1 - y \cdot z\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 7 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z) :precision binary64 (* x (- 1.0 (* y z))))
double code(double x, double y, double z) {
return x * (1.0 - (y * z));
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = x * (1.0d0 - (y * z))
end function
public static double code(double x, double y, double z) {
return x * (1.0 - (y * z));
}
def code(x, y, z): return x * (1.0 - (y * z))
function code(x, y, z) return Float64(x * Float64(1.0 - Float64(y * z))) end
function tmp = code(x, y, z) tmp = x * (1.0 - (y * z)); end
code[x_, y_, z_] := N[(x * N[(1.0 - N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot \left(1 - y \cdot z\right)
\end{array}
x\_m = (fabs.f64 x)
x\_s = (copysign.f64 #s(literal 1 binary64) x)
(FPCore (x_s x_m y z)
:precision binary64
(let* ((t_0 (* (- 1.0 (* z y)) x_m)))
(*
x_s
(if (<= t_0 (- INFINITY))
(/ y (/ -1.0 (* z x_m)))
(if (<= t_0 5e+268) t_0 (fma (* (- y) x_m) z x_m))))))x\_m = fabs(x);
x\_s = copysign(1.0, x);
double code(double x_s, double x_m, double y, double z) {
double t_0 = (1.0 - (z * y)) * x_m;
double tmp;
if (t_0 <= -((double) INFINITY)) {
tmp = y / (-1.0 / (z * x_m));
} else if (t_0 <= 5e+268) {
tmp = t_0;
} else {
tmp = fma((-y * x_m), z, x_m);
}
return x_s * tmp;
}
x\_m = abs(x) x\_s = copysign(1.0, x) function code(x_s, x_m, y, z) t_0 = Float64(Float64(1.0 - Float64(z * y)) * x_m) tmp = 0.0 if (t_0 <= Float64(-Inf)) tmp = Float64(y / Float64(-1.0 / Float64(z * x_m))); elseif (t_0 <= 5e+268) tmp = t_0; else tmp = fma(Float64(Float64(-y) * x_m), z, x_m); end return Float64(x_s * tmp) end
x\_m = N[Abs[x], $MachinePrecision]
x\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[x$95$s_, x$95$m_, y_, z_] := Block[{t$95$0 = N[(N[(1.0 - N[(z * y), $MachinePrecision]), $MachinePrecision] * x$95$m), $MachinePrecision]}, N[(x$95$s * If[LessEqual[t$95$0, (-Infinity)], N[(y / N[(-1.0 / N[(z * x$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 5e+268], t$95$0, N[(N[((-y) * x$95$m), $MachinePrecision] * z + x$95$m), $MachinePrecision]]]), $MachinePrecision]]
\begin{array}{l}
x\_m = \left|x\right|
\\
x\_s = \mathsf{copysign}\left(1, x\right)
\\
\begin{array}{l}
t_0 := \left(1 - z \cdot y\right) \cdot x\_m\\
x\_s \cdot \begin{array}{l}
\mathbf{if}\;t\_0 \leq -\infty:\\
\;\;\;\;\frac{y}{\frac{-1}{z \cdot x\_m}}\\
\mathbf{elif}\;t\_0 \leq 5 \cdot 10^{+268}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\left(-y\right) \cdot x\_m, z, x\_m\right)\\
\end{array}
\end{array}
\end{array}
if (*.f64 x (-.f64 #s(literal 1 binary64) (*.f64 y z))) < -inf.0Initial program 75.5%
lift-*.f64N/A
*-commutativeN/A
lift--.f64N/A
flip3--N/A
associate-*l/N/A
lower-/.f64N/A
lower-*.f64N/A
metadata-evalN/A
lower--.f64N/A
lower-pow.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
metadata-evalN/A
+-commutativeN/A
*-lft-identityN/A
distribute-lft1-inN/A
+-commutativeN/A
Applied rewrites11.1%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-pow.f64N/A
cube-multN/A
distribute-lft-neg-inN/A
lift-*.f64N/A
distribute-lft-neg-outN/A
lift-neg.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lift-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites7.5%
Taylor expanded in z around inf
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6499.9
Applied rewrites99.9%
Applied rewrites99.9%
if -inf.0 < (*.f64 x (-.f64 #s(literal 1 binary64) (*.f64 y z))) < 5.0000000000000002e268Initial program 99.9%
if 5.0000000000000002e268 < (*.f64 x (-.f64 #s(literal 1 binary64) (*.f64 y z))) Initial program 87.9%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
distribute-lft-inN/A
lift-*.f64N/A
distribute-lft-neg-inN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f6492.9
Applied rewrites92.9%
Final simplification98.8%
x\_m = (fabs.f64 x)
x\_s = (copysign.f64 #s(literal 1 binary64) x)
(FPCore (x_s x_m y z)
:precision binary64
(let* ((t_0 (* (- 1.0 (* z y)) x_m)))
(*
x_s
(if (<= t_0 (- INFINITY))
(* (* (- z) x_m) y)
(if (<= t_0 5e+268) t_0 (fma (* (- y) x_m) z x_m))))))x\_m = fabs(x);
x\_s = copysign(1.0, x);
double code(double x_s, double x_m, double y, double z) {
double t_0 = (1.0 - (z * y)) * x_m;
double tmp;
if (t_0 <= -((double) INFINITY)) {
tmp = (-z * x_m) * y;
} else if (t_0 <= 5e+268) {
tmp = t_0;
} else {
tmp = fma((-y * x_m), z, x_m);
}
return x_s * tmp;
}
x\_m = abs(x) x\_s = copysign(1.0, x) function code(x_s, x_m, y, z) t_0 = Float64(Float64(1.0 - Float64(z * y)) * x_m) tmp = 0.0 if (t_0 <= Float64(-Inf)) tmp = Float64(Float64(Float64(-z) * x_m) * y); elseif (t_0 <= 5e+268) tmp = t_0; else tmp = fma(Float64(Float64(-y) * x_m), z, x_m); end return Float64(x_s * tmp) end
x\_m = N[Abs[x], $MachinePrecision]
x\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[x$95$s_, x$95$m_, y_, z_] := Block[{t$95$0 = N[(N[(1.0 - N[(z * y), $MachinePrecision]), $MachinePrecision] * x$95$m), $MachinePrecision]}, N[(x$95$s * If[LessEqual[t$95$0, (-Infinity)], N[(N[((-z) * x$95$m), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[t$95$0, 5e+268], t$95$0, N[(N[((-y) * x$95$m), $MachinePrecision] * z + x$95$m), $MachinePrecision]]]), $MachinePrecision]]
\begin{array}{l}
x\_m = \left|x\right|
\\
x\_s = \mathsf{copysign}\left(1, x\right)
\\
\begin{array}{l}
t_0 := \left(1 - z \cdot y\right) \cdot x\_m\\
x\_s \cdot \begin{array}{l}
\mathbf{if}\;t\_0 \leq -\infty:\\
\;\;\;\;\left(\left(-z\right) \cdot x\_m\right) \cdot y\\
\mathbf{elif}\;t\_0 \leq 5 \cdot 10^{+268}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\left(-y\right) \cdot x\_m, z, x\_m\right)\\
\end{array}
\end{array}
\end{array}
if (*.f64 x (-.f64 #s(literal 1 binary64) (*.f64 y z))) < -inf.0Initial program 75.5%
lift-*.f64N/A
*-commutativeN/A
lift--.f64N/A
flip3--N/A
associate-*l/N/A
lower-/.f64N/A
lower-*.f64N/A
metadata-evalN/A
lower--.f64N/A
lower-pow.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
metadata-evalN/A
+-commutativeN/A
*-lft-identityN/A
distribute-lft1-inN/A
+-commutativeN/A
Applied rewrites11.1%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-pow.f64N/A
cube-multN/A
distribute-lft-neg-inN/A
lift-*.f64N/A
distribute-lft-neg-outN/A
lift-neg.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lift-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites7.5%
Taylor expanded in z around inf
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6499.9
Applied rewrites99.9%
if -inf.0 < (*.f64 x (-.f64 #s(literal 1 binary64) (*.f64 y z))) < 5.0000000000000002e268Initial program 99.9%
if 5.0000000000000002e268 < (*.f64 x (-.f64 #s(literal 1 binary64) (*.f64 y z))) Initial program 87.9%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
distribute-lft-inN/A
lift-*.f64N/A
distribute-lft-neg-inN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f6492.9
Applied rewrites92.9%
Final simplification98.8%
x\_m = (fabs.f64 x) x\_s = (copysign.f64 #s(literal 1 binary64) x) (FPCore (x_s x_m y z) :precision binary64 (let* ((t_0 (* (* (- z) x_m) y)) (t_1 (* (- 1.0 (* z y)) x_m))) (* x_s (if (<= t_1 (- INFINITY)) t_0 (if (<= t_1 2e+298) t_1 t_0)))))
x\_m = fabs(x);
x\_s = copysign(1.0, x);
double code(double x_s, double x_m, double y, double z) {
double t_0 = (-z * x_m) * y;
double t_1 = (1.0 - (z * y)) * x_m;
double tmp;
if (t_1 <= -((double) INFINITY)) {
tmp = t_0;
} else if (t_1 <= 2e+298) {
tmp = t_1;
} else {
tmp = t_0;
}
return x_s * tmp;
}
x\_m = Math.abs(x);
x\_s = Math.copySign(1.0, x);
public static double code(double x_s, double x_m, double y, double z) {
double t_0 = (-z * x_m) * y;
double t_1 = (1.0 - (z * y)) * x_m;
double tmp;
if (t_1 <= -Double.POSITIVE_INFINITY) {
tmp = t_0;
} else if (t_1 <= 2e+298) {
tmp = t_1;
} else {
tmp = t_0;
}
return x_s * tmp;
}
x\_m = math.fabs(x) x\_s = math.copysign(1.0, x) def code(x_s, x_m, y, z): t_0 = (-z * x_m) * y t_1 = (1.0 - (z * y)) * x_m tmp = 0 if t_1 <= -math.inf: tmp = t_0 elif t_1 <= 2e+298: tmp = t_1 else: tmp = t_0 return x_s * tmp
x\_m = abs(x) x\_s = copysign(1.0, x) function code(x_s, x_m, y, z) t_0 = Float64(Float64(Float64(-z) * x_m) * y) t_1 = Float64(Float64(1.0 - Float64(z * y)) * x_m) tmp = 0.0 if (t_1 <= Float64(-Inf)) tmp = t_0; elseif (t_1 <= 2e+298) tmp = t_1; else tmp = t_0; end return Float64(x_s * tmp) end
x\_m = abs(x); x\_s = sign(x) * abs(1.0); function tmp_2 = code(x_s, x_m, y, z) t_0 = (-z * x_m) * y; t_1 = (1.0 - (z * y)) * x_m; tmp = 0.0; if (t_1 <= -Inf) tmp = t_0; elseif (t_1 <= 2e+298) tmp = t_1; else tmp = t_0; end tmp_2 = x_s * tmp; end
x\_m = N[Abs[x], $MachinePrecision]
x\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[x$95$s_, x$95$m_, y_, z_] := Block[{t$95$0 = N[(N[((-z) * x$95$m), $MachinePrecision] * y), $MachinePrecision]}, Block[{t$95$1 = N[(N[(1.0 - N[(z * y), $MachinePrecision]), $MachinePrecision] * x$95$m), $MachinePrecision]}, N[(x$95$s * If[LessEqual[t$95$1, (-Infinity)], t$95$0, If[LessEqual[t$95$1, 2e+298], t$95$1, t$95$0]]), $MachinePrecision]]]
\begin{array}{l}
x\_m = \left|x\right|
\\
x\_s = \mathsf{copysign}\left(1, x\right)
\\
\begin{array}{l}
t_0 := \left(\left(-z\right) \cdot x\_m\right) \cdot y\\
t_1 := \left(1 - z \cdot y\right) \cdot x\_m\\
x\_s \cdot \begin{array}{l}
\mathbf{if}\;t\_1 \leq -\infty:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+298}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
\end{array}
if (*.f64 x (-.f64 #s(literal 1 binary64) (*.f64 y z))) < -inf.0 or 1.9999999999999999e298 < (*.f64 x (-.f64 #s(literal 1 binary64) (*.f64 y z))) Initial program 80.8%
lift-*.f64N/A
*-commutativeN/A
lift--.f64N/A
flip3--N/A
associate-*l/N/A
lower-/.f64N/A
lower-*.f64N/A
metadata-evalN/A
lower--.f64N/A
lower-pow.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
metadata-evalN/A
+-commutativeN/A
*-lft-identityN/A
distribute-lft1-inN/A
+-commutativeN/A
Applied rewrites10.2%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-pow.f64N/A
cube-multN/A
distribute-lft-neg-inN/A
lift-*.f64N/A
distribute-lft-neg-outN/A
lift-neg.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lift-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites8.5%
Taylor expanded in z around inf
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6499.9
Applied rewrites99.9%
if -inf.0 < (*.f64 x (-.f64 #s(literal 1 binary64) (*.f64 y z))) < 1.9999999999999999e298Initial program 99.9%
Final simplification99.9%
x\_m = (fabs.f64 x)
x\_s = (copysign.f64 #s(literal 1 binary64) x)
(FPCore (x_s x_m y z)
:precision binary64
(*
x_s
(if (<= (* z y) -500.0)
(* (* (- y) x_m) z)
(if (<= (* z y) 0.02)
(* 1.0 x_m)
(if (<= (* z y) 2e+289) (* (* (- z) y) x_m) (* (* (- z) x_m) y))))))x\_m = fabs(x);
x\_s = copysign(1.0, x);
double code(double x_s, double x_m, double y, double z) {
double tmp;
if ((z * y) <= -500.0) {
tmp = (-y * x_m) * z;
} else if ((z * y) <= 0.02) {
tmp = 1.0 * x_m;
} else if ((z * y) <= 2e+289) {
tmp = (-z * y) * x_m;
} else {
tmp = (-z * x_m) * y;
}
return x_s * tmp;
}
x\_m = abs(x)
x\_s = copysign(1.0d0, x)
real(8) function code(x_s, x_m, y, z)
real(8), intent (in) :: x_s
real(8), intent (in) :: x_m
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if ((z * y) <= (-500.0d0)) then
tmp = (-y * x_m) * z
else if ((z * y) <= 0.02d0) then
tmp = 1.0d0 * x_m
else if ((z * y) <= 2d+289) then
tmp = (-z * y) * x_m
else
tmp = (-z * x_m) * y
end if
code = x_s * tmp
end function
x\_m = Math.abs(x);
x\_s = Math.copySign(1.0, x);
public static double code(double x_s, double x_m, double y, double z) {
double tmp;
if ((z * y) <= -500.0) {
tmp = (-y * x_m) * z;
} else if ((z * y) <= 0.02) {
tmp = 1.0 * x_m;
} else if ((z * y) <= 2e+289) {
tmp = (-z * y) * x_m;
} else {
tmp = (-z * x_m) * y;
}
return x_s * tmp;
}
x\_m = math.fabs(x) x\_s = math.copysign(1.0, x) def code(x_s, x_m, y, z): tmp = 0 if (z * y) <= -500.0: tmp = (-y * x_m) * z elif (z * y) <= 0.02: tmp = 1.0 * x_m elif (z * y) <= 2e+289: tmp = (-z * y) * x_m else: tmp = (-z * x_m) * y return x_s * tmp
x\_m = abs(x) x\_s = copysign(1.0, x) function code(x_s, x_m, y, z) tmp = 0.0 if (Float64(z * y) <= -500.0) tmp = Float64(Float64(Float64(-y) * x_m) * z); elseif (Float64(z * y) <= 0.02) tmp = Float64(1.0 * x_m); elseif (Float64(z * y) <= 2e+289) tmp = Float64(Float64(Float64(-z) * y) * x_m); else tmp = Float64(Float64(Float64(-z) * x_m) * y); end return Float64(x_s * tmp) end
x\_m = abs(x); x\_s = sign(x) * abs(1.0); function tmp_2 = code(x_s, x_m, y, z) tmp = 0.0; if ((z * y) <= -500.0) tmp = (-y * x_m) * z; elseif ((z * y) <= 0.02) tmp = 1.0 * x_m; elseif ((z * y) <= 2e+289) tmp = (-z * y) * x_m; else tmp = (-z * x_m) * y; end tmp_2 = x_s * tmp; end
x\_m = N[Abs[x], $MachinePrecision]
x\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[x$95$s_, x$95$m_, y_, z_] := N[(x$95$s * If[LessEqual[N[(z * y), $MachinePrecision], -500.0], N[(N[((-y) * x$95$m), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[N[(z * y), $MachinePrecision], 0.02], N[(1.0 * x$95$m), $MachinePrecision], If[LessEqual[N[(z * y), $MachinePrecision], 2e+289], N[(N[((-z) * y), $MachinePrecision] * x$95$m), $MachinePrecision], N[(N[((-z) * x$95$m), $MachinePrecision] * y), $MachinePrecision]]]]), $MachinePrecision]
\begin{array}{l}
x\_m = \left|x\right|
\\
x\_s = \mathsf{copysign}\left(1, x\right)
\\
x\_s \cdot \begin{array}{l}
\mathbf{if}\;z \cdot y \leq -500:\\
\;\;\;\;\left(\left(-y\right) \cdot x\_m\right) \cdot z\\
\mathbf{elif}\;z \cdot y \leq 0.02:\\
\;\;\;\;1 \cdot x\_m\\
\mathbf{elif}\;z \cdot y \leq 2 \cdot 10^{+289}:\\
\;\;\;\;\left(\left(-z\right) \cdot y\right) \cdot x\_m\\
\mathbf{else}:\\
\;\;\;\;\left(\left(-z\right) \cdot x\_m\right) \cdot y\\
\end{array}
\end{array}
if (*.f64 y z) < -500Initial program 92.5%
lift-*.f64N/A
*-commutativeN/A
lift--.f64N/A
flip3--N/A
associate-*l/N/A
lower-/.f64N/A
lower-*.f64N/A
metadata-evalN/A
lower--.f64N/A
lower-pow.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
metadata-evalN/A
+-commutativeN/A
*-lft-identityN/A
distribute-lft1-inN/A
+-commutativeN/A
Applied rewrites33.4%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-pow.f64N/A
cube-multN/A
distribute-lft-neg-inN/A
lift-*.f64N/A
distribute-lft-neg-outN/A
lift-neg.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lift-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites18.6%
Taylor expanded in z around inf
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6488.2
Applied rewrites88.2%
Applied rewrites94.0%
if -500 < (*.f64 y z) < 0.0200000000000000004Initial program 100.0%
Taylor expanded in z around 0
Applied rewrites97.9%
if 0.0200000000000000004 < (*.f64 y z) < 2.0000000000000001e289Initial program 99.8%
Taylor expanded in z around inf
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6496.1
Applied rewrites96.1%
if 2.0000000000000001e289 < (*.f64 y z) Initial program 68.6%
lift-*.f64N/A
*-commutativeN/A
lift--.f64N/A
flip3--N/A
associate-*l/N/A
lower-/.f64N/A
lower-*.f64N/A
metadata-evalN/A
lower--.f64N/A
lower-pow.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
metadata-evalN/A
+-commutativeN/A
*-lft-identityN/A
distribute-lft1-inN/A
+-commutativeN/A
Applied rewrites0.0%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-pow.f64N/A
cube-multN/A
distribute-lft-neg-inN/A
lift-*.f64N/A
distribute-lft-neg-outN/A
lift-neg.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lift-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites0.0%
Taylor expanded in z around inf
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6499.7
Applied rewrites99.7%
Final simplification96.7%
x\_m = (fabs.f64 x)
x\_s = (copysign.f64 #s(literal 1 binary64) x)
(FPCore (x_s x_m y z)
:precision binary64
(let* ((t_0 (- 1.0 (* z y))))
(*
x_s
(if (<= t_0 -100.0)
(* (* (- z) x_m) y)
(if (<= t_0 2.0) (* 1.0 x_m) (* (* (- y) x_m) z))))))x\_m = fabs(x);
x\_s = copysign(1.0, x);
double code(double x_s, double x_m, double y, double z) {
double t_0 = 1.0 - (z * y);
double tmp;
if (t_0 <= -100.0) {
tmp = (-z * x_m) * y;
} else if (t_0 <= 2.0) {
tmp = 1.0 * x_m;
} else {
tmp = (-y * x_m) * z;
}
return x_s * tmp;
}
x\_m = abs(x)
x\_s = copysign(1.0d0, x)
real(8) function code(x_s, x_m, y, z)
real(8), intent (in) :: x_s
real(8), intent (in) :: x_m
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: tmp
t_0 = 1.0d0 - (z * y)
if (t_0 <= (-100.0d0)) then
tmp = (-z * x_m) * y
else if (t_0 <= 2.0d0) then
tmp = 1.0d0 * x_m
else
tmp = (-y * x_m) * z
end if
code = x_s * tmp
end function
x\_m = Math.abs(x);
x\_s = Math.copySign(1.0, x);
public static double code(double x_s, double x_m, double y, double z) {
double t_0 = 1.0 - (z * y);
double tmp;
if (t_0 <= -100.0) {
tmp = (-z * x_m) * y;
} else if (t_0 <= 2.0) {
tmp = 1.0 * x_m;
} else {
tmp = (-y * x_m) * z;
}
return x_s * tmp;
}
x\_m = math.fabs(x) x\_s = math.copysign(1.0, x) def code(x_s, x_m, y, z): t_0 = 1.0 - (z * y) tmp = 0 if t_0 <= -100.0: tmp = (-z * x_m) * y elif t_0 <= 2.0: tmp = 1.0 * x_m else: tmp = (-y * x_m) * z return x_s * tmp
x\_m = abs(x) x\_s = copysign(1.0, x) function code(x_s, x_m, y, z) t_0 = Float64(1.0 - Float64(z * y)) tmp = 0.0 if (t_0 <= -100.0) tmp = Float64(Float64(Float64(-z) * x_m) * y); elseif (t_0 <= 2.0) tmp = Float64(1.0 * x_m); else tmp = Float64(Float64(Float64(-y) * x_m) * z); end return Float64(x_s * tmp) end
x\_m = abs(x); x\_s = sign(x) * abs(1.0); function tmp_2 = code(x_s, x_m, y, z) t_0 = 1.0 - (z * y); tmp = 0.0; if (t_0 <= -100.0) tmp = (-z * x_m) * y; elseif (t_0 <= 2.0) tmp = 1.0 * x_m; else tmp = (-y * x_m) * z; end tmp_2 = x_s * tmp; end
x\_m = N[Abs[x], $MachinePrecision]
x\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[x$95$s_, x$95$m_, y_, z_] := Block[{t$95$0 = N[(1.0 - N[(z * y), $MachinePrecision]), $MachinePrecision]}, N[(x$95$s * If[LessEqual[t$95$0, -100.0], N[(N[((-z) * x$95$m), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[t$95$0, 2.0], N[(1.0 * x$95$m), $MachinePrecision], N[(N[((-y) * x$95$m), $MachinePrecision] * z), $MachinePrecision]]]), $MachinePrecision]]
\begin{array}{l}
x\_m = \left|x\right|
\\
x\_s = \mathsf{copysign}\left(1, x\right)
\\
\begin{array}{l}
t_0 := 1 - z \cdot y\\
x\_s \cdot \begin{array}{l}
\mathbf{if}\;t\_0 \leq -100:\\
\;\;\;\;\left(\left(-z\right) \cdot x\_m\right) \cdot y\\
\mathbf{elif}\;t\_0 \leq 2:\\
\;\;\;\;1 \cdot x\_m\\
\mathbf{else}:\\
\;\;\;\;\left(\left(-y\right) \cdot x\_m\right) \cdot z\\
\end{array}
\end{array}
\end{array}
if (-.f64 #s(literal 1 binary64) (*.f64 y z)) < -100Initial program 90.8%
lift-*.f64N/A
*-commutativeN/A
lift--.f64N/A
flip3--N/A
associate-*l/N/A
lower-/.f64N/A
lower-*.f64N/A
metadata-evalN/A
lower--.f64N/A
lower-pow.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
metadata-evalN/A
+-commutativeN/A
*-lft-identityN/A
distribute-lft1-inN/A
+-commutativeN/A
Applied rewrites29.7%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-pow.f64N/A
cube-multN/A
distribute-lft-neg-inN/A
lift-*.f64N/A
distribute-lft-neg-outN/A
lift-neg.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lift-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites20.0%
Taylor expanded in z around inf
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6494.8
Applied rewrites94.8%
if -100 < (-.f64 #s(literal 1 binary64) (*.f64 y z)) < 2Initial program 100.0%
Taylor expanded in z around 0
Applied rewrites97.9%
if 2 < (-.f64 #s(literal 1 binary64) (*.f64 y z)) Initial program 92.5%
lift-*.f64N/A
*-commutativeN/A
lift--.f64N/A
flip3--N/A
associate-*l/N/A
lower-/.f64N/A
lower-*.f64N/A
metadata-evalN/A
lower--.f64N/A
lower-pow.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
metadata-evalN/A
+-commutativeN/A
*-lft-identityN/A
distribute-lft1-inN/A
+-commutativeN/A
Applied rewrites33.4%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-pow.f64N/A
cube-multN/A
distribute-lft-neg-inN/A
lift-*.f64N/A
distribute-lft-neg-outN/A
lift-neg.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lift-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites18.6%
Taylor expanded in z around inf
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6488.2
Applied rewrites88.2%
Applied rewrites94.0%
Final simplification96.1%
x\_m = (fabs.f64 x) x\_s = (copysign.f64 #s(literal 1 binary64) x) (FPCore (x_s x_m y z) :precision binary64 (let* ((t_0 (- 1.0 (* z y))) (t_1 (* (* (- z) x_m) y))) (* x_s (if (<= t_0 -100.0) t_1 (if (<= t_0 1000.0) (* 1.0 x_m) t_1)))))
x\_m = fabs(x);
x\_s = copysign(1.0, x);
double code(double x_s, double x_m, double y, double z) {
double t_0 = 1.0 - (z * y);
double t_1 = (-z * x_m) * y;
double tmp;
if (t_0 <= -100.0) {
tmp = t_1;
} else if (t_0 <= 1000.0) {
tmp = 1.0 * x_m;
} else {
tmp = t_1;
}
return x_s * tmp;
}
x\_m = abs(x)
x\_s = copysign(1.0d0, x)
real(8) function code(x_s, x_m, y, z)
real(8), intent (in) :: x_s
real(8), intent (in) :: x_m
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = 1.0d0 - (z * y)
t_1 = (-z * x_m) * y
if (t_0 <= (-100.0d0)) then
tmp = t_1
else if (t_0 <= 1000.0d0) then
tmp = 1.0d0 * x_m
else
tmp = t_1
end if
code = x_s * tmp
end function
x\_m = Math.abs(x);
x\_s = Math.copySign(1.0, x);
public static double code(double x_s, double x_m, double y, double z) {
double t_0 = 1.0 - (z * y);
double t_1 = (-z * x_m) * y;
double tmp;
if (t_0 <= -100.0) {
tmp = t_1;
} else if (t_0 <= 1000.0) {
tmp = 1.0 * x_m;
} else {
tmp = t_1;
}
return x_s * tmp;
}
x\_m = math.fabs(x) x\_s = math.copysign(1.0, x) def code(x_s, x_m, y, z): t_0 = 1.0 - (z * y) t_1 = (-z * x_m) * y tmp = 0 if t_0 <= -100.0: tmp = t_1 elif t_0 <= 1000.0: tmp = 1.0 * x_m else: tmp = t_1 return x_s * tmp
x\_m = abs(x) x\_s = copysign(1.0, x) function code(x_s, x_m, y, z) t_0 = Float64(1.0 - Float64(z * y)) t_1 = Float64(Float64(Float64(-z) * x_m) * y) tmp = 0.0 if (t_0 <= -100.0) tmp = t_1; elseif (t_0 <= 1000.0) tmp = Float64(1.0 * x_m); else tmp = t_1; end return Float64(x_s * tmp) end
x\_m = abs(x); x\_s = sign(x) * abs(1.0); function tmp_2 = code(x_s, x_m, y, z) t_0 = 1.0 - (z * y); t_1 = (-z * x_m) * y; tmp = 0.0; if (t_0 <= -100.0) tmp = t_1; elseif (t_0 <= 1000.0) tmp = 1.0 * x_m; else tmp = t_1; end tmp_2 = x_s * tmp; end
x\_m = N[Abs[x], $MachinePrecision]
x\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[x$95$s_, x$95$m_, y_, z_] := Block[{t$95$0 = N[(1.0 - N[(z * y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[((-z) * x$95$m), $MachinePrecision] * y), $MachinePrecision]}, N[(x$95$s * If[LessEqual[t$95$0, -100.0], t$95$1, If[LessEqual[t$95$0, 1000.0], N[(1.0 * x$95$m), $MachinePrecision], t$95$1]]), $MachinePrecision]]]
\begin{array}{l}
x\_m = \left|x\right|
\\
x\_s = \mathsf{copysign}\left(1, x\right)
\\
\begin{array}{l}
t_0 := 1 - z \cdot y\\
t_1 := \left(\left(-z\right) \cdot x\_m\right) \cdot y\\
x\_s \cdot \begin{array}{l}
\mathbf{if}\;t\_0 \leq -100:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_0 \leq 1000:\\
\;\;\;\;1 \cdot x\_m\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
\end{array}
if (-.f64 #s(literal 1 binary64) (*.f64 y z)) < -100 or 1e3 < (-.f64 #s(literal 1 binary64) (*.f64 y z)) Initial program 91.5%
lift-*.f64N/A
*-commutativeN/A
lift--.f64N/A
flip3--N/A
associate-*l/N/A
lower-/.f64N/A
lower-*.f64N/A
metadata-evalN/A
lower--.f64N/A
lower-pow.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
metadata-evalN/A
+-commutativeN/A
*-lft-identityN/A
distribute-lft1-inN/A
+-commutativeN/A
Applied rewrites30.9%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-pow.f64N/A
cube-multN/A
distribute-lft-neg-inN/A
lift-*.f64N/A
distribute-lft-neg-outN/A
lift-neg.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lift-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites19.4%
Taylor expanded in z around inf
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6492.4
Applied rewrites92.4%
if -100 < (-.f64 #s(literal 1 binary64) (*.f64 y z)) < 1e3Initial program 100.0%
Taylor expanded in z around 0
Applied rewrites97.2%
Final simplification94.6%
x\_m = (fabs.f64 x) x\_s = (copysign.f64 #s(literal 1 binary64) x) (FPCore (x_s x_m y z) :precision binary64 (* x_s (* 1.0 x_m)))
x\_m = fabs(x);
x\_s = copysign(1.0, x);
double code(double x_s, double x_m, double y, double z) {
return x_s * (1.0 * x_m);
}
x\_m = abs(x)
x\_s = copysign(1.0d0, x)
real(8) function code(x_s, x_m, y, z)
real(8), intent (in) :: x_s
real(8), intent (in) :: x_m
real(8), intent (in) :: y
real(8), intent (in) :: z
code = x_s * (1.0d0 * x_m)
end function
x\_m = Math.abs(x);
x\_s = Math.copySign(1.0, x);
public static double code(double x_s, double x_m, double y, double z) {
return x_s * (1.0 * x_m);
}
x\_m = math.fabs(x) x\_s = math.copysign(1.0, x) def code(x_s, x_m, y, z): return x_s * (1.0 * x_m)
x\_m = abs(x) x\_s = copysign(1.0, x) function code(x_s, x_m, y, z) return Float64(x_s * Float64(1.0 * x_m)) end
x\_m = abs(x); x\_s = sign(x) * abs(1.0); function tmp = code(x_s, x_m, y, z) tmp = x_s * (1.0 * x_m); end
x\_m = N[Abs[x], $MachinePrecision]
x\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[x]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[x$95$s_, x$95$m_, y_, z_] := N[(x$95$s * N[(1.0 * x$95$m), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
x\_m = \left|x\right|
\\
x\_s = \mathsf{copysign}\left(1, x\right)
\\
x\_s \cdot \left(1 \cdot x\_m\right)
\end{array}
Initial program 95.5%
Taylor expanded in z around 0
Applied rewrites47.4%
Final simplification47.4%
herbie shell --seed 2024243
(FPCore (x y z)
:name "Data.Colour.RGBSpace.HSV:hsv from colour-2.3.3, I"
:precision binary64
(* x (- 1.0 (* y z))))