
(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 18 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}
(FPCore (x y z t) :precision binary64 (* (sqrt (* z 2.0)) (* (- (* x 0.5) y) (pow (/ 1.0 (* E E)) (/ (* t t) -4.0)))))
double code(double x, double y, double z, double t) {
return sqrt((z * 2.0)) * (((x * 0.5) - y) * pow((1.0 / (((double) M_E) * ((double) M_E))), ((t * t) / -4.0)));
}
public static double code(double x, double y, double z, double t) {
return Math.sqrt((z * 2.0)) * (((x * 0.5) - y) * Math.pow((1.0 / (Math.E * Math.E)), ((t * t) / -4.0)));
}
def code(x, y, z, t): return math.sqrt((z * 2.0)) * (((x * 0.5) - y) * math.pow((1.0 / (math.e * math.e)), ((t * t) / -4.0)))
function code(x, y, z, t) return Float64(sqrt(Float64(z * 2.0)) * Float64(Float64(Float64(x * 0.5) - y) * (Float64(1.0 / Float64(exp(1) * exp(1))) ^ Float64(Float64(t * t) / -4.0)))) end
function tmp = code(x, y, z, t) tmp = sqrt((z * 2.0)) * (((x * 0.5) - y) * ((1.0 / (2.71828182845904523536 * 2.71828182845904523536)) ^ ((t * t) / -4.0))); end
code[x_, y_, z_, t_] := N[(N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision] * N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[Power[N[(1.0 / N[(E * E), $MachinePrecision]), $MachinePrecision], N[(N[(t * t), $MachinePrecision] / -4.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\sqrt{z \cdot 2} \cdot \left(\left(x \cdot 0.5 - y\right) \cdot {\left(\frac{1}{e \cdot e}\right)}^{\left(\frac{t \cdot t}{-4}\right)}\right)
\end{array}
Initial program 99.4%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
associate-/l*N/A
exp-prodN/A
pow-lowering-pow.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f6499.8%
Applied egg-rr99.8%
sqrt-pow1N/A
exp-prodN/A
exp-sqrtN/A
metadata-evalN/A
distribute-neg-frac2N/A
clear-numN/A
div-invN/A
log-EN/A
clear-numN/A
rec-expN/A
pow-to-expN/A
sqr-powN/A
pow-prod-downN/A
pow-flipN/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
E-lowering-E.f64N/A
E-lowering-E.f64N/A
neg-lowering-neg.f64N/A
Applied egg-rr99.8%
neg-mul-1N/A
pow-unpowN/A
pow-lowering-pow.f64N/A
unpow-1N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
E-lowering-E.f64N/A
E-lowering-E.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6499.8%
Applied egg-rr99.8%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (sqrt (* z 2.0))))
(if (<= (* t t) 1e-5)
(* t_1 (* (- (* x 0.5) y) (+ 1.0 (* t (* t (+ 0.5 (* (* t t) 0.125)))))))
(if (<= (* t t) 1e+55)
(* t_1 (/ (* x 0.5) (exp (* (* t t) -0.5))))
(*
t_1
(*
x
(*
(+
1.0
(*
(* t t)
(+ 0.5 (* (* t t) (+ 0.125 (* (* t t) 0.020833333333333332))))))
(- 0.5 (/ y x)))))))))
double code(double x, double y, double z, double t) {
double t_1 = sqrt((z * 2.0));
double tmp;
if ((t * t) <= 1e-5) {
tmp = t_1 * (((x * 0.5) - y) * (1.0 + (t * (t * (0.5 + ((t * t) * 0.125))))));
} else if ((t * t) <= 1e+55) {
tmp = t_1 * ((x * 0.5) / exp(((t * t) * -0.5)));
} else {
tmp = t_1 * (x * ((1.0 + ((t * t) * (0.5 + ((t * t) * (0.125 + ((t * t) * 0.020833333333333332)))))) * (0.5 - (y / x))));
}
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) :: t_1
real(8) :: tmp
t_1 = sqrt((z * 2.0d0))
if ((t * t) <= 1d-5) then
tmp = t_1 * (((x * 0.5d0) - y) * (1.0d0 + (t * (t * (0.5d0 + ((t * t) * 0.125d0))))))
else if ((t * t) <= 1d+55) then
tmp = t_1 * ((x * 0.5d0) / exp(((t * t) * (-0.5d0))))
else
tmp = t_1 * (x * ((1.0d0 + ((t * t) * (0.5d0 + ((t * t) * (0.125d0 + ((t * t) * 0.020833333333333332d0)))))) * (0.5d0 - (y / x))))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = Math.sqrt((z * 2.0));
double tmp;
if ((t * t) <= 1e-5) {
tmp = t_1 * (((x * 0.5) - y) * (1.0 + (t * (t * (0.5 + ((t * t) * 0.125))))));
} else if ((t * t) <= 1e+55) {
tmp = t_1 * ((x * 0.5) / Math.exp(((t * t) * -0.5)));
} else {
tmp = t_1 * (x * ((1.0 + ((t * t) * (0.5 + ((t * t) * (0.125 + ((t * t) * 0.020833333333333332)))))) * (0.5 - (y / x))));
}
return tmp;
}
def code(x, y, z, t): t_1 = math.sqrt((z * 2.0)) tmp = 0 if (t * t) <= 1e-5: tmp = t_1 * (((x * 0.5) - y) * (1.0 + (t * (t * (0.5 + ((t * t) * 0.125)))))) elif (t * t) <= 1e+55: tmp = t_1 * ((x * 0.5) / math.exp(((t * t) * -0.5))) else: tmp = t_1 * (x * ((1.0 + ((t * t) * (0.5 + ((t * t) * (0.125 + ((t * t) * 0.020833333333333332)))))) * (0.5 - (y / x)))) return tmp
function code(x, y, z, t) t_1 = sqrt(Float64(z * 2.0)) tmp = 0.0 if (Float64(t * t) <= 1e-5) tmp = Float64(t_1 * Float64(Float64(Float64(x * 0.5) - y) * Float64(1.0 + Float64(t * Float64(t * Float64(0.5 + Float64(Float64(t * t) * 0.125))))))); elseif (Float64(t * t) <= 1e+55) tmp = Float64(t_1 * Float64(Float64(x * 0.5) / exp(Float64(Float64(t * t) * -0.5)))); else tmp = Float64(t_1 * Float64(x * Float64(Float64(1.0 + Float64(Float64(t * t) * Float64(0.5 + Float64(Float64(t * t) * Float64(0.125 + Float64(Float64(t * t) * 0.020833333333333332)))))) * Float64(0.5 - Float64(y / x))))); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = sqrt((z * 2.0)); tmp = 0.0; if ((t * t) <= 1e-5) tmp = t_1 * (((x * 0.5) - y) * (1.0 + (t * (t * (0.5 + ((t * t) * 0.125)))))); elseif ((t * t) <= 1e+55) tmp = t_1 * ((x * 0.5) / exp(((t * t) * -0.5))); else tmp = t_1 * (x * ((1.0 + ((t * t) * (0.5 + ((t * t) * (0.125 + ((t * t) * 0.020833333333333332)))))) * (0.5 - (y / x)))); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[N[(t * t), $MachinePrecision], 1e-5], N[(t$95$1 * N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[(1.0 + N[(t * N[(t * N[(0.5 + N[(N[(t * t), $MachinePrecision] * 0.125), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(t * t), $MachinePrecision], 1e+55], N[(t$95$1 * N[(N[(x * 0.5), $MachinePrecision] / N[Exp[N[(N[(t * t), $MachinePrecision] * -0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 * N[(x * N[(N[(1.0 + N[(N[(t * t), $MachinePrecision] * N[(0.5 + N[(N[(t * t), $MachinePrecision] * N[(0.125 + N[(N[(t * t), $MachinePrecision] * 0.020833333333333332), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(0.5 - N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sqrt{z \cdot 2}\\
\mathbf{if}\;t \cdot t \leq 10^{-5}:\\
\;\;\;\;t\_1 \cdot \left(\left(x \cdot 0.5 - y\right) \cdot \left(1 + t \cdot \left(t \cdot \left(0.5 + \left(t \cdot t\right) \cdot 0.125\right)\right)\right)\right)\\
\mathbf{elif}\;t \cdot t \leq 10^{+55}:\\
\;\;\;\;t\_1 \cdot \frac{x \cdot 0.5}{e^{\left(t \cdot t\right) \cdot -0.5}}\\
\mathbf{else}:\\
\;\;\;\;t\_1 \cdot \left(x \cdot \left(\left(1 + \left(t \cdot t\right) \cdot \left(0.5 + \left(t \cdot t\right) \cdot \left(0.125 + \left(t \cdot t\right) \cdot 0.020833333333333332\right)\right)\right) \cdot \left(0.5 - \frac{y}{x}\right)\right)\right)\\
\end{array}
\end{array}
if (*.f64 t t) < 1.00000000000000008e-5Initial program 99.7%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6499.7%
Simplified99.7%
Taylor expanded in t around 0
+-lowering-+.f64N/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6499.7%
Simplified99.7%
if 1.00000000000000008e-5 < (*.f64 t t) < 1.00000000000000001e55Initial program 99.3%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6499.3%
Simplified99.3%
*-lft-identityN/A
exp-prodN/A
frac-2negN/A
distribute-frac-negN/A
pow-negN/A
/-lowering-/.f64N/A
pow-lowering-pow.f64N/A
exp-1-eN/A
E-lowering-E.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-eval99.5%
Applied egg-rr99.5%
Taylor expanded in x around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
log-EN/A
*-rgt-identityN/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6490.3%
Simplified90.3%
if 1.00000000000000001e55 < (*.f64 t t) Initial program 99.3%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in t around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6498.6%
Simplified98.6%
Taylor expanded in x around inf
*-lowering-*.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
*-commutativeN/A
Simplified100.0%
Final simplification99.4%
(FPCore (x y z t) :precision binary64 (* (sqrt (* z 2.0)) (* (- (* x 0.5) y) (pow (* E E) (/ (* t t) 4.0)))))
double code(double x, double y, double z, double t) {
return sqrt((z * 2.0)) * (((x * 0.5) - y) * pow((((double) M_E) * ((double) M_E)), ((t * t) / 4.0)));
}
public static double code(double x, double y, double z, double t) {
return Math.sqrt((z * 2.0)) * (((x * 0.5) - y) * Math.pow((Math.E * Math.E), ((t * t) / 4.0)));
}
def code(x, y, z, t): return math.sqrt((z * 2.0)) * (((x * 0.5) - y) * math.pow((math.e * math.e), ((t * t) / 4.0)))
function code(x, y, z, t) return Float64(sqrt(Float64(z * 2.0)) * Float64(Float64(Float64(x * 0.5) - y) * (Float64(exp(1) * exp(1)) ^ Float64(Float64(t * t) / 4.0)))) end
function tmp = code(x, y, z, t) tmp = sqrt((z * 2.0)) * (((x * 0.5) - y) * ((2.71828182845904523536 * 2.71828182845904523536) ^ ((t * t) / 4.0))); end
code[x_, y_, z_, t_] := N[(N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision] * N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[Power[N[(E * E), $MachinePrecision], N[(N[(t * t), $MachinePrecision] / 4.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\sqrt{z \cdot 2} \cdot \left(\left(x \cdot 0.5 - y\right) \cdot {\left(e \cdot e\right)}^{\left(\frac{t \cdot t}{4}\right)}\right)
\end{array}
Initial program 99.4%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
associate-/l*N/A
exp-prodN/A
pow-lowering-pow.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f6499.8%
Applied egg-rr99.8%
sqrt-pow1N/A
exp-prodN/A
exp-sqrtN/A
metadata-evalN/A
distribute-neg-frac2N/A
clear-numN/A
div-invN/A
log-EN/A
clear-numN/A
rec-expN/A
pow-to-expN/A
sqr-powN/A
pow-prod-downN/A
pow-flipN/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
E-lowering-E.f64N/A
E-lowering-E.f64N/A
neg-lowering-neg.f64N/A
Applied egg-rr99.8%
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
E-lowering-E.f64N/A
E-lowering-E.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-eval99.8%
Applied egg-rr99.8%
(FPCore (x y z t) :precision binary64 (* (sqrt (* z 2.0)) (* (- (* x 0.5) y) (/ 1.0 (pow E (/ (* t t) -2.0))))))
double code(double x, double y, double z, double t) {
return sqrt((z * 2.0)) * (((x * 0.5) - y) * (1.0 / pow(((double) M_E), ((t * t) / -2.0))));
}
public static double code(double x, double y, double z, double t) {
return Math.sqrt((z * 2.0)) * (((x * 0.5) - y) * (1.0 / Math.pow(Math.E, ((t * t) / -2.0))));
}
def code(x, y, z, t): return math.sqrt((z * 2.0)) * (((x * 0.5) - y) * (1.0 / math.pow(math.e, ((t * t) / -2.0))))
function code(x, y, z, t) return Float64(sqrt(Float64(z * 2.0)) * Float64(Float64(Float64(x * 0.5) - y) * Float64(1.0 / (exp(1) ^ Float64(Float64(t * t) / -2.0))))) end
function tmp = code(x, y, z, t) tmp = sqrt((z * 2.0)) * (((x * 0.5) - y) * (1.0 / (2.71828182845904523536 ^ ((t * t) / -2.0)))); end
code[x_, y_, z_, t_] := N[(N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision] * N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[(1.0 / N[Power[E, N[(N[(t * t), $MachinePrecision] / -2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\sqrt{z \cdot 2} \cdot \left(\left(x \cdot 0.5 - y\right) \cdot \frac{1}{{e}^{\left(\frac{t \cdot t}{-2}\right)}}\right)
\end{array}
Initial program 99.4%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
*-lft-identityN/A
exp-prodN/A
frac-2negN/A
distribute-frac-negN/A
pow-negN/A
/-lowering-/.f64N/A
pow-lowering-pow.f64N/A
exp-1-eN/A
E-lowering-E.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-eval99.8%
Applied egg-rr99.8%
(FPCore (x y z t) :precision binary64 (* (sqrt (* z 2.0)) (* (- (* x 0.5) y) (/ 1.0 (exp (/ (* t t) -2.0))))))
double code(double x, double y, double z, double t) {
return sqrt((z * 2.0)) * (((x * 0.5) - y) * (1.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 = sqrt((z * 2.0d0)) * (((x * 0.5d0) - y) * (1.0d0 / exp(((t * t) / (-2.0d0)))))
end function
public static double code(double x, double y, double z, double t) {
return Math.sqrt((z * 2.0)) * (((x * 0.5) - y) * (1.0 / Math.exp(((t * t) / -2.0))));
}
def code(x, y, z, t): return math.sqrt((z * 2.0)) * (((x * 0.5) - y) * (1.0 / math.exp(((t * t) / -2.0))))
function code(x, y, z, t) return Float64(sqrt(Float64(z * 2.0)) * Float64(Float64(Float64(x * 0.5) - y) * Float64(1.0 / exp(Float64(Float64(t * t) / -2.0))))) end
function tmp = code(x, y, z, t) tmp = sqrt((z * 2.0)) * (((x * 0.5) - y) * (1.0 / exp(((t * t) / -2.0)))); end
code[x_, y_, z_, t_] := N[(N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision] * N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[(1.0 / N[Exp[N[(N[(t * t), $MachinePrecision] / -2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\sqrt{z \cdot 2} \cdot \left(\left(x \cdot 0.5 - y\right) \cdot \frac{1}{e^{\frac{t \cdot t}{-2}}}\right)
\end{array}
Initial program 99.4%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
frac-2negN/A
distribute-frac-negN/A
exp-negN/A
/-lowering-/.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-eval99.8%
Applied egg-rr99.8%
(FPCore (x y z t) :precision binary64 (* (sqrt (* z 2.0)) (* (- (* x 0.5) y) (exp (/ (* t t) 2.0)))))
double code(double x, double y, double z, double t) {
return sqrt((z * 2.0)) * (((x * 0.5) - y) * 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 = sqrt((z * 2.0d0)) * (((x * 0.5d0) - y) * exp(((t * t) / 2.0d0)))
end function
public static double code(double x, double y, double z, double t) {
return Math.sqrt((z * 2.0)) * (((x * 0.5) - y) * Math.exp(((t * t) / 2.0)));
}
def code(x, y, z, t): return math.sqrt((z * 2.0)) * (((x * 0.5) - y) * math.exp(((t * t) / 2.0)))
function code(x, y, z, t) return Float64(sqrt(Float64(z * 2.0)) * Float64(Float64(Float64(x * 0.5) - y) * exp(Float64(Float64(t * t) / 2.0)))) end
function tmp = code(x, y, z, t) tmp = sqrt((z * 2.0)) * (((x * 0.5) - y) * exp(((t * t) / 2.0))); end
code[x_, y_, z_, t_] := N[(N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision] * N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[Exp[N[(N[(t * t), $MachinePrecision] / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\sqrt{z \cdot 2} \cdot \left(\left(x \cdot 0.5 - y\right) \cdot e^{\frac{t \cdot t}{2}}\right)
\end{array}
Initial program 99.4%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
(FPCore (x y z t) :precision binary64 (* (- (* x 0.5) y) (sqrt (* (* z 2.0) (exp (* t t))))))
double code(double x, double y, double z, double t) {
return ((x * 0.5) - y) * sqrt(((z * 2.0) * exp((t * t))));
}
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))))
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))));
}
def code(x, y, z, t): return ((x * 0.5) - y) * math.sqrt(((z * 2.0) * math.exp((t * t))))
function code(x, y, z, t) return Float64(Float64(Float64(x * 0.5) - y) * sqrt(Float64(Float64(z * 2.0) * exp(Float64(t * t))))) end
function tmp = code(x, y, z, t) tmp = ((x * 0.5) - y) * sqrt(((z * 2.0) * exp((t * t)))); end
code[x_, y_, z_, t_] := N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[Sqrt[N[(N[(z * 2.0), $MachinePrecision] * N[Exp[N[(t * t), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot 0.5 - y\right) \cdot \sqrt{\left(z \cdot 2\right) \cdot e^{t \cdot t}}
\end{array}
Initial program 99.4%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
exp-sqrtN/A
sqrt-unprodN/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6499.8%
Applied egg-rr99.8%
Final simplification99.8%
(FPCore (x y z t)
:precision binary64
(*
(sqrt (* z 2.0))
(*
(- (* x 0.5) y)
(+
1.0
(*
(* t t)
(+ 0.5 (* t (* t (+ 0.125 (* (* t t) 0.020833333333333332))))))))))
double code(double x, double y, double z, double t) {
return sqrt((z * 2.0)) * (((x * 0.5) - y) * (1.0 + ((t * t) * (0.5 + (t * (t * (0.125 + ((t * t) * 0.020833333333333332))))))));
}
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 = sqrt((z * 2.0d0)) * (((x * 0.5d0) - y) * (1.0d0 + ((t * t) * (0.5d0 + (t * (t * (0.125d0 + ((t * t) * 0.020833333333333332d0))))))))
end function
public static double code(double x, double y, double z, double t) {
return Math.sqrt((z * 2.0)) * (((x * 0.5) - y) * (1.0 + ((t * t) * (0.5 + (t * (t * (0.125 + ((t * t) * 0.020833333333333332))))))));
}
def code(x, y, z, t): return math.sqrt((z * 2.0)) * (((x * 0.5) - y) * (1.0 + ((t * t) * (0.5 + (t * (t * (0.125 + ((t * t) * 0.020833333333333332))))))))
function code(x, y, z, t) return Float64(sqrt(Float64(z * 2.0)) * Float64(Float64(Float64(x * 0.5) - y) * Float64(1.0 + Float64(Float64(t * t) * Float64(0.5 + Float64(t * Float64(t * Float64(0.125 + Float64(Float64(t * t) * 0.020833333333333332))))))))) end
function tmp = code(x, y, z, t) tmp = sqrt((z * 2.0)) * (((x * 0.5) - y) * (1.0 + ((t * t) * (0.5 + (t * (t * (0.125 + ((t * t) * 0.020833333333333332)))))))); end
code[x_, y_, z_, t_] := N[(N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision] * N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[(1.0 + N[(N[(t * t), $MachinePrecision] * N[(0.5 + N[(t * N[(t * N[(0.125 + N[(N[(t * t), $MachinePrecision] * 0.020833333333333332), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\sqrt{z \cdot 2} \cdot \left(\left(x \cdot 0.5 - y\right) \cdot \left(1 + \left(t \cdot t\right) \cdot \left(0.5 + t \cdot \left(t \cdot \left(0.125 + \left(t \cdot t\right) \cdot 0.020833333333333332\right)\right)\right)\right)\right)
\end{array}
Initial program 99.4%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in t around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6496.2%
Simplified96.2%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (sqrt (* z 2.0))))
(if (<= t 8e+54)
(* t_1 (- (* x 0.5) y))
(if (<= t 3e+195)
(* t_1 (* x (+ 0.5 (* (* t t) 0.25))))
(* t_1 (* y (* (* t t) -0.5)))))))
double code(double x, double y, double z, double t) {
double t_1 = sqrt((z * 2.0));
double tmp;
if (t <= 8e+54) {
tmp = t_1 * ((x * 0.5) - y);
} else if (t <= 3e+195) {
tmp = t_1 * (x * (0.5 + ((t * t) * 0.25)));
} else {
tmp = t_1 * (y * ((t * t) * -0.5));
}
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) :: t_1
real(8) :: tmp
t_1 = sqrt((z * 2.0d0))
if (t <= 8d+54) then
tmp = t_1 * ((x * 0.5d0) - y)
else if (t <= 3d+195) then
tmp = t_1 * (x * (0.5d0 + ((t * t) * 0.25d0)))
else
tmp = t_1 * (y * ((t * t) * (-0.5d0)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = Math.sqrt((z * 2.0));
double tmp;
if (t <= 8e+54) {
tmp = t_1 * ((x * 0.5) - y);
} else if (t <= 3e+195) {
tmp = t_1 * (x * (0.5 + ((t * t) * 0.25)));
} else {
tmp = t_1 * (y * ((t * t) * -0.5));
}
return tmp;
}
def code(x, y, z, t): t_1 = math.sqrt((z * 2.0)) tmp = 0 if t <= 8e+54: tmp = t_1 * ((x * 0.5) - y) elif t <= 3e+195: tmp = t_1 * (x * (0.5 + ((t * t) * 0.25))) else: tmp = t_1 * (y * ((t * t) * -0.5)) return tmp
function code(x, y, z, t) t_1 = sqrt(Float64(z * 2.0)) tmp = 0.0 if (t <= 8e+54) tmp = Float64(t_1 * Float64(Float64(x * 0.5) - y)); elseif (t <= 3e+195) tmp = Float64(t_1 * Float64(x * Float64(0.5 + Float64(Float64(t * t) * 0.25)))); else tmp = Float64(t_1 * Float64(y * Float64(Float64(t * t) * -0.5))); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = sqrt((z * 2.0)); tmp = 0.0; if (t <= 8e+54) tmp = t_1 * ((x * 0.5) - y); elseif (t <= 3e+195) tmp = t_1 * (x * (0.5 + ((t * t) * 0.25))); else tmp = t_1 * (y * ((t * t) * -0.5)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t, 8e+54], N[(t$95$1 * N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3e+195], N[(t$95$1 * N[(x * N[(0.5 + N[(N[(t * t), $MachinePrecision] * 0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 * N[(y * N[(N[(t * t), $MachinePrecision] * -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sqrt{z \cdot 2}\\
\mathbf{if}\;t \leq 8 \cdot 10^{+54}:\\
\;\;\;\;t\_1 \cdot \left(x \cdot 0.5 - y\right)\\
\mathbf{elif}\;t \leq 3 \cdot 10^{+195}:\\
\;\;\;\;t\_1 \cdot \left(x \cdot \left(0.5 + \left(t \cdot t\right) \cdot 0.25\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1 \cdot \left(y \cdot \left(\left(t \cdot t\right) \cdot -0.5\right)\right)\\
\end{array}
\end{array}
if t < 8.0000000000000006e54Initial program 99.8%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in t around 0
--lowering--.f64N/A
*-lowering-*.f6463.1%
Simplified63.1%
if 8.0000000000000006e54 < t < 3.0000000000000001e195Initial program 97.3%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in t around 0
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6479.6%
Simplified79.6%
Taylor expanded in x around inf
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
distribute-lft-inN/A
metadata-evalN/A
+-lowering-+.f64N/A
associate-*r*N/A
metadata-evalN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6460.3%
Simplified60.3%
if 3.0000000000000001e195 < t Initial program 100.0%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in t around 0
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in x around 0
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6481.3%
Simplified81.3%
Final simplification65.0%
(FPCore (x y z t) :precision binary64 (* (sqrt (* z 2.0)) (* (- (* x 0.5) y) (+ 1.0 (* t (* t (+ 0.5 (* (* t t) 0.125))))))))
double code(double x, double y, double z, double t) {
return sqrt((z * 2.0)) * (((x * 0.5) - y) * (1.0 + (t * (t * (0.5 + ((t * t) * 0.125))))));
}
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 = sqrt((z * 2.0d0)) * (((x * 0.5d0) - y) * (1.0d0 + (t * (t * (0.5d0 + ((t * t) * 0.125d0))))))
end function
public static double code(double x, double y, double z, double t) {
return Math.sqrt((z * 2.0)) * (((x * 0.5) - y) * (1.0 + (t * (t * (0.5 + ((t * t) * 0.125))))));
}
def code(x, y, z, t): return math.sqrt((z * 2.0)) * (((x * 0.5) - y) * (1.0 + (t * (t * (0.5 + ((t * t) * 0.125))))))
function code(x, y, z, t) return Float64(sqrt(Float64(z * 2.0)) * Float64(Float64(Float64(x * 0.5) - y) * Float64(1.0 + Float64(t * Float64(t * Float64(0.5 + Float64(Float64(t * t) * 0.125))))))) end
function tmp = code(x, y, z, t) tmp = sqrt((z * 2.0)) * (((x * 0.5) - y) * (1.0 + (t * (t * (0.5 + ((t * t) * 0.125)))))); end
code[x_, y_, z_, t_] := N[(N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision] * N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[(1.0 + N[(t * N[(t * N[(0.5 + N[(N[(t * t), $MachinePrecision] * 0.125), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\sqrt{z \cdot 2} \cdot \left(\left(x \cdot 0.5 - y\right) \cdot \left(1 + t \cdot \left(t \cdot \left(0.5 + \left(t \cdot t\right) \cdot 0.125\right)\right)\right)\right)
\end{array}
Initial program 99.4%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in t around 0
+-lowering-+.f64N/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6493.6%
Simplified93.6%
(FPCore (x y z t) :precision binary64 (let* ((t_1 (sqrt (* z 2.0))) (t_2 (- (* x 0.5) y))) (if (<= (* t t) 1e-5) (* t_1 t_2) (* t_1 (* t_2 (* 0.5 (* t t)))))))
double code(double x, double y, double z, double t) {
double t_1 = sqrt((z * 2.0));
double t_2 = (x * 0.5) - y;
double tmp;
if ((t * t) <= 1e-5) {
tmp = t_1 * t_2;
} else {
tmp = t_1 * (t_2 * (0.5 * (t * t)));
}
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) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = sqrt((z * 2.0d0))
t_2 = (x * 0.5d0) - y
if ((t * t) <= 1d-5) then
tmp = t_1 * t_2
else
tmp = t_1 * (t_2 * (0.5d0 * (t * t)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = Math.sqrt((z * 2.0));
double t_2 = (x * 0.5) - y;
double tmp;
if ((t * t) <= 1e-5) {
tmp = t_1 * t_2;
} else {
tmp = t_1 * (t_2 * (0.5 * (t * t)));
}
return tmp;
}
def code(x, y, z, t): t_1 = math.sqrt((z * 2.0)) t_2 = (x * 0.5) - y tmp = 0 if (t * t) <= 1e-5: tmp = t_1 * t_2 else: tmp = t_1 * (t_2 * (0.5 * (t * t))) return tmp
function code(x, y, z, t) t_1 = sqrt(Float64(z * 2.0)) t_2 = Float64(Float64(x * 0.5) - y) tmp = 0.0 if (Float64(t * t) <= 1e-5) tmp = Float64(t_1 * t_2); else tmp = Float64(t_1 * Float64(t_2 * Float64(0.5 * Float64(t * t)))); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = sqrt((z * 2.0)); t_2 = (x * 0.5) - y; tmp = 0.0; if ((t * t) <= 1e-5) tmp = t_1 * t_2; else tmp = t_1 * (t_2 * (0.5 * (t * t))); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision]}, If[LessEqual[N[(t * t), $MachinePrecision], 1e-5], N[(t$95$1 * t$95$2), $MachinePrecision], N[(t$95$1 * N[(t$95$2 * N[(0.5 * N[(t * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sqrt{z \cdot 2}\\
t_2 := x \cdot 0.5 - y\\
\mathbf{if}\;t \cdot t \leq 10^{-5}:\\
\;\;\;\;t\_1 \cdot t\_2\\
\mathbf{else}:\\
\;\;\;\;t\_1 \cdot \left(t\_2 \cdot \left(0.5 \cdot \left(t \cdot t\right)\right)\right)\\
\end{array}
\end{array}
if (*.f64 t t) < 1.00000000000000008e-5Initial program 99.7%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6499.7%
Simplified99.7%
Taylor expanded in t around 0
--lowering--.f64N/A
*-lowering-*.f6499.1%
Simplified99.1%
if 1.00000000000000008e-5 < (*.f64 t t) Initial program 99.3%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in t around 0
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6480.5%
Simplified80.5%
Taylor expanded in t around inf
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6480.5%
Simplified80.5%
Final simplification88.5%
(FPCore (x y z t) :precision binary64 (let* ((t_1 (sqrt (* z 2.0))) (t_2 (- (* x 0.5) y))) (if (<= (* t t) 1e-5) (* t_1 t_2) (* t_1 (* (* t_2 t) (* 0.5 t))))))
double code(double x, double y, double z, double t) {
double t_1 = sqrt((z * 2.0));
double t_2 = (x * 0.5) - y;
double tmp;
if ((t * t) <= 1e-5) {
tmp = t_1 * t_2;
} else {
tmp = t_1 * ((t_2 * t) * (0.5 * t));
}
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) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = sqrt((z * 2.0d0))
t_2 = (x * 0.5d0) - y
if ((t * t) <= 1d-5) then
tmp = t_1 * t_2
else
tmp = t_1 * ((t_2 * t) * (0.5d0 * t))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = Math.sqrt((z * 2.0));
double t_2 = (x * 0.5) - y;
double tmp;
if ((t * t) <= 1e-5) {
tmp = t_1 * t_2;
} else {
tmp = t_1 * ((t_2 * t) * (0.5 * t));
}
return tmp;
}
def code(x, y, z, t): t_1 = math.sqrt((z * 2.0)) t_2 = (x * 0.5) - y tmp = 0 if (t * t) <= 1e-5: tmp = t_1 * t_2 else: tmp = t_1 * ((t_2 * t) * (0.5 * t)) return tmp
function code(x, y, z, t) t_1 = sqrt(Float64(z * 2.0)) t_2 = Float64(Float64(x * 0.5) - y) tmp = 0.0 if (Float64(t * t) <= 1e-5) tmp = Float64(t_1 * t_2); else tmp = Float64(t_1 * Float64(Float64(t_2 * t) * Float64(0.5 * t))); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = sqrt((z * 2.0)); t_2 = (x * 0.5) - y; tmp = 0.0; if ((t * t) <= 1e-5) tmp = t_1 * t_2; else tmp = t_1 * ((t_2 * t) * (0.5 * t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision]}, If[LessEqual[N[(t * t), $MachinePrecision], 1e-5], N[(t$95$1 * t$95$2), $MachinePrecision], N[(t$95$1 * N[(N[(t$95$2 * t), $MachinePrecision] * N[(0.5 * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sqrt{z \cdot 2}\\
t_2 := x \cdot 0.5 - y\\
\mathbf{if}\;t \cdot t \leq 10^{-5}:\\
\;\;\;\;t\_1 \cdot t\_2\\
\mathbf{else}:\\
\;\;\;\;t\_1 \cdot \left(\left(t\_2 \cdot t\right) \cdot \left(0.5 \cdot t\right)\right)\\
\end{array}
\end{array}
if (*.f64 t t) < 1.00000000000000008e-5Initial program 99.7%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6499.7%
Simplified99.7%
Taylor expanded in t around 0
--lowering--.f64N/A
*-lowering-*.f6499.1%
Simplified99.1%
if 1.00000000000000008e-5 < (*.f64 t t) Initial program 99.3%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in t around 0
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6480.5%
Simplified80.5%
Taylor expanded in t around inf
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6480.5%
Simplified80.5%
associate-*l*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6477.3%
Applied egg-rr77.3%
Final simplification86.6%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (sqrt (* z 2.0))))
(if (<= t 7.2e+54)
(* t_1 (- (* x 0.5) y))
(if (<= t 2.65e+185)
(* t_1 (* x (* (* t t) 0.25)))
(* t_1 (* y (* (* t t) -0.5)))))))
double code(double x, double y, double z, double t) {
double t_1 = sqrt((z * 2.0));
double tmp;
if (t <= 7.2e+54) {
tmp = t_1 * ((x * 0.5) - y);
} else if (t <= 2.65e+185) {
tmp = t_1 * (x * ((t * t) * 0.25));
} else {
tmp = t_1 * (y * ((t * t) * -0.5));
}
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) :: t_1
real(8) :: tmp
t_1 = sqrt((z * 2.0d0))
if (t <= 7.2d+54) then
tmp = t_1 * ((x * 0.5d0) - y)
else if (t <= 2.65d+185) then
tmp = t_1 * (x * ((t * t) * 0.25d0))
else
tmp = t_1 * (y * ((t * t) * (-0.5d0)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = Math.sqrt((z * 2.0));
double tmp;
if (t <= 7.2e+54) {
tmp = t_1 * ((x * 0.5) - y);
} else if (t <= 2.65e+185) {
tmp = t_1 * (x * ((t * t) * 0.25));
} else {
tmp = t_1 * (y * ((t * t) * -0.5));
}
return tmp;
}
def code(x, y, z, t): t_1 = math.sqrt((z * 2.0)) tmp = 0 if t <= 7.2e+54: tmp = t_1 * ((x * 0.5) - y) elif t <= 2.65e+185: tmp = t_1 * (x * ((t * t) * 0.25)) else: tmp = t_1 * (y * ((t * t) * -0.5)) return tmp
function code(x, y, z, t) t_1 = sqrt(Float64(z * 2.0)) tmp = 0.0 if (t <= 7.2e+54) tmp = Float64(t_1 * Float64(Float64(x * 0.5) - y)); elseif (t <= 2.65e+185) tmp = Float64(t_1 * Float64(x * Float64(Float64(t * t) * 0.25))); else tmp = Float64(t_1 * Float64(y * Float64(Float64(t * t) * -0.5))); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = sqrt((z * 2.0)); tmp = 0.0; if (t <= 7.2e+54) tmp = t_1 * ((x * 0.5) - y); elseif (t <= 2.65e+185) tmp = t_1 * (x * ((t * t) * 0.25)); else tmp = t_1 * (y * ((t * t) * -0.5)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t, 7.2e+54], N[(t$95$1 * N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.65e+185], N[(t$95$1 * N[(x * N[(N[(t * t), $MachinePrecision] * 0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 * N[(y * N[(N[(t * t), $MachinePrecision] * -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sqrt{z \cdot 2}\\
\mathbf{if}\;t \leq 7.2 \cdot 10^{+54}:\\
\;\;\;\;t\_1 \cdot \left(x \cdot 0.5 - y\right)\\
\mathbf{elif}\;t \leq 2.65 \cdot 10^{+185}:\\
\;\;\;\;t\_1 \cdot \left(x \cdot \left(\left(t \cdot t\right) \cdot 0.25\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1 \cdot \left(y \cdot \left(\left(t \cdot t\right) \cdot -0.5\right)\right)\\
\end{array}
\end{array}
if t < 7.2000000000000003e54Initial program 99.8%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in t around 0
--lowering--.f64N/A
*-lowering-*.f6463.1%
Simplified63.1%
if 7.2000000000000003e54 < t < 2.65000000000000004e185Initial program 97.1%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in t around 0
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6477.8%
Simplified77.8%
Taylor expanded in t around inf
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6477.8%
Simplified77.8%
Taylor expanded in x around inf
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6456.8%
Simplified56.8%
if 2.65000000000000004e185 < t Initial program 100.0%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in t around 0
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in x around 0
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6480.0%
Simplified80.0%
Final simplification64.6%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (sqrt (* z 2.0))))
(if (or (<= x -3.15e+147) (not (<= x 9.5e+73)))
(* t_1 (* x 0.5))
(* t_1 (- 0.0 y)))))
double code(double x, double y, double z, double t) {
double t_1 = sqrt((z * 2.0));
double tmp;
if ((x <= -3.15e+147) || !(x <= 9.5e+73)) {
tmp = t_1 * (x * 0.5);
} else {
tmp = t_1 * (0.0 - y);
}
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) :: t_1
real(8) :: tmp
t_1 = sqrt((z * 2.0d0))
if ((x <= (-3.15d+147)) .or. (.not. (x <= 9.5d+73))) then
tmp = t_1 * (x * 0.5d0)
else
tmp = t_1 * (0.0d0 - y)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = Math.sqrt((z * 2.0));
double tmp;
if ((x <= -3.15e+147) || !(x <= 9.5e+73)) {
tmp = t_1 * (x * 0.5);
} else {
tmp = t_1 * (0.0 - y);
}
return tmp;
}
def code(x, y, z, t): t_1 = math.sqrt((z * 2.0)) tmp = 0 if (x <= -3.15e+147) or not (x <= 9.5e+73): tmp = t_1 * (x * 0.5) else: tmp = t_1 * (0.0 - y) return tmp
function code(x, y, z, t) t_1 = sqrt(Float64(z * 2.0)) tmp = 0.0 if ((x <= -3.15e+147) || !(x <= 9.5e+73)) tmp = Float64(t_1 * Float64(x * 0.5)); else tmp = Float64(t_1 * Float64(0.0 - y)); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = sqrt((z * 2.0)); tmp = 0.0; if ((x <= -3.15e+147) || ~((x <= 9.5e+73))) tmp = t_1 * (x * 0.5); else tmp = t_1 * (0.0 - y); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision]}, If[Or[LessEqual[x, -3.15e+147], N[Not[LessEqual[x, 9.5e+73]], $MachinePrecision]], N[(t$95$1 * N[(x * 0.5), $MachinePrecision]), $MachinePrecision], N[(t$95$1 * N[(0.0 - y), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sqrt{z \cdot 2}\\
\mathbf{if}\;x \leq -3.15 \cdot 10^{+147} \lor \neg \left(x \leq 9.5 \cdot 10^{+73}\right):\\
\;\;\;\;t\_1 \cdot \left(x \cdot 0.5\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1 \cdot \left(0 - y\right)\\
\end{array}
\end{array}
if x < -3.14999999999999991e147 or 9.4999999999999996e73 < x Initial program 99.9%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6499.9%
Simplified99.9%
Taylor expanded in t around 0
--lowering--.f64N/A
*-lowering-*.f6455.7%
Simplified55.7%
Taylor expanded in x around inf
*-lowering-*.f6452.7%
Simplified52.7%
if -3.14999999999999991e147 < x < 9.4999999999999996e73Initial program 99.2%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in t around 0
--lowering--.f64N/A
*-lowering-*.f6447.4%
Simplified47.4%
Taylor expanded in x around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f6436.4%
Simplified36.4%
sub0-negN/A
neg-lowering-neg.f6436.4%
Applied egg-rr36.4%
Final simplification42.1%
(FPCore (x y z t) :precision binary64 (* (sqrt (* z 2.0)) (* (- (* x 0.5) y) (+ 1.0 (* 0.5 (* t t))))))
double code(double x, double y, double z, double t) {
return sqrt((z * 2.0)) * (((x * 0.5) - y) * (1.0 + (0.5 * (t * t))));
}
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 = sqrt((z * 2.0d0)) * (((x * 0.5d0) - y) * (1.0d0 + (0.5d0 * (t * t))))
end function
public static double code(double x, double y, double z, double t) {
return Math.sqrt((z * 2.0)) * (((x * 0.5) - y) * (1.0 + (0.5 * (t * t))));
}
def code(x, y, z, t): return math.sqrt((z * 2.0)) * (((x * 0.5) - y) * (1.0 + (0.5 * (t * t))))
function code(x, y, z, t) return Float64(sqrt(Float64(z * 2.0)) * Float64(Float64(Float64(x * 0.5) - y) * Float64(1.0 + Float64(0.5 * Float64(t * t))))) end
function tmp = code(x, y, z, t) tmp = sqrt((z * 2.0)) * (((x * 0.5) - y) * (1.0 + (0.5 * (t * t)))); end
code[x_, y_, z_, t_] := N[(N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision] * N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[(1.0 + N[(0.5 * N[(t * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\sqrt{z \cdot 2} \cdot \left(\left(x \cdot 0.5 - y\right) \cdot \left(1 + 0.5 \cdot \left(t \cdot t\right)\right)\right)
\end{array}
Initial program 99.4%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in t around 0
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6488.6%
Simplified88.6%
Final simplification88.6%
(FPCore (x y z t) :precision binary64 (let* ((t_1 (sqrt (* z 2.0)))) (if (<= t 7.2e+54) (* t_1 (- (* x 0.5) y)) (* t_1 (* x (* (* t t) 0.25))))))
double code(double x, double y, double z, double t) {
double t_1 = sqrt((z * 2.0));
double tmp;
if (t <= 7.2e+54) {
tmp = t_1 * ((x * 0.5) - y);
} else {
tmp = t_1 * (x * ((t * t) * 0.25));
}
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) :: t_1
real(8) :: tmp
t_1 = sqrt((z * 2.0d0))
if (t <= 7.2d+54) then
tmp = t_1 * ((x * 0.5d0) - y)
else
tmp = t_1 * (x * ((t * t) * 0.25d0))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = Math.sqrt((z * 2.0));
double tmp;
if (t <= 7.2e+54) {
tmp = t_1 * ((x * 0.5) - y);
} else {
tmp = t_1 * (x * ((t * t) * 0.25));
}
return tmp;
}
def code(x, y, z, t): t_1 = math.sqrt((z * 2.0)) tmp = 0 if t <= 7.2e+54: tmp = t_1 * ((x * 0.5) - y) else: tmp = t_1 * (x * ((t * t) * 0.25)) return tmp
function code(x, y, z, t) t_1 = sqrt(Float64(z * 2.0)) tmp = 0.0 if (t <= 7.2e+54) tmp = Float64(t_1 * Float64(Float64(x * 0.5) - y)); else tmp = Float64(t_1 * Float64(x * Float64(Float64(t * t) * 0.25))); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = sqrt((z * 2.0)); tmp = 0.0; if (t <= 7.2e+54) tmp = t_1 * ((x * 0.5) - y); else tmp = t_1 * (x * ((t * t) * 0.25)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t, 7.2e+54], N[(t$95$1 * N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision]), $MachinePrecision], N[(t$95$1 * N[(x * N[(N[(t * t), $MachinePrecision] * 0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sqrt{z \cdot 2}\\
\mathbf{if}\;t \leq 7.2 \cdot 10^{+54}:\\
\;\;\;\;t\_1 \cdot \left(x \cdot 0.5 - y\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1 \cdot \left(x \cdot \left(\left(t \cdot t\right) \cdot 0.25\right)\right)\\
\end{array}
\end{array}
if t < 7.2000000000000003e54Initial program 99.8%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in t around 0
--lowering--.f64N/A
*-lowering-*.f6463.1%
Simplified63.1%
if 7.2000000000000003e54 < t Initial program 98.6%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in t around 0
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6489.0%
Simplified89.0%
Taylor expanded in t around inf
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6489.0%
Simplified89.0%
Taylor expanded in x around inf
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6462.8%
Simplified62.8%
Final simplification63.1%
(FPCore (x y z t) :precision binary64 (* (sqrt (* z 2.0)) (- (* x 0.5) y)))
double code(double x, double y, double z, double t) {
return sqrt((z * 2.0)) * ((x * 0.5) - 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 = sqrt((z * 2.0d0)) * ((x * 0.5d0) - y)
end function
public static double code(double x, double y, double z, double t) {
return Math.sqrt((z * 2.0)) * ((x * 0.5) - y);
}
def code(x, y, z, t): return math.sqrt((z * 2.0)) * ((x * 0.5) - y)
function code(x, y, z, t) return Float64(sqrt(Float64(z * 2.0)) * Float64(Float64(x * 0.5) - y)) end
function tmp = code(x, y, z, t) tmp = sqrt((z * 2.0)) * ((x * 0.5) - y); end
code[x_, y_, z_, t_] := N[(N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision] * N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\sqrt{z \cdot 2} \cdot \left(x \cdot 0.5 - y\right)
\end{array}
Initial program 99.4%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in t around 0
--lowering--.f64N/A
*-lowering-*.f6450.3%
Simplified50.3%
Final simplification50.3%
(FPCore (x y z t) :precision binary64 (* (sqrt (* z 2.0)) (- 0.0 y)))
double code(double x, double y, double z, double t) {
return sqrt((z * 2.0)) * (0.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 = sqrt((z * 2.0d0)) * (0.0d0 - y)
end function
public static double code(double x, double y, double z, double t) {
return Math.sqrt((z * 2.0)) * (0.0 - y);
}
def code(x, y, z, t): return math.sqrt((z * 2.0)) * (0.0 - y)
function code(x, y, z, t) return Float64(sqrt(Float64(z * 2.0)) * Float64(0.0 - y)) end
function tmp = code(x, y, z, t) tmp = sqrt((z * 2.0)) * (0.0 - y); end
code[x_, y_, z_, t_] := N[(N[Sqrt[N[(z * 2.0), $MachinePrecision]], $MachinePrecision] * N[(0.0 - y), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\sqrt{z \cdot 2} \cdot \left(0 - y\right)
\end{array}
Initial program 99.4%
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in t around 0
--lowering--.f64N/A
*-lowering-*.f6450.3%
Simplified50.3%
Taylor expanded in x around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f6425.9%
Simplified25.9%
sub0-negN/A
neg-lowering-neg.f6425.9%
Applied egg-rr25.9%
Final simplification25.9%
(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 2024130
(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))))