
(FPCore (x y z t) :precision binary64 (* (* (- (* x 0.5) y) (sqrt (* z 2.0))) (exp (/ (* t t) 2.0))))
double code(double x, double y, double z, double t) {
return (((x * 0.5) - y) * sqrt((z * 2.0))) * exp(((t * t) / 2.0));
}
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 * 0.5d0) - y) * sqrt((z * 2.0d0))) * exp(((t * t) / 2.0d0))
end function
public static double code(double x, double y, double z, double t) {
return (((x * 0.5) - y) * Math.sqrt((z * 2.0))) * Math.exp(((t * t) / 2.0));
}
def code(x, y, z, t): return (((x * 0.5) - y) * math.sqrt((z * 2.0))) * math.exp(((t * t) / 2.0))
function code(x, y, z, t) return Float64(Float64(Float64(Float64(x * 0.5) - y) * sqrt(Float64(z * 2.0))) * exp(Float64(Float64(t * t) / 2.0))) end
function tmp = code(x, y, z, t) tmp = (((x * 0.5) - y) * sqrt((z * 2.0))) * exp(((t * t) / 2.0)); end
code[x_, y_, z_, t_] := N[(N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Exp[N[(N[(t * t), $MachinePrecision] / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 14 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t) :precision binary64 (* (* (- (* x 0.5) y) (sqrt (* z 2.0))) (exp (/ (* t t) 2.0))))
double code(double x, double y, double z, double t) {
return (((x * 0.5) - y) * sqrt((z * 2.0))) * exp(((t * t) / 2.0));
}
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 * 0.5d0) - y) * sqrt((z * 2.0d0))) * exp(((t * t) / 2.0d0))
end function
public static double code(double x, double y, double z, double t) {
return (((x * 0.5) - y) * Math.sqrt((z * 2.0))) * Math.exp(((t * t) / 2.0));
}
def code(x, y, z, t): return (((x * 0.5) - y) * math.sqrt((z * 2.0))) * math.exp(((t * t) / 2.0))
function code(x, y, z, t) return Float64(Float64(Float64(Float64(x * 0.5) - y) * sqrt(Float64(z * 2.0))) * exp(Float64(Float64(t * t) / 2.0))) end
function tmp = code(x, y, z, t) tmp = (((x * 0.5) - y) * sqrt((z * 2.0))) * exp(((t * t) / 2.0)); end
code[x_, y_, z_, t_] := N[(N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Exp[N[(N[(t * t), $MachinePrecision] / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot e^{\frac{t \cdot t}{2}}
\end{array}
t_m = (fabs.f64 t) (FPCore (x y z t_m) :precision binary64 (* (- (* 0.5 x) y) (sqrt (* (pow (exp t_m) t_m) (* z 2.0)))))
t_m = fabs(t);
double code(double x, double y, double z, double t_m) {
return ((0.5 * x) - y) * sqrt((pow(exp(t_m), t_m) * (z * 2.0)));
}
t_m = abs(t)
real(8) function code(x, y, z, t_m)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t_m
code = ((0.5d0 * x) - y) * sqrt(((exp(t_m) ** t_m) * (z * 2.0d0)))
end function
t_m = Math.abs(t);
public static double code(double x, double y, double z, double t_m) {
return ((0.5 * x) - y) * Math.sqrt((Math.pow(Math.exp(t_m), t_m) * (z * 2.0)));
}
t_m = math.fabs(t) def code(x, y, z, t_m): return ((0.5 * x) - y) * math.sqrt((math.pow(math.exp(t_m), t_m) * (z * 2.0)))
t_m = abs(t) function code(x, y, z, t_m) return Float64(Float64(Float64(0.5 * x) - y) * sqrt(Float64((exp(t_m) ^ t_m) * Float64(z * 2.0)))) end
t_m = abs(t); function tmp = code(x, y, z, t_m) tmp = ((0.5 * x) - y) * sqrt(((exp(t_m) ^ t_m) * (z * 2.0))); end
t_m = N[Abs[t], $MachinePrecision] code[x_, y_, z_, t$95$m_] := N[(N[(N[(0.5 * x), $MachinePrecision] - y), $MachinePrecision] * N[Sqrt[N[(N[Power[N[Exp[t$95$m], $MachinePrecision], t$95$m], $MachinePrecision] * N[(z * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
\left(0.5 \cdot x - y\right) \cdot \sqrt{{\left(e^{t\_m}\right)}^{t\_m} \cdot \left(z \cdot 2\right)}
\end{array}
Initial program 99.7%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lift-sqrt.f64N/A
lift-exp.f64N/A
lift-/.f64N/A
exp-sqrtN/A
sqrt-unprodN/A
lower-sqrt.f64N/A
*-commutativeN/A
lower-*.f64N/A
lift-*.f64N/A
exp-prodN/A
lower-pow.f64N/A
lower-exp.f6499.8
Applied rewrites99.8%
t_m = (fabs.f64 t)
(FPCore (x y z t_m)
:precision binary64
(if (<= t_m 3.5e-6)
(* (- (* 0.5 x) y) (sqrt (* (fma t_m t_m 1.0) (* z 2.0))))
(if (<= t_m 3.7e+46)
(* (- y) (sqrt (* (exp (* t_m t_m)) (* z 2.0))))
(*
(* (- (* x 0.5) y) (sqrt (* z 2.0)))
(fma
(* (fma (* 0.020833333333333332 (* t_m t_m)) (* t_m t_m) 0.5) t_m)
t_m
1.0)))))t_m = fabs(t);
double code(double x, double y, double z, double t_m) {
double tmp;
if (t_m <= 3.5e-6) {
tmp = ((0.5 * x) - y) * sqrt((fma(t_m, t_m, 1.0) * (z * 2.0)));
} else if (t_m <= 3.7e+46) {
tmp = -y * sqrt((exp((t_m * t_m)) * (z * 2.0)));
} else {
tmp = (((x * 0.5) - y) * sqrt((z * 2.0))) * fma((fma((0.020833333333333332 * (t_m * t_m)), (t_m * t_m), 0.5) * t_m), t_m, 1.0);
}
return tmp;
}
t_m = abs(t) function code(x, y, z, t_m) tmp = 0.0 if (t_m <= 3.5e-6) tmp = Float64(Float64(Float64(0.5 * x) - y) * sqrt(Float64(fma(t_m, t_m, 1.0) * Float64(z * 2.0)))); elseif (t_m <= 3.7e+46) tmp = Float64(Float64(-y) * sqrt(Float64(exp(Float64(t_m * t_m)) * Float64(z * 2.0)))); else tmp = Float64(Float64(Float64(Float64(x * 0.5) - y) * sqrt(Float64(z * 2.0))) * fma(Float64(fma(Float64(0.020833333333333332 * Float64(t_m * t_m)), Float64(t_m * t_m), 0.5) * t_m), t_m, 1.0)); end return tmp end
t_m = N[Abs[t], $MachinePrecision] code[x_, y_, z_, t$95$m_] := If[LessEqual[t$95$m, 3.5e-6], N[(N[(N[(0.5 * x), $MachinePrecision] - y), $MachinePrecision] * N[Sqrt[N[(N[(t$95$m * t$95$m + 1.0), $MachinePrecision] * N[(z * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$m, 3.7e+46], N[((-y) * N[Sqrt[N[(N[Exp[N[(t$95$m * t$95$m), $MachinePrecision]], $MachinePrecision] * N[(z * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(N[(N[(0.020833333333333332 * N[(t$95$m * t$95$m), $MachinePrecision]), $MachinePrecision] * N[(t$95$m * t$95$m), $MachinePrecision] + 0.5), $MachinePrecision] * t$95$m), $MachinePrecision] * t$95$m + 1.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
t_m = \left|t\right|
\\
\begin{array}{l}
\mathbf{if}\;t\_m \leq 3.5 \cdot 10^{-6}:\\
\;\;\;\;\left(0.5 \cdot x - y\right) \cdot \sqrt{\mathsf{fma}\left(t\_m, t\_m, 1\right) \cdot \left(z \cdot 2\right)}\\
\mathbf{elif}\;t\_m \leq 3.7 \cdot 10^{+46}:\\
\;\;\;\;\left(-y\right) \cdot \sqrt{e^{t\_m \cdot t\_m} \cdot \left(z \cdot 2\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot \mathsf{fma}\left(\mathsf{fma}\left(0.020833333333333332 \cdot \left(t\_m \cdot t\_m\right), t\_m \cdot t\_m, 0.5\right) \cdot t\_m, t\_m, 1\right)\\
\end{array}
\end{array}
if t < 3.49999999999999995e-6Initial program 99.7%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lift-sqrt.f64N/A
lift-exp.f64N/A
lift-/.f64N/A
exp-sqrtN/A
sqrt-unprodN/A
lower-sqrt.f64N/A
*-commutativeN/A
lower-*.f64N/A
lift-*.f64N/A
exp-prodN/A
lower-pow.f64N/A
lower-exp.f6499.7
Applied rewrites99.7%
Taylor expanded in t around 0
+-commutativeN/A
unpow2N/A
lower-fma.f6490.5
Applied rewrites90.5%
if 3.49999999999999995e-6 < t < 3.6999999999999999e46Initial program 99.6%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lift-sqrt.f64N/A
lift-exp.f64N/A
lift-/.f64N/A
exp-sqrtN/A
sqrt-unprodN/A
lower-sqrt.f64N/A
*-commutativeN/A
lower-*.f64N/A
lift-*.f64N/A
exp-prodN/A
lower-pow.f64N/A
lower-exp.f6499.9
Applied rewrites99.9%
lift-pow.f64N/A
lift-exp.f64N/A
pow-expN/A
lift-*.f64N/A
lower-exp.f6499.7
Applied rewrites99.7%
Taylor expanded in x around 0
mul-1-negN/A
lower-neg.f6478.3
Applied rewrites78.3%
if 3.6999999999999999e46 < t Initial program 100.0%
Taylor expanded in t around 0
+-commutativeN/A
*-commutativeN/A
unpow2N/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64100.0
Applied rewrites100.0%
Taylor expanded in t around inf
Applied rewrites100.0%
t_m = (fabs.f64 t) (FPCore (x y z t_m) :precision binary64 (* (- (* 0.5 x) y) (sqrt (* (exp (* t_m t_m)) (* z 2.0)))))
t_m = fabs(t);
double code(double x, double y, double z, double t_m) {
return ((0.5 * x) - y) * sqrt((exp((t_m * t_m)) * (z * 2.0)));
}
t_m = abs(t)
real(8) function code(x, y, z, t_m)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t_m
code = ((0.5d0 * x) - y) * sqrt((exp((t_m * t_m)) * (z * 2.0d0)))
end function
t_m = Math.abs(t);
public static double code(double x, double y, double z, double t_m) {
return ((0.5 * x) - y) * Math.sqrt((Math.exp((t_m * t_m)) * (z * 2.0)));
}
t_m = math.fabs(t) def code(x, y, z, t_m): return ((0.5 * x) - y) * math.sqrt((math.exp((t_m * t_m)) * (z * 2.0)))
t_m = abs(t) function code(x, y, z, t_m) return Float64(Float64(Float64(0.5 * x) - y) * sqrt(Float64(exp(Float64(t_m * t_m)) * Float64(z * 2.0)))) end
t_m = abs(t); function tmp = code(x, y, z, t_m) tmp = ((0.5 * x) - y) * sqrt((exp((t_m * t_m)) * (z * 2.0))); end
t_m = N[Abs[t], $MachinePrecision] code[x_, y_, z_, t$95$m_] := N[(N[(N[(0.5 * x), $MachinePrecision] - y), $MachinePrecision] * N[Sqrt[N[(N[Exp[N[(t$95$m * t$95$m), $MachinePrecision]], $MachinePrecision] * N[(z * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
\left(0.5 \cdot x - y\right) \cdot \sqrt{e^{t\_m \cdot t\_m} \cdot \left(z \cdot 2\right)}
\end{array}
Initial program 99.7%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lift-sqrt.f64N/A
lift-exp.f64N/A
lift-/.f64N/A
exp-sqrtN/A
sqrt-unprodN/A
lower-sqrt.f64N/A
*-commutativeN/A
lower-*.f64N/A
lift-*.f64N/A
exp-prodN/A
lower-pow.f64N/A
lower-exp.f6499.8
Applied rewrites99.8%
lift-pow.f64N/A
lift-exp.f64N/A
pow-expN/A
lift-*.f64N/A
lower-exp.f6499.8
Applied rewrites99.8%
t_m = (fabs.f64 t)
(FPCore (x y z t_m)
:precision binary64
(*
(*
(fma
(* (fma (fma (* t_m t_m) 0.020833333333333332 0.125) (* t_m t_m) 0.5) t_m)
t_m
1.0)
(* (sqrt 2.0) (- (* x 0.5) y)))
(sqrt z)))t_m = fabs(t);
double code(double x, double y, double z, double t_m) {
return (fma((fma(fma((t_m * t_m), 0.020833333333333332, 0.125), (t_m * t_m), 0.5) * t_m), t_m, 1.0) * (sqrt(2.0) * ((x * 0.5) - y))) * sqrt(z);
}
t_m = abs(t) function code(x, y, z, t_m) return Float64(Float64(fma(Float64(fma(fma(Float64(t_m * t_m), 0.020833333333333332, 0.125), Float64(t_m * t_m), 0.5) * t_m), t_m, 1.0) * Float64(sqrt(2.0) * Float64(Float64(x * 0.5) - y))) * sqrt(z)) end
t_m = N[Abs[t], $MachinePrecision] code[x_, y_, z_, t$95$m_] := N[(N[(N[(N[(N[(N[(N[(t$95$m * t$95$m), $MachinePrecision] * 0.020833333333333332 + 0.125), $MachinePrecision] * N[(t$95$m * t$95$m), $MachinePrecision] + 0.5), $MachinePrecision] * t$95$m), $MachinePrecision] * t$95$m + 1.0), $MachinePrecision] * N[(N[Sqrt[2.0], $MachinePrecision] * N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sqrt[z], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
\left(\mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(t\_m \cdot t\_m, 0.020833333333333332, 0.125\right), t\_m \cdot t\_m, 0.5\right) \cdot t\_m, t\_m, 1\right) \cdot \left(\sqrt{2} \cdot \left(x \cdot 0.5 - y\right)\right)\right) \cdot \sqrt{z}
\end{array}
Initial program 99.7%
Taylor expanded in t around 0
+-commutativeN/A
*-commutativeN/A
unpow2N/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6494.3
Applied rewrites94.3%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-sqrt.f64N/A
lift-*.f64N/A
sqrt-prodN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
Applied rewrites94.5%
t_m = (fabs.f64 t)
(FPCore (x y z t_m)
:precision binary64
(*
(- (* x 0.5) y)
(*
(fma
(* (fma (* (fma 0.020833333333333332 (* t_m t_m) 0.125) t_m) t_m 0.5) t_m)
t_m
1.0)
(sqrt (* 2.0 z)))))t_m = fabs(t);
double code(double x, double y, double z, double t_m) {
return ((x * 0.5) - y) * (fma((fma((fma(0.020833333333333332, (t_m * t_m), 0.125) * t_m), t_m, 0.5) * t_m), t_m, 1.0) * sqrt((2.0 * z)));
}
t_m = abs(t) function code(x, y, z, t_m) return Float64(Float64(Float64(x * 0.5) - y) * Float64(fma(Float64(fma(Float64(fma(0.020833333333333332, Float64(t_m * t_m), 0.125) * t_m), t_m, 0.5) * t_m), t_m, 1.0) * sqrt(Float64(2.0 * z)))) end
t_m = N[Abs[t], $MachinePrecision] code[x_, y_, z_, t$95$m_] := N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[(N[(N[(N[(N[(N[(0.020833333333333332 * N[(t$95$m * t$95$m), $MachinePrecision] + 0.125), $MachinePrecision] * t$95$m), $MachinePrecision] * t$95$m + 0.5), $MachinePrecision] * t$95$m), $MachinePrecision] * t$95$m + 1.0), $MachinePrecision] * N[Sqrt[N[(2.0 * z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
\left(x \cdot 0.5 - y\right) \cdot \left(\mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(0.020833333333333332, t\_m \cdot t\_m, 0.125\right) \cdot t\_m, t\_m, 0.5\right) \cdot t\_m, t\_m, 1\right) \cdot \sqrt{2 \cdot z}\right)
\end{array}
Initial program 99.7%
Taylor expanded in t around 0
+-commutativeN/A
*-commutativeN/A
unpow2N/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6494.3
Applied rewrites94.3%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f6494.3
Applied rewrites94.3%
Applied rewrites94.3%
t_m = (fabs.f64 t)
(FPCore (x y z t_m)
:precision binary64
(*
(- (* x 0.5) y)
(*
(fma
(* (fma (* 0.020833333333333332 (* t_m t_m)) (* t_m t_m) 0.5) t_m)
t_m
1.0)
(sqrt (* 2.0 z)))))t_m = fabs(t);
double code(double x, double y, double z, double t_m) {
return ((x * 0.5) - y) * (fma((fma((0.020833333333333332 * (t_m * t_m)), (t_m * t_m), 0.5) * t_m), t_m, 1.0) * sqrt((2.0 * z)));
}
t_m = abs(t) function code(x, y, z, t_m) return Float64(Float64(Float64(x * 0.5) - y) * Float64(fma(Float64(fma(Float64(0.020833333333333332 * Float64(t_m * t_m)), Float64(t_m * t_m), 0.5) * t_m), t_m, 1.0) * sqrt(Float64(2.0 * z)))) end
t_m = N[Abs[t], $MachinePrecision] code[x_, y_, z_, t$95$m_] := N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[(N[(N[(N[(N[(0.020833333333333332 * N[(t$95$m * t$95$m), $MachinePrecision]), $MachinePrecision] * N[(t$95$m * t$95$m), $MachinePrecision] + 0.5), $MachinePrecision] * t$95$m), $MachinePrecision] * t$95$m + 1.0), $MachinePrecision] * N[Sqrt[N[(2.0 * z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
\left(x \cdot 0.5 - y\right) \cdot \left(\mathsf{fma}\left(\mathsf{fma}\left(0.020833333333333332 \cdot \left(t\_m \cdot t\_m\right), t\_m \cdot t\_m, 0.5\right) \cdot t\_m, t\_m, 1\right) \cdot \sqrt{2 \cdot z}\right)
\end{array}
Initial program 99.7%
Taylor expanded in t around 0
+-commutativeN/A
*-commutativeN/A
unpow2N/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6494.3
Applied rewrites94.3%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f6494.3
Applied rewrites94.3%
Taylor expanded in t around inf
Applied rewrites94.3%
Final simplification94.3%
t_m = (fabs.f64 t) (FPCore (x y z t_m) :precision binary64 (* (* (- (* x 0.5) y) (sqrt (* z 2.0))) (fma (* (fma (* 0.020833333333333332 (* t_m t_m)) (* t_m t_m) 0.5) t_m) t_m 1.0)))
t_m = fabs(t);
double code(double x, double y, double z, double t_m) {
return (((x * 0.5) - y) * sqrt((z * 2.0))) * fma((fma((0.020833333333333332 * (t_m * t_m)), (t_m * t_m), 0.5) * t_m), t_m, 1.0);
}
t_m = abs(t) function code(x, y, z, t_m) return Float64(Float64(Float64(Float64(x * 0.5) - y) * sqrt(Float64(z * 2.0))) * fma(Float64(fma(Float64(0.020833333333333332 * Float64(t_m * t_m)), Float64(t_m * t_m), 0.5) * t_m), t_m, 1.0)) end
t_m = N[Abs[t], $MachinePrecision] code[x_, y_, z_, t$95$m_] := N[(N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(N[(N[(0.020833333333333332 * N[(t$95$m * t$95$m), $MachinePrecision]), $MachinePrecision] * N[(t$95$m * t$95$m), $MachinePrecision] + 0.5), $MachinePrecision] * t$95$m), $MachinePrecision] * t$95$m + 1.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot \mathsf{fma}\left(\mathsf{fma}\left(0.020833333333333332 \cdot \left(t\_m \cdot t\_m\right), t\_m \cdot t\_m, 0.5\right) \cdot t\_m, t\_m, 1\right)
\end{array}
Initial program 99.7%
Taylor expanded in t around 0
+-commutativeN/A
*-commutativeN/A
unpow2N/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6494.3
Applied rewrites94.3%
Taylor expanded in t around inf
Applied rewrites94.3%
t_m = (fabs.f64 t) (FPCore (x y z t_m) :precision binary64 (* (- (* x 0.5) y) (* (fma (* (fma 0.125 (* t_m t_m) 0.5) t_m) t_m 1.0) (sqrt (* 2.0 z)))))
t_m = fabs(t);
double code(double x, double y, double z, double t_m) {
return ((x * 0.5) - y) * (fma((fma(0.125, (t_m * t_m), 0.5) * t_m), t_m, 1.0) * sqrt((2.0 * z)));
}
t_m = abs(t) function code(x, y, z, t_m) return Float64(Float64(Float64(x * 0.5) - y) * Float64(fma(Float64(fma(0.125, Float64(t_m * t_m), 0.5) * t_m), t_m, 1.0) * sqrt(Float64(2.0 * z)))) end
t_m = N[Abs[t], $MachinePrecision] code[x_, y_, z_, t$95$m_] := N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[(N[(N[(N[(0.125 * N[(t$95$m * t$95$m), $MachinePrecision] + 0.5), $MachinePrecision] * t$95$m), $MachinePrecision] * t$95$m + 1.0), $MachinePrecision] * N[Sqrt[N[(2.0 * z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
\left(x \cdot 0.5 - y\right) \cdot \left(\mathsf{fma}\left(\mathsf{fma}\left(0.125, t\_m \cdot t\_m, 0.5\right) \cdot t\_m, t\_m, 1\right) \cdot \sqrt{2 \cdot z}\right)
\end{array}
Initial program 99.7%
Taylor expanded in t around 0
+-commutativeN/A
*-commutativeN/A
unpow2N/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6494.3
Applied rewrites94.3%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f6494.3
Applied rewrites94.3%
Taylor expanded in t around 0
Applied rewrites92.4%
Final simplification92.4%
t_m = (fabs.f64 t) (FPCore (x y z t_m) :precision binary64 (* (* (- (* x 0.5) y) (sqrt (* z 2.0))) (fma (* (fma 0.125 (* t_m t_m) 0.5) t_m) t_m 1.0)))
t_m = fabs(t);
double code(double x, double y, double z, double t_m) {
return (((x * 0.5) - y) * sqrt((z * 2.0))) * fma((fma(0.125, (t_m * t_m), 0.5) * t_m), t_m, 1.0);
}
t_m = abs(t) function code(x, y, z, t_m) return Float64(Float64(Float64(Float64(x * 0.5) - y) * sqrt(Float64(z * 2.0))) * fma(Float64(fma(0.125, Float64(t_m * t_m), 0.5) * t_m), t_m, 1.0)) end
t_m = N[Abs[t], $MachinePrecision] code[x_, y_, z_, t$95$m_] := N[(N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(N[(0.125 * N[(t$95$m * t$95$m), $MachinePrecision] + 0.5), $MachinePrecision] * t$95$m), $MachinePrecision] * t$95$m + 1.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot \mathsf{fma}\left(\mathsf{fma}\left(0.125, t\_m \cdot t\_m, 0.5\right) \cdot t\_m, t\_m, 1\right)
\end{array}
Initial program 99.7%
Taylor expanded in t around 0
+-commutativeN/A
*-commutativeN/A
unpow2N/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6494.3
Applied rewrites94.3%
Taylor expanded in t around 0
Applied rewrites92.1%
t_m = (fabs.f64 t) (FPCore (x y z t_m) :precision binary64 (* (- (* 0.5 x) y) (sqrt (fma (* (fma t_m t_m 2.0) z) (* t_m t_m) (* 2.0 z)))))
t_m = fabs(t);
double code(double x, double y, double z, double t_m) {
return ((0.5 * x) - y) * sqrt(fma((fma(t_m, t_m, 2.0) * z), (t_m * t_m), (2.0 * z)));
}
t_m = abs(t) function code(x, y, z, t_m) return Float64(Float64(Float64(0.5 * x) - y) * sqrt(fma(Float64(fma(t_m, t_m, 2.0) * z), Float64(t_m * t_m), Float64(2.0 * z)))) end
t_m = N[Abs[t], $MachinePrecision] code[x_, y_, z_, t$95$m_] := N[(N[(N[(0.5 * x), $MachinePrecision] - y), $MachinePrecision] * N[Sqrt[N[(N[(N[(t$95$m * t$95$m + 2.0), $MachinePrecision] * z), $MachinePrecision] * N[(t$95$m * t$95$m), $MachinePrecision] + N[(2.0 * z), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
\left(0.5 \cdot x - y\right) \cdot \sqrt{\mathsf{fma}\left(\mathsf{fma}\left(t\_m, t\_m, 2\right) \cdot z, t\_m \cdot t\_m, 2 \cdot z\right)}
\end{array}
Initial program 99.7%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lift-sqrt.f64N/A
lift-exp.f64N/A
lift-/.f64N/A
exp-sqrtN/A
sqrt-unprodN/A
lower-sqrt.f64N/A
*-commutativeN/A
lower-*.f64N/A
lift-*.f64N/A
exp-prodN/A
lower-pow.f64N/A
lower-exp.f6499.8
Applied rewrites99.8%
lift-pow.f64N/A
lift-exp.f64N/A
pow-expN/A
lift-*.f64N/A
lower-exp.f6499.8
Applied rewrites99.8%
Taylor expanded in t around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
distribute-rgt-outN/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
unpow2N/A
lower-fma.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f6490.5
Applied rewrites90.5%
Final simplification90.5%
t_m = (fabs.f64 t) (FPCore (x y z t_m) :precision binary64 (* (* (fma (* t_m t_m) 0.5 1.0) (fma 0.5 x (- y))) (sqrt (* 2.0 z))))
t_m = fabs(t);
double code(double x, double y, double z, double t_m) {
return (fma((t_m * t_m), 0.5, 1.0) * fma(0.5, x, -y)) * sqrt((2.0 * z));
}
t_m = abs(t) function code(x, y, z, t_m) return Float64(Float64(fma(Float64(t_m * t_m), 0.5, 1.0) * fma(0.5, x, Float64(-y))) * sqrt(Float64(2.0 * z))) end
t_m = N[Abs[t], $MachinePrecision] code[x_, y_, z_, t$95$m_] := N[(N[(N[(N[(t$95$m * t$95$m), $MachinePrecision] * 0.5 + 1.0), $MachinePrecision] * N[(0.5 * x + (-y)), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(2.0 * z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
\left(\mathsf{fma}\left(t\_m \cdot t\_m, 0.5, 1\right) \cdot \mathsf{fma}\left(0.5, x, -y\right)\right) \cdot \sqrt{2 \cdot z}
\end{array}
Initial program 99.7%
Taylor expanded in t around 0
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
distribute-lft1-inN/A
+-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites86.3%
Applied rewrites87.9%
t_m = (fabs.f64 t) (FPCore (x y z t_m) :precision binary64 (* (- (* 0.5 x) y) (sqrt (* (fma t_m t_m 1.0) (* z 2.0)))))
t_m = fabs(t);
double code(double x, double y, double z, double t_m) {
return ((0.5 * x) - y) * sqrt((fma(t_m, t_m, 1.0) * (z * 2.0)));
}
t_m = abs(t) function code(x, y, z, t_m) return Float64(Float64(Float64(0.5 * x) - y) * sqrt(Float64(fma(t_m, t_m, 1.0) * Float64(z * 2.0)))) end
t_m = N[Abs[t], $MachinePrecision] code[x_, y_, z_, t$95$m_] := N[(N[(N[(0.5 * x), $MachinePrecision] - y), $MachinePrecision] * N[Sqrt[N[(N[(t$95$m * t$95$m + 1.0), $MachinePrecision] * N[(z * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
\left(0.5 \cdot x - y\right) \cdot \sqrt{\mathsf{fma}\left(t\_m, t\_m, 1\right) \cdot \left(z \cdot 2\right)}
\end{array}
Initial program 99.7%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lift-sqrt.f64N/A
lift-exp.f64N/A
lift-/.f64N/A
exp-sqrtN/A
sqrt-unprodN/A
lower-sqrt.f64N/A
*-commutativeN/A
lower-*.f64N/A
lift-*.f64N/A
exp-prodN/A
lower-pow.f64N/A
lower-exp.f6499.8
Applied rewrites99.8%
Taylor expanded in t around 0
+-commutativeN/A
unpow2N/A
lower-fma.f6485.3
Applied rewrites85.3%
t_m = (fabs.f64 t) (FPCore (x y z t_m) :precision binary64 (* (- (* 0.5 x) y) (sqrt (* 2.0 z))))
t_m = fabs(t);
double code(double x, double y, double z, double t_m) {
return ((0.5 * x) - y) * sqrt((2.0 * z));
}
t_m = abs(t)
real(8) function code(x, y, z, t_m)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t_m
code = ((0.5d0 * x) - y) * sqrt((2.0d0 * z))
end function
t_m = Math.abs(t);
public static double code(double x, double y, double z, double t_m) {
return ((0.5 * x) - y) * Math.sqrt((2.0 * z));
}
t_m = math.fabs(t) def code(x, y, z, t_m): return ((0.5 * x) - y) * math.sqrt((2.0 * z))
t_m = abs(t) function code(x, y, z, t_m) return Float64(Float64(Float64(0.5 * x) - y) * sqrt(Float64(2.0 * z))) end
t_m = abs(t); function tmp = code(x, y, z, t_m) tmp = ((0.5 * x) - y) * sqrt((2.0 * z)); end
t_m = N[Abs[t], $MachinePrecision] code[x_, y_, z_, t$95$m_] := N[(N[(N[(0.5 * x), $MachinePrecision] - y), $MachinePrecision] * N[Sqrt[N[(2.0 * z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
\left(0.5 \cdot x - y\right) \cdot \sqrt{2 \cdot z}
\end{array}
Initial program 99.7%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lift-sqrt.f64N/A
lift-exp.f64N/A
lift-/.f64N/A
exp-sqrtN/A
sqrt-unprodN/A
lower-sqrt.f64N/A
*-commutativeN/A
lower-*.f64N/A
lift-*.f64N/A
exp-prodN/A
lower-pow.f64N/A
lower-exp.f6499.8
Applied rewrites99.8%
Taylor expanded in t around 0
lower-*.f6458.1
Applied rewrites58.1%
t_m = (fabs.f64 t) (FPCore (x y z t_m) :precision binary64 (* (* (sqrt (* 2.0 z)) (- y)) 1.0))
t_m = fabs(t);
double code(double x, double y, double z, double t_m) {
return (sqrt((2.0 * z)) * -y) * 1.0;
}
t_m = abs(t)
real(8) function code(x, y, z, t_m)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t_m
code = (sqrt((2.0d0 * z)) * -y) * 1.0d0
end function
t_m = Math.abs(t);
public static double code(double x, double y, double z, double t_m) {
return (Math.sqrt((2.0 * z)) * -y) * 1.0;
}
t_m = math.fabs(t) def code(x, y, z, t_m): return (math.sqrt((2.0 * z)) * -y) * 1.0
t_m = abs(t) function code(x, y, z, t_m) return Float64(Float64(sqrt(Float64(2.0 * z)) * Float64(-y)) * 1.0) end
t_m = abs(t); function tmp = code(x, y, z, t_m) tmp = (sqrt((2.0 * z)) * -y) * 1.0; end
t_m = N[Abs[t], $MachinePrecision] code[x_, y_, z_, t$95$m_] := N[(N[(N[Sqrt[N[(2.0 * z), $MachinePrecision]], $MachinePrecision] * (-y)), $MachinePrecision] * 1.0), $MachinePrecision]
\begin{array}{l}
t_m = \left|t\right|
\\
\left(\sqrt{2 \cdot z} \cdot \left(-y\right)\right) \cdot 1
\end{array}
Initial program 99.7%
Taylor expanded in t around 0
Applied rewrites58.1%
Taylor expanded in x around 0
mul-1-negN/A
*-commutativeN/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sqrt.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f6432.2
Applied rewrites32.2%
Applied rewrites32.4%
Final simplification32.4%
(FPCore (x y z t) :precision binary64 (* (* (- (* x 0.5) y) (sqrt (* z 2.0))) (pow (exp 1.0) (/ (* t t) 2.0))))
double code(double x, double y, double z, double t) {
return (((x * 0.5) - y) * sqrt((z * 2.0))) * pow(exp(1.0), ((t * t) / 2.0));
}
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 * 0.5d0) - y) * sqrt((z * 2.0d0))) * (exp(1.0d0) ** ((t * t) / 2.0d0))
end function
public static double code(double x, double y, double z, double t) {
return (((x * 0.5) - y) * Math.sqrt((z * 2.0))) * Math.pow(Math.exp(1.0), ((t * t) / 2.0));
}
def code(x, y, z, t): return (((x * 0.5) - y) * math.sqrt((z * 2.0))) * math.pow(math.exp(1.0), ((t * t) / 2.0))
function code(x, y, z, t) return Float64(Float64(Float64(Float64(x * 0.5) - y) * sqrt(Float64(z * 2.0))) * (exp(1.0) ^ Float64(Float64(t * t) / 2.0))) end
function tmp = code(x, y, z, t) tmp = (((x * 0.5) - y) * sqrt((z * 2.0))) * (exp(1.0) ^ ((t * t) / 2.0)); end
code[x_, y_, z_, t_] := N[(N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Power[N[Exp[1.0], $MachinePrecision], N[(N[(t * t), $MachinePrecision] / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(x \cdot 0.5 - y\right) \cdot \sqrt{z \cdot 2}\right) \cdot {\left(e^{1}\right)}^{\left(\frac{t \cdot t}{2}\right)}
\end{array}
herbie shell --seed 2024338
(FPCore (x y z t)
:name "Data.Number.Erf:$cinvnormcdf from erf-2.0.0.0, A"
:precision binary64
:alt
(! :herbie-platform default (* (* (- (* x 1/2) y) (sqrt (* z 2))) (pow (exp 1) (/ (* t t) 2))))
(* (* (- (* x 0.5) y) (sqrt (* z 2.0))) (exp (/ (* t t) 2.0))))