
(FPCore (x y z t) :precision binary64 (+ (- x (/ y (* z 3.0))) (/ t (* (* z 3.0) y))))
double code(double x, double y, double z, double t) {
return (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y));
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = (x - (y / (z * 3.0d0))) + (t / ((z * 3.0d0) * y))
end function
public static double code(double x, double y, double z, double t) {
return (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y));
}
def code(x, y, z, t): return (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y))
function code(x, y, z, t) return Float64(Float64(x - Float64(y / Float64(z * 3.0))) + Float64(t / Float64(Float64(z * 3.0) * y))) end
function tmp = code(x, y, z, t) tmp = (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y)); end
code[x_, y_, z_, t_] := N[(N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(t / N[(N[(z * 3.0), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 12 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t) :precision binary64 (+ (- x (/ y (* z 3.0))) (/ t (* (* z 3.0) y))))
double code(double x, double y, double z, double t) {
return (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y));
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = (x - (y / (z * 3.0d0))) + (t / ((z * 3.0d0) * y))
end function
public static double code(double x, double y, double z, double t) {
return (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y));
}
def code(x, y, z, t): return (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y))
function code(x, y, z, t) return Float64(Float64(x - Float64(y / Float64(z * 3.0))) + Float64(t / Float64(Float64(z * 3.0) * y))) end
function tmp = code(x, y, z, t) tmp = (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y)); end
code[x_, y_, z_, t_] := N[(N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(t / N[(N[(z * 3.0), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y}
\end{array}
(FPCore (x y z t) :precision binary64 (- x (/ (- y (/ t y)) (* 3.0 z))))
double code(double x, double y, double z, double t) {
return x - ((y - (t / y)) / (3.0 * z));
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = x - ((y - (t / y)) / (3.0d0 * z))
end function
public static double code(double x, double y, double z, double t) {
return x - ((y - (t / y)) / (3.0 * z));
}
def code(x, y, z, t): return x - ((y - (t / y)) / (3.0 * z))
function code(x, y, z, t) return Float64(x - Float64(Float64(y - Float64(t / y)) / Float64(3.0 * z))) end
function tmp = code(x, y, z, t) tmp = x - ((y - (t / y)) / (3.0 * z)); end
code[x_, y_, z_, t_] := N[(x - N[(N[(y - N[(t / y), $MachinePrecision]), $MachinePrecision] / N[(3.0 * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x - \frac{y - \frac{t}{y}}{3 \cdot z}
\end{array}
Initial program 94.9%
lift-+.f64N/A
lift--.f64N/A
associate-+l-N/A
lower--.f64N/A
lift-/.f64N/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/r*N/A
sub-divN/A
lower-/.f64N/A
lower--.f64N/A
lower-/.f6498.0
lift-*.f64N/A
*-commutativeN/A
lower-*.f6498.0
Applied rewrites98.0%
(FPCore (x y z t)
:precision binary64
(if (<= y -3.3e+64)
(fma (- y) (/ 0.3333333333333333 z) x)
(if (<= y 5.8e+54)
(fma (/ 0.3333333333333333 y) (/ t z) x)
(fma -0.3333333333333333 (/ y z) x))))
double code(double x, double y, double z, double t) {
double tmp;
if (y <= -3.3e+64) {
tmp = fma(-y, (0.3333333333333333 / z), x);
} else if (y <= 5.8e+54) {
tmp = fma((0.3333333333333333 / y), (t / z), x);
} else {
tmp = fma(-0.3333333333333333, (y / z), x);
}
return tmp;
}
function code(x, y, z, t) tmp = 0.0 if (y <= -3.3e+64) tmp = fma(Float64(-y), Float64(0.3333333333333333 / z), x); elseif (y <= 5.8e+54) tmp = fma(Float64(0.3333333333333333 / y), Float64(t / z), x); else tmp = fma(-0.3333333333333333, Float64(y / z), x); end return tmp end
code[x_, y_, z_, t_] := If[LessEqual[y, -3.3e+64], N[((-y) * N[(0.3333333333333333 / z), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[y, 5.8e+54], N[(N[(0.3333333333333333 / y), $MachinePrecision] * N[(t / z), $MachinePrecision] + x), $MachinePrecision], N[(-0.3333333333333333 * N[(y / z), $MachinePrecision] + x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -3.3 \cdot 10^{+64}:\\
\;\;\;\;\mathsf{fma}\left(-y, \frac{0.3333333333333333}{z}, x\right)\\
\mathbf{elif}\;y \leq 5.8 \cdot 10^{+54}:\\
\;\;\;\;\mathsf{fma}\left(\frac{0.3333333333333333}{y}, \frac{t}{z}, x\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-0.3333333333333333, \frac{y}{z}, x\right)\\
\end{array}
\end{array}
if y < -3.29999999999999988e64Initial program 99.8%
Taylor expanded in x around 0
associate--l+N/A
+-commutativeN/A
distribute-lft-out--N/A
*-commutativeN/A
lower-fma.f64N/A
associate-/r*N/A
div-subN/A
lower-/.f64N/A
lower--.f64N/A
lower-/.f6499.8
Applied rewrites99.8%
Applied rewrites99.9%
Taylor expanded in y around inf
Applied rewrites96.3%
if -3.29999999999999988e64 < y < 5.7999999999999997e54Initial program 91.6%
Taylor expanded in y around 0
div-addN/A
associate-/l*N/A
associate-/r*N/A
*-commutativeN/A
associate-/l*N/A
fp-cancel-sign-sub-invN/A
*-inversesN/A
*-rgt-identityN/A
mul-1-negN/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
*-lft-identityN/A
associate-*r/N/A
times-fracN/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f6490.1
Applied rewrites90.1%
if 5.7999999999999997e54 < y Initial program 99.8%
Taylor expanded in y around inf
fp-cancel-sub-sign-invN/A
+-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-*r/N/A
metadata-evalN/A
associate-/l*N/A
*-commutativeN/A
associate-*r/N/A
fp-cancel-sign-subN/A
distribute-lft-neg-inN/A
associate-/l*N/A
*-commutativeN/A
associate-/l*N/A
distribute-lft-neg-inN/A
*-inversesN/A
*-rgt-identityN/A
*-lft-identityN/A
distribute-lft-neg-inN/A
fp-cancel-sign-sub-invN/A
*-lft-identityN/A
lower-fma.f64N/A
lower-/.f6498.1
Applied rewrites98.1%
(FPCore (x y z t)
:precision binary64
(if (<= y -3.3e+64)
(fma (- y) (/ 0.3333333333333333 z) x)
(if (<= y 5.8e+54)
(fma 0.3333333333333333 (/ (/ t z) y) x)
(fma -0.3333333333333333 (/ y z) x))))
double code(double x, double y, double z, double t) {
double tmp;
if (y <= -3.3e+64) {
tmp = fma(-y, (0.3333333333333333 / z), x);
} else if (y <= 5.8e+54) {
tmp = fma(0.3333333333333333, ((t / z) / y), x);
} else {
tmp = fma(-0.3333333333333333, (y / z), x);
}
return tmp;
}
function code(x, y, z, t) tmp = 0.0 if (y <= -3.3e+64) tmp = fma(Float64(-y), Float64(0.3333333333333333 / z), x); elseif (y <= 5.8e+54) tmp = fma(0.3333333333333333, Float64(Float64(t / z) / y), x); else tmp = fma(-0.3333333333333333, Float64(y / z), x); end return tmp end
code[x_, y_, z_, t_] := If[LessEqual[y, -3.3e+64], N[((-y) * N[(0.3333333333333333 / z), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[y, 5.8e+54], N[(0.3333333333333333 * N[(N[(t / z), $MachinePrecision] / y), $MachinePrecision] + x), $MachinePrecision], N[(-0.3333333333333333 * N[(y / z), $MachinePrecision] + x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -3.3 \cdot 10^{+64}:\\
\;\;\;\;\mathsf{fma}\left(-y, \frac{0.3333333333333333}{z}, x\right)\\
\mathbf{elif}\;y \leq 5.8 \cdot 10^{+54}:\\
\;\;\;\;\mathsf{fma}\left(0.3333333333333333, \frac{\frac{t}{z}}{y}, x\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-0.3333333333333333, \frac{y}{z}, x\right)\\
\end{array}
\end{array}
if y < -3.29999999999999988e64Initial program 99.8%
Taylor expanded in x around 0
associate--l+N/A
+-commutativeN/A
distribute-lft-out--N/A
*-commutativeN/A
lower-fma.f64N/A
associate-/r*N/A
div-subN/A
lower-/.f64N/A
lower--.f64N/A
lower-/.f6499.8
Applied rewrites99.8%
Applied rewrites99.9%
Taylor expanded in y around inf
Applied rewrites96.3%
if -3.29999999999999988e64 < y < 5.7999999999999997e54Initial program 91.6%
Taylor expanded in y around 0
div-addN/A
associate-/l*N/A
associate-/r*N/A
*-commutativeN/A
associate-/l*N/A
fp-cancel-sign-sub-invN/A
*-inversesN/A
*-rgt-identityN/A
mul-1-negN/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
*-lft-identityN/A
associate-*r/N/A
times-fracN/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f6490.1
Applied rewrites90.1%
Applied rewrites90.0%
if 5.7999999999999997e54 < y Initial program 99.8%
Taylor expanded in y around inf
fp-cancel-sub-sign-invN/A
+-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-*r/N/A
metadata-evalN/A
associate-/l*N/A
*-commutativeN/A
associate-*r/N/A
fp-cancel-sign-subN/A
distribute-lft-neg-inN/A
associate-/l*N/A
*-commutativeN/A
associate-/l*N/A
distribute-lft-neg-inN/A
*-inversesN/A
*-rgt-identityN/A
*-lft-identityN/A
distribute-lft-neg-inN/A
fp-cancel-sign-sub-invN/A
*-lft-identityN/A
lower-fma.f64N/A
lower-/.f6498.1
Applied rewrites98.1%
(FPCore (x y z t)
:precision binary64
(if (<= y -3.6e+80)
(fma (- y) (/ 0.3333333333333333 z) x)
(if (<= y 5.8e+54)
(+ x (* (/ 0.3333333333333333 (* z y)) t))
(fma -0.3333333333333333 (/ y z) x))))
double code(double x, double y, double z, double t) {
double tmp;
if (y <= -3.6e+80) {
tmp = fma(-y, (0.3333333333333333 / z), x);
} else if (y <= 5.8e+54) {
tmp = x + ((0.3333333333333333 / (z * y)) * t);
} else {
tmp = fma(-0.3333333333333333, (y / z), x);
}
return tmp;
}
function code(x, y, z, t) tmp = 0.0 if (y <= -3.6e+80) tmp = fma(Float64(-y), Float64(0.3333333333333333 / z), x); elseif (y <= 5.8e+54) tmp = Float64(x + Float64(Float64(0.3333333333333333 / Float64(z * y)) * t)); else tmp = fma(-0.3333333333333333, Float64(y / z), x); end return tmp end
code[x_, y_, z_, t_] := If[LessEqual[y, -3.6e+80], N[((-y) * N[(0.3333333333333333 / z), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[y, 5.8e+54], N[(x + N[(N[(0.3333333333333333 / N[(z * y), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision], N[(-0.3333333333333333 * N[(y / z), $MachinePrecision] + x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -3.6 \cdot 10^{+80}:\\
\;\;\;\;\mathsf{fma}\left(-y, \frac{0.3333333333333333}{z}, x\right)\\
\mathbf{elif}\;y \leq 5.8 \cdot 10^{+54}:\\
\;\;\;\;x + \frac{0.3333333333333333}{z \cdot y} \cdot t\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-0.3333333333333333, \frac{y}{z}, x\right)\\
\end{array}
\end{array}
if y < -3.59999999999999995e80Initial program 99.8%
Taylor expanded in x around 0
associate--l+N/A
+-commutativeN/A
distribute-lft-out--N/A
*-commutativeN/A
lower-fma.f64N/A
associate-/r*N/A
div-subN/A
lower-/.f64N/A
lower--.f64N/A
lower-/.f6499.8
Applied rewrites99.8%
Applied rewrites99.9%
Taylor expanded in y around inf
Applied rewrites98.0%
if -3.59999999999999995e80 < y < 5.7999999999999997e54Initial program 91.7%
Taylor expanded in y around 0
div-addN/A
associate-/l*N/A
associate-/r*N/A
*-commutativeN/A
associate-/l*N/A
fp-cancel-sign-sub-invN/A
*-inversesN/A
*-rgt-identityN/A
mul-1-negN/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
*-lft-identityN/A
associate-*r/N/A
times-fracN/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f6489.0
Applied rewrites89.0%
Applied rewrites89.0%
Applied rewrites83.6%
Applied rewrites83.6%
if 5.7999999999999997e54 < y Initial program 99.8%
Taylor expanded in y around inf
fp-cancel-sub-sign-invN/A
+-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-*r/N/A
metadata-evalN/A
associate-/l*N/A
*-commutativeN/A
associate-*r/N/A
fp-cancel-sign-subN/A
distribute-lft-neg-inN/A
associate-/l*N/A
*-commutativeN/A
associate-/l*N/A
distribute-lft-neg-inN/A
*-inversesN/A
*-rgt-identityN/A
*-lft-identityN/A
distribute-lft-neg-inN/A
fp-cancel-sign-sub-invN/A
*-lft-identityN/A
lower-fma.f64N/A
lower-/.f6498.1
Applied rewrites98.1%
Final simplification89.3%
(FPCore (x y z t)
:precision binary64
(if (<= y -3.6e+80)
(fma (- y) (/ 0.3333333333333333 z) x)
(if (<= y 5.8e+54)
(fma t (/ 0.3333333333333333 (* z y)) x)
(fma -0.3333333333333333 (/ y z) x))))
double code(double x, double y, double z, double t) {
double tmp;
if (y <= -3.6e+80) {
tmp = fma(-y, (0.3333333333333333 / z), x);
} else if (y <= 5.8e+54) {
tmp = fma(t, (0.3333333333333333 / (z * y)), x);
} else {
tmp = fma(-0.3333333333333333, (y / z), x);
}
return tmp;
}
function code(x, y, z, t) tmp = 0.0 if (y <= -3.6e+80) tmp = fma(Float64(-y), Float64(0.3333333333333333 / z), x); elseif (y <= 5.8e+54) tmp = fma(t, Float64(0.3333333333333333 / Float64(z * y)), x); else tmp = fma(-0.3333333333333333, Float64(y / z), x); end return tmp end
code[x_, y_, z_, t_] := If[LessEqual[y, -3.6e+80], N[((-y) * N[(0.3333333333333333 / z), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[y, 5.8e+54], N[(t * N[(0.3333333333333333 / N[(z * y), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision], N[(-0.3333333333333333 * N[(y / z), $MachinePrecision] + x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -3.6 \cdot 10^{+80}:\\
\;\;\;\;\mathsf{fma}\left(-y, \frac{0.3333333333333333}{z}, x\right)\\
\mathbf{elif}\;y \leq 5.8 \cdot 10^{+54}:\\
\;\;\;\;\mathsf{fma}\left(t, \frac{0.3333333333333333}{z \cdot y}, x\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-0.3333333333333333, \frac{y}{z}, x\right)\\
\end{array}
\end{array}
if y < -3.59999999999999995e80Initial program 99.8%
Taylor expanded in x around 0
associate--l+N/A
+-commutativeN/A
distribute-lft-out--N/A
*-commutativeN/A
lower-fma.f64N/A
associate-/r*N/A
div-subN/A
lower-/.f64N/A
lower--.f64N/A
lower-/.f6499.8
Applied rewrites99.8%
Applied rewrites99.9%
Taylor expanded in y around inf
Applied rewrites98.0%
if -3.59999999999999995e80 < y < 5.7999999999999997e54Initial program 91.7%
Taylor expanded in y around 0
div-addN/A
associate-/l*N/A
associate-/r*N/A
*-commutativeN/A
associate-/l*N/A
fp-cancel-sign-sub-invN/A
*-inversesN/A
*-rgt-identityN/A
mul-1-negN/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
*-lft-identityN/A
associate-*r/N/A
times-fracN/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f6489.0
Applied rewrites89.0%
Applied rewrites89.0%
Applied rewrites83.6%
if 5.7999999999999997e54 < y Initial program 99.8%
Taylor expanded in y around inf
fp-cancel-sub-sign-invN/A
+-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-*r/N/A
metadata-evalN/A
associate-/l*N/A
*-commutativeN/A
associate-*r/N/A
fp-cancel-sign-subN/A
distribute-lft-neg-inN/A
associate-/l*N/A
*-commutativeN/A
associate-/l*N/A
distribute-lft-neg-inN/A
*-inversesN/A
*-rgt-identityN/A
*-lft-identityN/A
distribute-lft-neg-inN/A
fp-cancel-sign-sub-invN/A
*-lft-identityN/A
lower-fma.f64N/A
lower-/.f6498.1
Applied rewrites98.1%
(FPCore (x y z t)
:precision binary64
(if (<= y -6.5e-182)
(fma (- y) (/ 0.3333333333333333 z) x)
(if (<= y 3.8e-95)
(* t (/ 0.3333333333333333 (* z y)))
(fma -0.3333333333333333 (/ y z) x))))
double code(double x, double y, double z, double t) {
double tmp;
if (y <= -6.5e-182) {
tmp = fma(-y, (0.3333333333333333 / z), x);
} else if (y <= 3.8e-95) {
tmp = t * (0.3333333333333333 / (z * y));
} else {
tmp = fma(-0.3333333333333333, (y / z), x);
}
return tmp;
}
function code(x, y, z, t) tmp = 0.0 if (y <= -6.5e-182) tmp = fma(Float64(-y), Float64(0.3333333333333333 / z), x); elseif (y <= 3.8e-95) tmp = Float64(t * Float64(0.3333333333333333 / Float64(z * y))); else tmp = fma(-0.3333333333333333, Float64(y / z), x); end return tmp end
code[x_, y_, z_, t_] := If[LessEqual[y, -6.5e-182], N[((-y) * N[(0.3333333333333333 / z), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[y, 3.8e-95], N[(t * N[(0.3333333333333333 / N[(z * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-0.3333333333333333 * N[(y / z), $MachinePrecision] + x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -6.5 \cdot 10^{-182}:\\
\;\;\;\;\mathsf{fma}\left(-y, \frac{0.3333333333333333}{z}, x\right)\\
\mathbf{elif}\;y \leq 3.8 \cdot 10^{-95}:\\
\;\;\;\;t \cdot \frac{0.3333333333333333}{z \cdot y}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-0.3333333333333333, \frac{y}{z}, x\right)\\
\end{array}
\end{array}
if y < -6.49999999999999997e-182Initial program 96.9%
Taylor expanded in x around 0
associate--l+N/A
+-commutativeN/A
distribute-lft-out--N/A
*-commutativeN/A
lower-fma.f64N/A
associate-/r*N/A
div-subN/A
lower-/.f64N/A
lower--.f64N/A
lower-/.f6499.8
Applied rewrites99.8%
Applied rewrites99.8%
Taylor expanded in y around inf
Applied rewrites76.6%
if -6.49999999999999997e-182 < y < 3.7999999999999997e-95Initial program 87.7%
Taylor expanded in y around 0
*-commutativeN/A
lower-*.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6469.5
Applied rewrites69.5%
Applied rewrites69.5%
if 3.7999999999999997e-95 < y Initial program 98.4%
Taylor expanded in y around inf
fp-cancel-sub-sign-invN/A
+-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-*r/N/A
metadata-evalN/A
associate-/l*N/A
*-commutativeN/A
associate-*r/N/A
fp-cancel-sign-subN/A
distribute-lft-neg-inN/A
associate-/l*N/A
*-commutativeN/A
associate-/l*N/A
distribute-lft-neg-inN/A
*-inversesN/A
*-rgt-identityN/A
*-lft-identityN/A
distribute-lft-neg-inN/A
fp-cancel-sign-sub-invN/A
*-lft-identityN/A
lower-fma.f64N/A
lower-/.f6480.0
Applied rewrites80.0%
(FPCore (x y z t) :precision binary64 (fma (/ (- (/ t y) y) z) 0.3333333333333333 x))
double code(double x, double y, double z, double t) {
return fma((((t / y) - y) / z), 0.3333333333333333, x);
}
function code(x, y, z, t) return fma(Float64(Float64(Float64(t / y) - y) / z), 0.3333333333333333, x) end
code[x_, y_, z_, t_] := N[(N[(N[(N[(t / y), $MachinePrecision] - y), $MachinePrecision] / z), $MachinePrecision] * 0.3333333333333333 + x), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\frac{\frac{t}{y} - y}{z}, 0.3333333333333333, x\right)
\end{array}
Initial program 94.9%
Taylor expanded in x around 0
associate--l+N/A
+-commutativeN/A
distribute-lft-out--N/A
*-commutativeN/A
lower-fma.f64N/A
associate-/r*N/A
div-subN/A
lower-/.f64N/A
lower--.f64N/A
lower-/.f6497.9
Applied rewrites97.9%
(FPCore (x y z t) :precision binary64 (fma (- (/ t y) y) (/ 0.3333333333333333 z) x))
double code(double x, double y, double z, double t) {
return fma(((t / y) - y), (0.3333333333333333 / z), x);
}
function code(x, y, z, t) return fma(Float64(Float64(t / y) - y), Float64(0.3333333333333333 / z), x) end
code[x_, y_, z_, t_] := N[(N[(N[(t / y), $MachinePrecision] - y), $MachinePrecision] * N[(0.3333333333333333 / z), $MachinePrecision] + x), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\frac{t}{y} - y, \frac{0.3333333333333333}{z}, x\right)
\end{array}
Initial program 94.9%
Taylor expanded in x around 0
associate--l+N/A
+-commutativeN/A
distribute-lft-out--N/A
*-commutativeN/A
lower-fma.f64N/A
associate-/r*N/A
div-subN/A
lower-/.f64N/A
lower--.f64N/A
lower-/.f6497.9
Applied rewrites97.9%
Applied rewrites97.9%
(FPCore (x y z t) :precision binary64 (if (or (<= x -6.5e-22) (not (<= x 1.45e+48))) (* 1.0 x) (/ (* -0.3333333333333333 y) z)))
double code(double x, double y, double z, double t) {
double tmp;
if ((x <= -6.5e-22) || !(x <= 1.45e+48)) {
tmp = 1.0 * x;
} else {
tmp = (-0.3333333333333333 * y) / z;
}
return tmp;
}
real(8) function code(x, y, z, t)
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 <= (-6.5d-22)) .or. (.not. (x <= 1.45d+48))) then
tmp = 1.0d0 * x
else
tmp = ((-0.3333333333333333d0) * y) / z
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if ((x <= -6.5e-22) || !(x <= 1.45e+48)) {
tmp = 1.0 * x;
} else {
tmp = (-0.3333333333333333 * y) / z;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (x <= -6.5e-22) or not (x <= 1.45e+48): tmp = 1.0 * x else: tmp = (-0.3333333333333333 * y) / z return tmp
function code(x, y, z, t) tmp = 0.0 if ((x <= -6.5e-22) || !(x <= 1.45e+48)) tmp = Float64(1.0 * x); else tmp = Float64(Float64(-0.3333333333333333 * y) / z); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((x <= -6.5e-22) || ~((x <= 1.45e+48))) tmp = 1.0 * x; else tmp = (-0.3333333333333333 * y) / z; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[x, -6.5e-22], N[Not[LessEqual[x, 1.45e+48]], $MachinePrecision]], N[(1.0 * x), $MachinePrecision], N[(N[(-0.3333333333333333 * y), $MachinePrecision] / z), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -6.5 \cdot 10^{-22} \lor \neg \left(x \leq 1.45 \cdot 10^{+48}\right):\\
\;\;\;\;1 \cdot x\\
\mathbf{else}:\\
\;\;\;\;\frac{-0.3333333333333333 \cdot y}{z}\\
\end{array}
\end{array}
if x < -6.50000000000000043e-22 or 1.4499999999999999e48 < x Initial program 95.3%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites96.8%
Taylor expanded in x around inf
Applied rewrites55.0%
if -6.50000000000000043e-22 < x < 1.4499999999999999e48Initial program 94.6%
lift-+.f64N/A
lift--.f64N/A
associate-+l-N/A
lower--.f64N/A
lift-/.f64N/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/r*N/A
sub-divN/A
lower-/.f64N/A
lower--.f64N/A
lower-/.f6499.1
lift-*.f64N/A
*-commutativeN/A
lower-*.f6499.1
Applied rewrites99.1%
lift-/.f64N/A
lift-*.f64N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f6499.0
Applied rewrites99.0%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
lower-/.f6446.5
Applied rewrites46.5%
Applied rewrites46.5%
Final simplification50.6%
(FPCore (x y z t) :precision binary64 (if (or (<= x -6.5e-22) (not (<= x 1.45e+48))) (* 1.0 x) (* (/ y z) -0.3333333333333333)))
double code(double x, double y, double z, double t) {
double tmp;
if ((x <= -6.5e-22) || !(x <= 1.45e+48)) {
tmp = 1.0 * x;
} else {
tmp = (y / z) * -0.3333333333333333;
}
return tmp;
}
real(8) function code(x, y, z, t)
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 <= (-6.5d-22)) .or. (.not. (x <= 1.45d+48))) then
tmp = 1.0d0 * x
else
tmp = (y / z) * (-0.3333333333333333d0)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if ((x <= -6.5e-22) || !(x <= 1.45e+48)) {
tmp = 1.0 * x;
} else {
tmp = (y / z) * -0.3333333333333333;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (x <= -6.5e-22) or not (x <= 1.45e+48): tmp = 1.0 * x else: tmp = (y / z) * -0.3333333333333333 return tmp
function code(x, y, z, t) tmp = 0.0 if ((x <= -6.5e-22) || !(x <= 1.45e+48)) tmp = Float64(1.0 * x); else tmp = Float64(Float64(y / z) * -0.3333333333333333); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((x <= -6.5e-22) || ~((x <= 1.45e+48))) tmp = 1.0 * x; else tmp = (y / z) * -0.3333333333333333; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[x, -6.5e-22], N[Not[LessEqual[x, 1.45e+48]], $MachinePrecision]], N[(1.0 * x), $MachinePrecision], N[(N[(y / z), $MachinePrecision] * -0.3333333333333333), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -6.5 \cdot 10^{-22} \lor \neg \left(x \leq 1.45 \cdot 10^{+48}\right):\\
\;\;\;\;1 \cdot x\\
\mathbf{else}:\\
\;\;\;\;\frac{y}{z} \cdot -0.3333333333333333\\
\end{array}
\end{array}
if x < -6.50000000000000043e-22 or 1.4499999999999999e48 < x Initial program 95.3%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites96.8%
Taylor expanded in x around inf
Applied rewrites55.0%
if -6.50000000000000043e-22 < x < 1.4499999999999999e48Initial program 94.6%
Taylor expanded in y around inf
fp-cancel-sub-sign-invN/A
+-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-*r/N/A
metadata-evalN/A
associate-/l*N/A
*-commutativeN/A
associate-*r/N/A
fp-cancel-sign-subN/A
distribute-lft-neg-inN/A
associate-/l*N/A
*-commutativeN/A
associate-/l*N/A
distribute-lft-neg-inN/A
*-inversesN/A
*-rgt-identityN/A
*-lft-identityN/A
distribute-lft-neg-inN/A
fp-cancel-sign-sub-invN/A
*-lft-identityN/A
lower-fma.f64N/A
lower-/.f6455.1
Applied rewrites55.1%
Taylor expanded in x around 0
Applied rewrites46.5%
Final simplification50.6%
(FPCore (x y z t) :precision binary64 (fma -0.3333333333333333 (/ y z) x))
double code(double x, double y, double z, double t) {
return fma(-0.3333333333333333, (y / z), x);
}
function code(x, y, z, t) return fma(-0.3333333333333333, Float64(y / z), x) end
code[x_, y_, z_, t_] := N[(-0.3333333333333333 * N[(y / z), $MachinePrecision] + x), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(-0.3333333333333333, \frac{y}{z}, x\right)
\end{array}
Initial program 94.9%
Taylor expanded in y around inf
fp-cancel-sub-sign-invN/A
+-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-*r/N/A
metadata-evalN/A
associate-/l*N/A
*-commutativeN/A
associate-*r/N/A
fp-cancel-sign-subN/A
distribute-lft-neg-inN/A
associate-/l*N/A
*-commutativeN/A
associate-/l*N/A
distribute-lft-neg-inN/A
*-inversesN/A
*-rgt-identityN/A
*-lft-identityN/A
distribute-lft-neg-inN/A
fp-cancel-sign-sub-invN/A
*-lft-identityN/A
lower-fma.f64N/A
lower-/.f6463.6
Applied rewrites63.6%
(FPCore (x y z t) :precision binary64 (* 1.0 x))
double code(double x, double y, double z, double t) {
return 1.0 * x;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = 1.0d0 * x
end function
public static double code(double x, double y, double z, double t) {
return 1.0 * x;
}
def code(x, y, z, t): return 1.0 * x
function code(x, y, z, t) return Float64(1.0 * x) end
function tmp = code(x, y, z, t) tmp = 1.0 * x; end
code[x_, y_, z_, t_] := N[(1.0 * x), $MachinePrecision]
\begin{array}{l}
\\
1 \cdot x
\end{array}
Initial program 94.9%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites86.9%
Taylor expanded in x around inf
Applied rewrites32.0%
(FPCore (x y z t) :precision binary64 (+ (- x (/ y (* z 3.0))) (/ (/ t (* z 3.0)) y)))
double code(double x, double y, double z, double t) {
return (x - (y / (z * 3.0))) + ((t / (z * 3.0)) / y);
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = (x - (y / (z * 3.0d0))) + ((t / (z * 3.0d0)) / y)
end function
public static double code(double x, double y, double z, double t) {
return (x - (y / (z * 3.0))) + ((t / (z * 3.0)) / y);
}
def code(x, y, z, t): return (x - (y / (z * 3.0))) + ((t / (z * 3.0)) / y)
function code(x, y, z, t) return Float64(Float64(x - Float64(y / Float64(z * 3.0))) + Float64(Float64(t / Float64(z * 3.0)) / y)) end
function tmp = code(x, y, z, t) tmp = (x - (y / (z * 3.0))) + ((t / (z * 3.0)) / y); end
code[x_, y_, z_, t_] := N[(N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(t / N[(z * 3.0), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x - \frac{y}{z \cdot 3}\right) + \frac{\frac{t}{z \cdot 3}}{y}
\end{array}
herbie shell --seed 2024327
(FPCore (x y z t)
:name "Diagrams.Solve.Polynomial:cubForm from diagrams-solve-0.1, H"
:precision binary64
:alt
(! :herbie-platform default (+ (- x (/ y (* z 3))) (/ (/ t (* z 3)) y)))
(+ (- x (/ y (* z 3.0))) (/ t (* (* z 3.0) y))))