
(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 11 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 (* (- (* x 0.5) y) (sqrt (* 2.0 (* z (exp (* t t)))))))
double code(double x, double y, double z, double t) {
return ((x * 0.5) - y) * sqrt((2.0 * (z * 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((2.0d0 * (z * exp((t * t)))))
end function
public static double code(double x, double y, double z, double t) {
return ((x * 0.5) - y) * Math.sqrt((2.0 * (z * Math.exp((t * t)))));
}
def code(x, y, z, t): return ((x * 0.5) - y) * math.sqrt((2.0 * (z * math.exp((t * t)))))
function code(x, y, z, t) return Float64(Float64(Float64(x * 0.5) - y) * sqrt(Float64(2.0 * Float64(z * exp(Float64(t * t)))))) end
function tmp = code(x, y, z, t) tmp = ((x * 0.5) - y) * sqrt((2.0 * (z * exp((t * t))))); end
code[x_, y_, z_, t_] := N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[Sqrt[N[(2.0 * N[(z * N[Exp[N[(t * t), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot 0.5 - y\right) \cdot \sqrt{2 \cdot \left(z \cdot e^{t \cdot t}\right)}
\end{array}
Initial program 99.0%
associate-*l*99.8%
exp-sqrt99.8%
Simplified99.8%
expm1-log1p-u98.5%
expm1-udef70.5%
sqrt-unprod70.5%
associate-*l*70.5%
exp-prod70.5%
Applied egg-rr70.5%
expm1-def98.5%
expm1-log1p99.8%
*-commutative99.8%
associate-*l*99.8%
*-commutative99.8%
exp-prod99.8%
Simplified99.8%
Final simplification99.8%
(FPCore (x y z t) :precision binary64 (if (or (<= (* t t) 0.0145) (not (<= (* t t) 1.58e+308))) (* (- (* x 0.5) y) (sqrt (* 2.0 (* z (+ (* t t) 1.0))))) (* (exp (/ (* t t) 2.0)) (* y (- (sqrt (* 2.0 z)))))))
double code(double x, double y, double z, double t) {
double tmp;
if (((t * t) <= 0.0145) || !((t * t) <= 1.58e+308)) {
tmp = ((x * 0.5) - y) * sqrt((2.0 * (z * ((t * t) + 1.0))));
} else {
tmp = exp(((t * t) / 2.0)) * (y * -sqrt((2.0 * 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 (((t * t) <= 0.0145d0) .or. (.not. ((t * t) <= 1.58d+308))) then
tmp = ((x * 0.5d0) - y) * sqrt((2.0d0 * (z * ((t * t) + 1.0d0))))
else
tmp = exp(((t * t) / 2.0d0)) * (y * -sqrt((2.0d0 * z)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (((t * t) <= 0.0145) || !((t * t) <= 1.58e+308)) {
tmp = ((x * 0.5) - y) * Math.sqrt((2.0 * (z * ((t * t) + 1.0))));
} else {
tmp = Math.exp(((t * t) / 2.0)) * (y * -Math.sqrt((2.0 * z)));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if ((t * t) <= 0.0145) or not ((t * t) <= 1.58e+308): tmp = ((x * 0.5) - y) * math.sqrt((2.0 * (z * ((t * t) + 1.0)))) else: tmp = math.exp(((t * t) / 2.0)) * (y * -math.sqrt((2.0 * z))) return tmp
function code(x, y, z, t) tmp = 0.0 if ((Float64(t * t) <= 0.0145) || !(Float64(t * t) <= 1.58e+308)) tmp = Float64(Float64(Float64(x * 0.5) - y) * sqrt(Float64(2.0 * Float64(z * Float64(Float64(t * t) + 1.0))))); else tmp = Float64(exp(Float64(Float64(t * t) / 2.0)) * Float64(y * Float64(-sqrt(Float64(2.0 * z))))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (((t * t) <= 0.0145) || ~(((t * t) <= 1.58e+308))) tmp = ((x * 0.5) - y) * sqrt((2.0 * (z * ((t * t) + 1.0)))); else tmp = exp(((t * t) / 2.0)) * (y * -sqrt((2.0 * z))); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[N[(t * t), $MachinePrecision], 0.0145], N[Not[LessEqual[N[(t * t), $MachinePrecision], 1.58e+308]], $MachinePrecision]], N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[Sqrt[N[(2.0 * N[(z * N[(N[(t * t), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[Exp[N[(N[(t * t), $MachinePrecision] / 2.0), $MachinePrecision]], $MachinePrecision] * N[(y * (-N[Sqrt[N[(2.0 * z), $MachinePrecision]], $MachinePrecision])), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \cdot t \leq 0.0145 \lor \neg \left(t \cdot t \leq 1.58 \cdot 10^{+308}\right):\\
\;\;\;\;\left(x \cdot 0.5 - y\right) \cdot \sqrt{2 \cdot \left(z \cdot \left(t \cdot t + 1\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;e^{\frac{t \cdot t}{2}} \cdot \left(y \cdot \left(-\sqrt{2 \cdot z}\right)\right)\\
\end{array}
\end{array}
if (*.f64 t t) < 0.0145000000000000007 or 1.5799999999999999e308 < (*.f64 t t) Initial program 99.3%
associate-*l*99.7%
exp-sqrt99.7%
Simplified99.7%
expm1-log1p-u98.0%
expm1-udef62.5%
sqrt-unprod62.5%
associate-*l*62.5%
exp-prod62.5%
Applied egg-rr62.5%
expm1-def98.0%
expm1-log1p99.8%
*-commutative99.8%
associate-*l*99.8%
*-commutative99.8%
exp-prod99.8%
Simplified99.8%
Taylor expanded in t around 0 99.7%
unpow299.7%
Simplified99.7%
if 0.0145000000000000007 < (*.f64 t t) < 1.5799999999999999e308Initial program 98.2%
add-sqr-sqrt56.1%
sqrt-unprod52.6%
*-commutative52.6%
*-commutative52.6%
swap-sqr51.0%
add-sqr-sqrt51.0%
pow251.0%
Applied egg-rr51.0%
pow1/251.0%
*-commutative51.0%
unpow-prod-down51.0%
pow1/251.0%
unpow251.0%
sqrt-prod56.1%
add-sqr-sqrt98.2%
metadata-eval98.2%
pow-pow98.2%
unpow298.2%
associate-*r*98.2%
*-commutative98.2%
*-commutative98.2%
Applied egg-rr98.2%
Taylor expanded in x around 0 73.7%
mul-1-neg73.7%
*-commutative73.7%
associate-*l*73.7%
unpow1/273.7%
metadata-eval73.7%
pow-sqr73.7%
unpow1/273.7%
metadata-eval73.7%
pow-sqr73.7%
swap-sqr73.7%
exp-to-pow73.7%
exp-to-pow73.6%
exp-sum73.6%
distribute-rgt-in73.6%
log-prod73.6%
log-pow73.6%
rem-exp-log73.7%
exp-to-pow73.7%
exp-to-pow73.6%
exp-sum73.6%
Simplified73.7%
Final simplification93.9%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (- (* x 0.5) y)))
(if (or (<= t -1.2e+26) (not (<= t 310000000.0)))
(* t_1 (pow (* 4.0 (* z z)) 0.25))
(* t_1 (sqrt (* 2.0 z))))))
double code(double x, double y, double z, double t) {
double t_1 = (x * 0.5) - y;
double tmp;
if ((t <= -1.2e+26) || !(t <= 310000000.0)) {
tmp = t_1 * pow((4.0 * (z * z)), 0.25);
} else {
tmp = t_1 * sqrt((2.0 * 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) :: t_1
real(8) :: tmp
t_1 = (x * 0.5d0) - y
if ((t <= (-1.2d+26)) .or. (.not. (t <= 310000000.0d0))) then
tmp = t_1 * ((4.0d0 * (z * z)) ** 0.25d0)
else
tmp = t_1 * sqrt((2.0d0 * z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = (x * 0.5) - y;
double tmp;
if ((t <= -1.2e+26) || !(t <= 310000000.0)) {
tmp = t_1 * Math.pow((4.0 * (z * z)), 0.25);
} else {
tmp = t_1 * Math.sqrt((2.0 * z));
}
return tmp;
}
def code(x, y, z, t): t_1 = (x * 0.5) - y tmp = 0 if (t <= -1.2e+26) or not (t <= 310000000.0): tmp = t_1 * math.pow((4.0 * (z * z)), 0.25) else: tmp = t_1 * math.sqrt((2.0 * z)) return tmp
function code(x, y, z, t) t_1 = Float64(Float64(x * 0.5) - y) tmp = 0.0 if ((t <= -1.2e+26) || !(t <= 310000000.0)) tmp = Float64(t_1 * (Float64(4.0 * Float64(z * z)) ^ 0.25)); else tmp = Float64(t_1 * sqrt(Float64(2.0 * z))); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = (x * 0.5) - y; tmp = 0.0; if ((t <= -1.2e+26) || ~((t <= 310000000.0))) tmp = t_1 * ((4.0 * (z * z)) ^ 0.25); else tmp = t_1 * sqrt((2.0 * z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision]}, If[Or[LessEqual[t, -1.2e+26], N[Not[LessEqual[t, 310000000.0]], $MachinePrecision]], N[(t$95$1 * N[Power[N[(4.0 * N[(z * z), $MachinePrecision]), $MachinePrecision], 0.25], $MachinePrecision]), $MachinePrecision], N[(t$95$1 * N[Sqrt[N[(2.0 * z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot 0.5 - y\\
\mathbf{if}\;t \leq -1.2 \cdot 10^{+26} \lor \neg \left(t \leq 310000000\right):\\
\;\;\;\;t_1 \cdot {\left(4 \cdot \left(z \cdot z\right)\right)}^{0.25}\\
\mathbf{else}:\\
\;\;\;\;t_1 \cdot \sqrt{2 \cdot z}\\
\end{array}
\end{array}
if t < -1.20000000000000002e26 or 3.1e8 < t Initial program 98.2%
associate-*l*100.0%
exp-sqrt100.0%
Simplified100.0%
Taylor expanded in t around 0 20.1%
*-commutative20.1%
sqrt-prod20.1%
pow1/220.1%
metadata-eval20.1%
pow-prod-up20.1%
pow-prod-down40.6%
*-commutative40.6%
*-commutative40.6%
swap-sqr40.6%
metadata-eval40.6%
Applied egg-rr40.6%
if -1.20000000000000002e26 < t < 3.1e8Initial program 99.7%
associate-*l*99.6%
exp-sqrt99.6%
Simplified99.6%
expm1-log1p-u97.3%
expm1-udef48.6%
sqrt-unprod48.6%
associate-*l*48.6%
exp-prod48.6%
Applied egg-rr48.6%
expm1-def97.3%
expm1-log1p99.7%
*-commutative99.7%
associate-*l*99.7%
*-commutative99.7%
exp-prod99.7%
Simplified99.7%
Taylor expanded in t around 0 94.9%
unpow1/294.9%
metadata-eval94.9%
pow-sqr94.9%
unpow1/294.9%
metadata-eval94.9%
pow-sqr94.8%
swap-sqr94.6%
exp-to-pow94.6%
exp-to-pow90.5%
exp-sum90.2%
distribute-rgt-in90.2%
log-prod90.6%
*-commutative90.6%
exp-to-pow94.9%
exp-to-pow94.9%
exp-to-pow90.5%
exp-sum90.3%
distribute-rgt-in90.3%
log-prod90.6%
*-commutative90.6%
exp-to-pow94.8%
Simplified95.3%
Final simplification72.0%
(FPCore (x y z t) :precision binary64 (* (- (* x 0.5) y) (sqrt (* 2.0 (* z (+ (* t t) 1.0))))))
double code(double x, double y, double z, double t) {
return ((x * 0.5) - y) * sqrt((2.0 * (z * ((t * t) + 1.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((2.0d0 * (z * ((t * t) + 1.0d0))))
end function
public static double code(double x, double y, double z, double t) {
return ((x * 0.5) - y) * Math.sqrt((2.0 * (z * ((t * t) + 1.0))));
}
def code(x, y, z, t): return ((x * 0.5) - y) * math.sqrt((2.0 * (z * ((t * t) + 1.0))))
function code(x, y, z, t) return Float64(Float64(Float64(x * 0.5) - y) * sqrt(Float64(2.0 * Float64(z * Float64(Float64(t * t) + 1.0))))) end
function tmp = code(x, y, z, t) tmp = ((x * 0.5) - y) * sqrt((2.0 * (z * ((t * t) + 1.0)))); end
code[x_, y_, z_, t_] := N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[Sqrt[N[(2.0 * N[(z * N[(N[(t * t), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot 0.5 - y\right) \cdot \sqrt{2 \cdot \left(z \cdot \left(t \cdot t + 1\right)\right)}
\end{array}
Initial program 99.0%
associate-*l*99.8%
exp-sqrt99.8%
Simplified99.8%
expm1-log1p-u98.5%
expm1-udef70.5%
sqrt-unprod70.5%
associate-*l*70.5%
exp-prod70.5%
Applied egg-rr70.5%
expm1-def98.5%
expm1-log1p99.8%
*-commutative99.8%
associate-*l*99.8%
*-commutative99.8%
exp-prod99.8%
Simplified99.8%
Taylor expanded in t around 0 89.1%
unpow289.1%
Simplified89.1%
Final simplification89.1%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (* x (sqrt (* 0.5 z)))))
(if (<= x -86000000.0)
t_1
(if (<= x 5.5e-65)
(* y (- (sqrt (* 2.0 z))))
(if (<= x 1.1e+221) (sqrt (* (* x 0.5) (* x z))) t_1)))))
double code(double x, double y, double z, double t) {
double t_1 = x * sqrt((0.5 * z));
double tmp;
if (x <= -86000000.0) {
tmp = t_1;
} else if (x <= 5.5e-65) {
tmp = y * -sqrt((2.0 * z));
} else if (x <= 1.1e+221) {
tmp = sqrt(((x * 0.5) * (x * z)));
} else {
tmp = t_1;
}
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 = x * sqrt((0.5d0 * z))
if (x <= (-86000000.0d0)) then
tmp = t_1
else if (x <= 5.5d-65) then
tmp = y * -sqrt((2.0d0 * z))
else if (x <= 1.1d+221) then
tmp = sqrt(((x * 0.5d0) * (x * z)))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = x * Math.sqrt((0.5 * z));
double tmp;
if (x <= -86000000.0) {
tmp = t_1;
} else if (x <= 5.5e-65) {
tmp = y * -Math.sqrt((2.0 * z));
} else if (x <= 1.1e+221) {
tmp = Math.sqrt(((x * 0.5) * (x * z)));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t): t_1 = x * math.sqrt((0.5 * z)) tmp = 0 if x <= -86000000.0: tmp = t_1 elif x <= 5.5e-65: tmp = y * -math.sqrt((2.0 * z)) elif x <= 1.1e+221: tmp = math.sqrt(((x * 0.5) * (x * z))) else: tmp = t_1 return tmp
function code(x, y, z, t) t_1 = Float64(x * sqrt(Float64(0.5 * z))) tmp = 0.0 if (x <= -86000000.0) tmp = t_1; elseif (x <= 5.5e-65) tmp = Float64(y * Float64(-sqrt(Float64(2.0 * z)))); elseif (x <= 1.1e+221) tmp = sqrt(Float64(Float64(x * 0.5) * Float64(x * z))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = x * sqrt((0.5 * z)); tmp = 0.0; if (x <= -86000000.0) tmp = t_1; elseif (x <= 5.5e-65) tmp = y * -sqrt((2.0 * z)); elseif (x <= 1.1e+221) tmp = sqrt(((x * 0.5) * (x * z))); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(x * N[Sqrt[N[(0.5 * z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -86000000.0], t$95$1, If[LessEqual[x, 5.5e-65], N[(y * (-N[Sqrt[N[(2.0 * z), $MachinePrecision]], $MachinePrecision])), $MachinePrecision], If[LessEqual[x, 1.1e+221], N[Sqrt[N[(N[(x * 0.5), $MachinePrecision] * N[(x * z), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \sqrt{0.5 \cdot z}\\
\mathbf{if}\;x \leq -86000000:\\
\;\;\;\;t_1\\
\mathbf{elif}\;x \leq 5.5 \cdot 10^{-65}:\\
\;\;\;\;y \cdot \left(-\sqrt{2 \cdot z}\right)\\
\mathbf{elif}\;x \leq 1.1 \cdot 10^{+221}:\\
\;\;\;\;\sqrt{\left(x \cdot 0.5\right) \cdot \left(x \cdot z\right)}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if x < -8.6e7 or 1.1e221 < x Initial program 99.7%
Taylor expanded in t around 0 81.0%
associate-*l*81.0%
Simplified81.0%
Taylor expanded in x around inf 66.5%
associate-*r*66.5%
Simplified66.5%
add-sqr-sqrt16.6%
sqrt-unprod14.0%
*-commutative14.0%
*-commutative14.0%
swap-sqr11.5%
add-sqr-sqrt11.5%
swap-sqr11.5%
metadata-eval11.5%
swap-sqr11.5%
add-sqr-sqrt11.5%
Applied egg-rr11.5%
associate-*r*11.5%
metadata-eval11.5%
associate-*r*11.5%
Simplified11.5%
sqrt-unprod11.5%
sqrt-prod16.7%
add-sqr-sqrt66.7%
Applied egg-rr66.7%
if -8.6e7 < x < 5.4999999999999999e-65Initial program 98.1%
Taylor expanded in t around 0 56.1%
associate-*l*56.1%
Simplified56.1%
Taylor expanded in x around 0 43.3%
mul-1-neg43.3%
distribute-lft-neg-out43.3%
*-commutative43.3%
Simplified43.3%
associate-*r*43.3%
sqrt-prod43.5%
distribute-rgt-neg-out43.5%
Applied egg-rr43.5%
if 5.4999999999999999e-65 < x < 1.1e221Initial program 99.8%
Taylor expanded in t around 0 53.5%
associate-*l*53.5%
Simplified53.5%
Taylor expanded in x around inf 39.3%
associate-*r*39.3%
Simplified39.3%
add-sqr-sqrt39.2%
sqrt-unprod57.7%
*-commutative57.7%
*-commutative57.7%
swap-sqr57.8%
add-sqr-sqrt57.8%
swap-sqr57.8%
metadata-eval57.8%
swap-sqr57.8%
add-sqr-sqrt57.9%
Applied egg-rr57.9%
associate-*r*57.9%
metadata-eval57.9%
associate-*r*57.9%
Simplified57.9%
Taylor expanded in z around 0 57.9%
unpow257.9%
*-commutative57.9%
associate-*r*57.9%
associate-*r*57.9%
associate-*l*57.9%
*-commutative57.9%
Simplified57.9%
Final simplification54.3%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (* x (sqrt (* 0.5 z)))))
(if (<= x -40000000.0)
t_1
(if (<= x 4e-62)
(* y (- (sqrt (* 2.0 z))))
(if (<= x 2e+213) (sqrt (* (* 0.5 z) (* x x))) t_1)))))
double code(double x, double y, double z, double t) {
double t_1 = x * sqrt((0.5 * z));
double tmp;
if (x <= -40000000.0) {
tmp = t_1;
} else if (x <= 4e-62) {
tmp = y * -sqrt((2.0 * z));
} else if (x <= 2e+213) {
tmp = sqrt(((0.5 * z) * (x * x)));
} else {
tmp = t_1;
}
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 = x * sqrt((0.5d0 * z))
if (x <= (-40000000.0d0)) then
tmp = t_1
else if (x <= 4d-62) then
tmp = y * -sqrt((2.0d0 * z))
else if (x <= 2d+213) then
tmp = sqrt(((0.5d0 * z) * (x * x)))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = x * Math.sqrt((0.5 * z));
double tmp;
if (x <= -40000000.0) {
tmp = t_1;
} else if (x <= 4e-62) {
tmp = y * -Math.sqrt((2.0 * z));
} else if (x <= 2e+213) {
tmp = Math.sqrt(((0.5 * z) * (x * x)));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t): t_1 = x * math.sqrt((0.5 * z)) tmp = 0 if x <= -40000000.0: tmp = t_1 elif x <= 4e-62: tmp = y * -math.sqrt((2.0 * z)) elif x <= 2e+213: tmp = math.sqrt(((0.5 * z) * (x * x))) else: tmp = t_1 return tmp
function code(x, y, z, t) t_1 = Float64(x * sqrt(Float64(0.5 * z))) tmp = 0.0 if (x <= -40000000.0) tmp = t_1; elseif (x <= 4e-62) tmp = Float64(y * Float64(-sqrt(Float64(2.0 * z)))); elseif (x <= 2e+213) tmp = sqrt(Float64(Float64(0.5 * z) * Float64(x * x))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = x * sqrt((0.5 * z)); tmp = 0.0; if (x <= -40000000.0) tmp = t_1; elseif (x <= 4e-62) tmp = y * -sqrt((2.0 * z)); elseif (x <= 2e+213) tmp = sqrt(((0.5 * z) * (x * x))); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(x * N[Sqrt[N[(0.5 * z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -40000000.0], t$95$1, If[LessEqual[x, 4e-62], N[(y * (-N[Sqrt[N[(2.0 * z), $MachinePrecision]], $MachinePrecision])), $MachinePrecision], If[LessEqual[x, 2e+213], N[Sqrt[N[(N[(0.5 * z), $MachinePrecision] * N[(x * x), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \sqrt{0.5 \cdot z}\\
\mathbf{if}\;x \leq -40000000:\\
\;\;\;\;t_1\\
\mathbf{elif}\;x \leq 4 \cdot 10^{-62}:\\
\;\;\;\;y \cdot \left(-\sqrt{2 \cdot z}\right)\\
\mathbf{elif}\;x \leq 2 \cdot 10^{+213}:\\
\;\;\;\;\sqrt{\left(0.5 \cdot z\right) \cdot \left(x \cdot x\right)}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if x < -4e7 or 1.99999999999999997e213 < x Initial program 99.7%
Taylor expanded in t around 0 80.3%
associate-*l*80.2%
Simplified80.2%
Taylor expanded in x around inf 66.2%
associate-*r*66.2%
Simplified66.2%
add-sqr-sqrt17.5%
sqrt-unprod16.1%
*-commutative16.1%
*-commutative16.1%
swap-sqr12.5%
add-sqr-sqrt12.5%
swap-sqr12.5%
metadata-eval12.5%
swap-sqr12.5%
add-sqr-sqrt12.5%
Applied egg-rr12.5%
associate-*r*12.5%
metadata-eval12.5%
associate-*r*12.5%
Simplified12.5%
sqrt-unprod12.5%
sqrt-prod17.6%
add-sqr-sqrt66.3%
Applied egg-rr66.3%
if -4e7 < x < 4.0000000000000002e-62Initial program 98.1%
Taylor expanded in t around 0 56.1%
associate-*l*56.1%
Simplified56.1%
Taylor expanded in x around 0 43.3%
mul-1-neg43.3%
distribute-lft-neg-out43.3%
*-commutative43.3%
Simplified43.3%
associate-*r*43.3%
sqrt-prod43.5%
distribute-rgt-neg-out43.5%
Applied egg-rr43.5%
if 4.0000000000000002e-62 < x < 1.99999999999999997e213Initial program 99.8%
Taylor expanded in t around 0 53.5%
associate-*l*53.6%
Simplified53.6%
Taylor expanded in x around inf 38.9%
associate-*r*38.9%
Simplified38.9%
add-sqr-sqrt38.8%
sqrt-unprod56.4%
*-commutative56.4%
*-commutative56.4%
swap-sqr58.0%
add-sqr-sqrt58.0%
swap-sqr58.0%
metadata-eval58.0%
swap-sqr57.9%
add-sqr-sqrt58.1%
Applied egg-rr58.1%
associate-*r*58.1%
metadata-eval58.1%
associate-*r*58.1%
Simplified58.1%
Final simplification54.3%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (* y (- (sqrt (* 2.0 z))))))
(if (<= y -5e+140)
t_1
(if (<= y -9.5e-43)
(sqrt (* 2.0 (* y (* y z))))
(if (<= y 4.5e+110) (* x (sqrt (* 0.5 z))) t_1)))))
double code(double x, double y, double z, double t) {
double t_1 = y * -sqrt((2.0 * z));
double tmp;
if (y <= -5e+140) {
tmp = t_1;
} else if (y <= -9.5e-43) {
tmp = sqrt((2.0 * (y * (y * z))));
} else if (y <= 4.5e+110) {
tmp = x * sqrt((0.5 * z));
} else {
tmp = t_1;
}
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 = y * -sqrt((2.0d0 * z))
if (y <= (-5d+140)) then
tmp = t_1
else if (y <= (-9.5d-43)) then
tmp = sqrt((2.0d0 * (y * (y * z))))
else if (y <= 4.5d+110) then
tmp = x * sqrt((0.5d0 * z))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = y * -Math.sqrt((2.0 * z));
double tmp;
if (y <= -5e+140) {
tmp = t_1;
} else if (y <= -9.5e-43) {
tmp = Math.sqrt((2.0 * (y * (y * z))));
} else if (y <= 4.5e+110) {
tmp = x * Math.sqrt((0.5 * z));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t): t_1 = y * -math.sqrt((2.0 * z)) tmp = 0 if y <= -5e+140: tmp = t_1 elif y <= -9.5e-43: tmp = math.sqrt((2.0 * (y * (y * z)))) elif y <= 4.5e+110: tmp = x * math.sqrt((0.5 * z)) else: tmp = t_1 return tmp
function code(x, y, z, t) t_1 = Float64(y * Float64(-sqrt(Float64(2.0 * z)))) tmp = 0.0 if (y <= -5e+140) tmp = t_1; elseif (y <= -9.5e-43) tmp = sqrt(Float64(2.0 * Float64(y * Float64(y * z)))); elseif (y <= 4.5e+110) tmp = Float64(x * sqrt(Float64(0.5 * z))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = y * -sqrt((2.0 * z)); tmp = 0.0; if (y <= -5e+140) tmp = t_1; elseif (y <= -9.5e-43) tmp = sqrt((2.0 * (y * (y * z)))); elseif (y <= 4.5e+110) tmp = x * sqrt((0.5 * z)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(y * (-N[Sqrt[N[(2.0 * z), $MachinePrecision]], $MachinePrecision])), $MachinePrecision]}, If[LessEqual[y, -5e+140], t$95$1, If[LessEqual[y, -9.5e-43], N[Sqrt[N[(2.0 * N[(y * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[y, 4.5e+110], N[(x * N[Sqrt[N[(0.5 * z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(-\sqrt{2 \cdot z}\right)\\
\mathbf{if}\;y \leq -5 \cdot 10^{+140}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -9.5 \cdot 10^{-43}:\\
\;\;\;\;\sqrt{2 \cdot \left(y \cdot \left(y \cdot z\right)\right)}\\
\mathbf{elif}\;y \leq 4.5 \cdot 10^{+110}:\\
\;\;\;\;x \cdot \sqrt{0.5 \cdot z}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if y < -5.00000000000000008e140 or 4.5000000000000003e110 < y Initial program 99.8%
Taylor expanded in t around 0 73.4%
associate-*l*73.4%
Simplified73.4%
Taylor expanded in x around 0 58.9%
mul-1-neg58.9%
distribute-lft-neg-out58.9%
*-commutative58.9%
Simplified58.9%
associate-*r*58.8%
sqrt-prod59.0%
distribute-rgt-neg-out59.0%
Applied egg-rr59.0%
if -5.00000000000000008e140 < y < -9.50000000000000044e-43Initial program 99.8%
Taylor expanded in t around 0 53.4%
associate-*l*53.6%
Simplified53.6%
Taylor expanded in x around 0 35.0%
mul-1-neg35.0%
distribute-lft-neg-out35.0%
*-commutative35.0%
Simplified35.0%
add-sqr-sqrt34.9%
sqrt-unprod47.8%
associate-*r*47.7%
sqrt-prod47.8%
associate-*r*47.8%
sqrt-prod47.8%
swap-sqr47.7%
add-sqr-sqrt47.7%
sqr-neg47.7%
Applied egg-rr47.7%
associate-*l*47.7%
*-commutative47.7%
associate-*l*47.8%
Simplified47.8%
if -9.50000000000000044e-43 < y < 4.5000000000000003e110Initial program 98.5%
Taylor expanded in t around 0 60.3%
associate-*l*60.3%
Simplified60.3%
Taylor expanded in x around inf 50.0%
associate-*r*50.0%
Simplified50.0%
add-sqr-sqrt24.6%
sqrt-unprod25.9%
*-commutative25.9%
*-commutative25.9%
swap-sqr23.9%
add-sqr-sqrt23.9%
swap-sqr23.9%
metadata-eval23.9%
swap-sqr23.9%
add-sqr-sqrt24.0%
Applied egg-rr24.0%
associate-*r*24.0%
metadata-eval24.0%
associate-*r*24.0%
Simplified24.0%
sqrt-unprod23.3%
sqrt-prod24.6%
add-sqr-sqrt50.2%
Applied egg-rr50.2%
Final simplification52.3%
(FPCore (x y z t) :precision binary64 (if (or (<= y -9.5e-43) (not (<= y 3.1e+112))) (* y (- (sqrt (* 2.0 z)))) (* x (sqrt (* 0.5 z)))))
double code(double x, double y, double z, double t) {
double tmp;
if ((y <= -9.5e-43) || !(y <= 3.1e+112)) {
tmp = y * -sqrt((2.0 * z));
} else {
tmp = x * sqrt((0.5 * 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 ((y <= (-9.5d-43)) .or. (.not. (y <= 3.1d+112))) then
tmp = y * -sqrt((2.0d0 * z))
else
tmp = x * sqrt((0.5d0 * z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if ((y <= -9.5e-43) || !(y <= 3.1e+112)) {
tmp = y * -Math.sqrt((2.0 * z));
} else {
tmp = x * Math.sqrt((0.5 * z));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (y <= -9.5e-43) or not (y <= 3.1e+112): tmp = y * -math.sqrt((2.0 * z)) else: tmp = x * math.sqrt((0.5 * z)) return tmp
function code(x, y, z, t) tmp = 0.0 if ((y <= -9.5e-43) || !(y <= 3.1e+112)) tmp = Float64(y * Float64(-sqrt(Float64(2.0 * z)))); else tmp = Float64(x * sqrt(Float64(0.5 * z))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((y <= -9.5e-43) || ~((y <= 3.1e+112))) tmp = y * -sqrt((2.0 * z)); else tmp = x * sqrt((0.5 * z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[y, -9.5e-43], N[Not[LessEqual[y, 3.1e+112]], $MachinePrecision]], N[(y * (-N[Sqrt[N[(2.0 * z), $MachinePrecision]], $MachinePrecision])), $MachinePrecision], N[(x * N[Sqrt[N[(0.5 * z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -9.5 \cdot 10^{-43} \lor \neg \left(y \leq 3.1 \cdot 10^{+112}\right):\\
\;\;\;\;y \cdot \left(-\sqrt{2 \cdot z}\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \sqrt{0.5 \cdot z}\\
\end{array}
\end{array}
if y < -9.50000000000000044e-43 or 3.09999999999999983e112 < y Initial program 99.8%
Taylor expanded in t around 0 66.6%
associate-*l*66.7%
Simplified66.7%
Taylor expanded in x around 0 50.7%
mul-1-neg50.7%
distribute-lft-neg-out50.7%
*-commutative50.7%
Simplified50.7%
associate-*r*50.7%
sqrt-prod50.9%
distribute-rgt-neg-out50.9%
Applied egg-rr50.9%
if -9.50000000000000044e-43 < y < 3.09999999999999983e112Initial program 98.5%
Taylor expanded in t around 0 60.3%
associate-*l*60.3%
Simplified60.3%
Taylor expanded in x around inf 50.0%
associate-*r*50.0%
Simplified50.0%
add-sqr-sqrt24.6%
sqrt-unprod25.9%
*-commutative25.9%
*-commutative25.9%
swap-sqr23.9%
add-sqr-sqrt23.9%
swap-sqr23.9%
metadata-eval23.9%
swap-sqr23.9%
add-sqr-sqrt24.0%
Applied egg-rr24.0%
associate-*r*24.0%
metadata-eval24.0%
associate-*r*24.0%
Simplified24.0%
sqrt-unprod23.3%
sqrt-prod24.6%
add-sqr-sqrt50.2%
Applied egg-rr50.2%
Final simplification50.5%
(FPCore (x y z t) :precision binary64 (* (- (* x 0.5) y) (sqrt (* 2.0 z))))
double code(double x, double y, double z, double t) {
return ((x * 0.5) - y) * sqrt((2.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 * 0.5d0) - y) * sqrt((2.0d0 * z))
end function
public static double code(double x, double y, double z, double t) {
return ((x * 0.5) - y) * Math.sqrt((2.0 * z));
}
def code(x, y, z, t): return ((x * 0.5) - y) * math.sqrt((2.0 * z))
function code(x, y, z, t) return Float64(Float64(Float64(x * 0.5) - y) * sqrt(Float64(2.0 * z))) end
function tmp = code(x, y, z, t) tmp = ((x * 0.5) - y) * sqrt((2.0 * z)); end
code[x_, y_, z_, t_] := N[(N[(N[(x * 0.5), $MachinePrecision] - y), $MachinePrecision] * N[Sqrt[N[(2.0 * z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot 0.5 - y\right) \cdot \sqrt{2 \cdot z}
\end{array}
Initial program 99.0%
associate-*l*99.8%
exp-sqrt99.8%
Simplified99.8%
expm1-log1p-u98.5%
expm1-udef70.5%
sqrt-unprod70.5%
associate-*l*70.5%
exp-prod70.5%
Applied egg-rr70.5%
expm1-def98.5%
expm1-log1p99.8%
*-commutative99.8%
associate-*l*99.8%
*-commutative99.8%
exp-prod99.8%
Simplified99.8%
Taylor expanded in t around 0 63.0%
unpow1/263.0%
metadata-eval63.0%
pow-sqr63.1%
unpow1/263.0%
metadata-eval63.0%
pow-sqr63.0%
swap-sqr62.9%
exp-to-pow62.9%
exp-to-pow60.5%
exp-sum60.4%
distribute-rgt-in60.4%
log-prod60.6%
*-commutative60.6%
exp-to-pow63.0%
exp-to-pow63.0%
exp-to-pow60.5%
exp-sum60.4%
distribute-rgt-in60.4%
log-prod60.6%
*-commutative60.6%
exp-to-pow63.0%
Simplified63.2%
Final simplification63.2%
(FPCore (x y z t) :precision binary64 (* y (sqrt (* 2.0 z))))
double code(double x, double y, double z, double t) {
return y * sqrt((2.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 = y * sqrt((2.0d0 * z))
end function
public static double code(double x, double y, double z, double t) {
return y * Math.sqrt((2.0 * z));
}
def code(x, y, z, t): return y * math.sqrt((2.0 * z))
function code(x, y, z, t) return Float64(y * sqrt(Float64(2.0 * z))) end
function tmp = code(x, y, z, t) tmp = y * sqrt((2.0 * z)); end
code[x_, y_, z_, t_] := N[(y * N[Sqrt[N[(2.0 * z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
y \cdot \sqrt{2 \cdot z}
\end{array}
Initial program 99.0%
Taylor expanded in t around 0 63.0%
associate-*l*63.0%
Simplified63.0%
Taylor expanded in x around 0 28.2%
mul-1-neg28.2%
distribute-lft-neg-out28.2%
*-commutative28.2%
Simplified28.2%
expm1-log1p-u18.4%
expm1-udef14.2%
associate-*r*14.2%
sqrt-prod14.2%
add-sqr-sqrt12.9%
sqrt-unprod12.1%
sqr-neg12.1%
sqrt-unprod1.3%
add-sqr-sqrt2.0%
Applied egg-rr2.0%
expm1-def2.1%
expm1-log1p2.4%
*-commutative2.4%
Simplified2.4%
Final simplification2.4%
(FPCore (x y z t) :precision binary64 (* x (sqrt (* 0.5 z))))
double code(double x, double y, double z, double t) {
return x * sqrt((0.5 * 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 * sqrt((0.5d0 * z))
end function
public static double code(double x, double y, double z, double t) {
return x * Math.sqrt((0.5 * z));
}
def code(x, y, z, t): return x * math.sqrt((0.5 * z))
function code(x, y, z, t) return Float64(x * sqrt(Float64(0.5 * z))) end
function tmp = code(x, y, z, t) tmp = x * sqrt((0.5 * z)); end
code[x_, y_, z_, t_] := N[(x * N[Sqrt[N[(0.5 * z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot \sqrt{0.5 \cdot z}
\end{array}
Initial program 99.0%
Taylor expanded in t around 0 63.0%
associate-*l*63.0%
Simplified63.0%
Taylor expanded in x around inf 36.5%
associate-*r*36.5%
Simplified36.5%
add-sqr-sqrt18.0%
sqrt-unprod21.7%
*-commutative21.7%
*-commutative21.7%
swap-sqr20.2%
add-sqr-sqrt20.2%
swap-sqr20.2%
metadata-eval20.2%
swap-sqr20.2%
add-sqr-sqrt20.2%
Applied egg-rr20.2%
associate-*r*20.2%
metadata-eval20.2%
associate-*r*20.2%
Simplified20.2%
sqrt-unprod18.4%
sqrt-prod18.0%
add-sqr-sqrt36.6%
Applied egg-rr36.6%
Final simplification36.6%
(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 2023196
(FPCore (x y z t)
:name "Data.Number.Erf:$cinvnormcdf from erf-2.0.0.0, A"
:precision binary64
:herbie-target
(* (* (- (* x 0.5) y) (sqrt (* z 2.0))) (pow (exp 1.0) (/ (* t t) 2.0)))
(* (* (- (* x 0.5) y) (sqrt (* z 2.0))) (exp (/ (* t t) 2.0))))