
(FPCore (a1 a2 th) :precision binary64 (let* ((t_1 (/ (cos th) (sqrt 2.0)))) (+ (* t_1 (* a1 a1)) (* t_1 (* a2 a2)))))
double code(double a1, double a2, double th) {
double t_1 = cos(th) / sqrt(2.0);
return (t_1 * (a1 * a1)) + (t_1 * (a2 * a2));
}
real(8) function code(a1, a2, th)
real(8), intent (in) :: a1
real(8), intent (in) :: a2
real(8), intent (in) :: th
real(8) :: t_1
t_1 = cos(th) / sqrt(2.0d0)
code = (t_1 * (a1 * a1)) + (t_1 * (a2 * a2))
end function
public static double code(double a1, double a2, double th) {
double t_1 = Math.cos(th) / Math.sqrt(2.0);
return (t_1 * (a1 * a1)) + (t_1 * (a2 * a2));
}
def code(a1, a2, th): t_1 = math.cos(th) / math.sqrt(2.0) return (t_1 * (a1 * a1)) + (t_1 * (a2 * a2))
function code(a1, a2, th) t_1 = Float64(cos(th) / sqrt(2.0)) return Float64(Float64(t_1 * Float64(a1 * a1)) + Float64(t_1 * Float64(a2 * a2))) end
function tmp = code(a1, a2, th) t_1 = cos(th) / sqrt(2.0); tmp = (t_1 * (a1 * a1)) + (t_1 * (a2 * a2)); end
code[a1_, a2_, th_] := Block[{t$95$1 = N[(N[Cos[th], $MachinePrecision] / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]}, N[(N[(t$95$1 * N[(a1 * a1), $MachinePrecision]), $MachinePrecision] + N[(t$95$1 * N[(a2 * a2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\cos th}{\sqrt{2}}\\
t_1 \cdot \left(a1 \cdot a1\right) + t_1 \cdot \left(a2 \cdot a2\right)
\end{array}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 14 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (a1 a2 th) :precision binary64 (let* ((t_1 (/ (cos th) (sqrt 2.0)))) (+ (* t_1 (* a1 a1)) (* t_1 (* a2 a2)))))
double code(double a1, double a2, double th) {
double t_1 = cos(th) / sqrt(2.0);
return (t_1 * (a1 * a1)) + (t_1 * (a2 * a2));
}
real(8) function code(a1, a2, th)
real(8), intent (in) :: a1
real(8), intent (in) :: a2
real(8), intent (in) :: th
real(8) :: t_1
t_1 = cos(th) / sqrt(2.0d0)
code = (t_1 * (a1 * a1)) + (t_1 * (a2 * a2))
end function
public static double code(double a1, double a2, double th) {
double t_1 = Math.cos(th) / Math.sqrt(2.0);
return (t_1 * (a1 * a1)) + (t_1 * (a2 * a2));
}
def code(a1, a2, th): t_1 = math.cos(th) / math.sqrt(2.0) return (t_1 * (a1 * a1)) + (t_1 * (a2 * a2))
function code(a1, a2, th) t_1 = Float64(cos(th) / sqrt(2.0)) return Float64(Float64(t_1 * Float64(a1 * a1)) + Float64(t_1 * Float64(a2 * a2))) end
function tmp = code(a1, a2, th) t_1 = cos(th) / sqrt(2.0); tmp = (t_1 * (a1 * a1)) + (t_1 * (a2 * a2)); end
code[a1_, a2_, th_] := Block[{t$95$1 = N[(N[Cos[th], $MachinePrecision] / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]}, N[(N[(t$95$1 * N[(a1 * a1), $MachinePrecision]), $MachinePrecision] + N[(t$95$1 * N[(a2 * a2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\cos th}{\sqrt{2}}\\
t_1 \cdot \left(a1 \cdot a1\right) + t_1 \cdot \left(a2 \cdot a2\right)
\end{array}
\end{array}
(FPCore (a1 a2 th) :precision binary64 (* (cos th) (* (pow (hypot a1 a2) 2.0) (pow 2.0 -0.5))))
double code(double a1, double a2, double th) {
return cos(th) * (pow(hypot(a1, a2), 2.0) * pow(2.0, -0.5));
}
public static double code(double a1, double a2, double th) {
return Math.cos(th) * (Math.pow(Math.hypot(a1, a2), 2.0) * Math.pow(2.0, -0.5));
}
def code(a1, a2, th): return math.cos(th) * (math.pow(math.hypot(a1, a2), 2.0) * math.pow(2.0, -0.5))
function code(a1, a2, th) return Float64(cos(th) * Float64((hypot(a1, a2) ^ 2.0) * (2.0 ^ -0.5))) end
function tmp = code(a1, a2, th) tmp = cos(th) * ((hypot(a1, a2) ^ 2.0) * (2.0 ^ -0.5)); end
code[a1_, a2_, th_] := N[(N[Cos[th], $MachinePrecision] * N[(N[Power[N[Sqrt[a1 ^ 2 + a2 ^ 2], $MachinePrecision], 2.0], $MachinePrecision] * N[Power[2.0, -0.5], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\cos th \cdot \left({\left(\mathsf{hypot}\left(a1, a2\right)\right)}^{2} \cdot {2}^{-0.5}\right)
\end{array}
Initial program 99.5%
distribute-lft-out99.6%
associate-*l/99.6%
associate-*r/99.5%
fma-def99.5%
Simplified99.5%
fma-def99.5%
div-inv99.5%
add-sqr-sqrt99.5%
pow299.5%
hypot-def99.5%
pow1/299.5%
pow-flip99.6%
metadata-eval99.6%
Applied egg-rr99.6%
Final simplification99.6%
(FPCore (a1 a2 th) :precision binary64 (if (<= (cos th) 0.9) (* a2 (/ a2 (/ (sqrt 2.0) (cos th)))) (* (+ (* a1 a1) (* a2 a2)) (sqrt 0.5))))
double code(double a1, double a2, double th) {
double tmp;
if (cos(th) <= 0.9) {
tmp = a2 * (a2 / (sqrt(2.0) / cos(th)));
} else {
tmp = ((a1 * a1) + (a2 * a2)) * sqrt(0.5);
}
return tmp;
}
real(8) function code(a1, a2, th)
real(8), intent (in) :: a1
real(8), intent (in) :: a2
real(8), intent (in) :: th
real(8) :: tmp
if (cos(th) <= 0.9d0) then
tmp = a2 * (a2 / (sqrt(2.0d0) / cos(th)))
else
tmp = ((a1 * a1) + (a2 * a2)) * sqrt(0.5d0)
end if
code = tmp
end function
public static double code(double a1, double a2, double th) {
double tmp;
if (Math.cos(th) <= 0.9) {
tmp = a2 * (a2 / (Math.sqrt(2.0) / Math.cos(th)));
} else {
tmp = ((a1 * a1) + (a2 * a2)) * Math.sqrt(0.5);
}
return tmp;
}
def code(a1, a2, th): tmp = 0 if math.cos(th) <= 0.9: tmp = a2 * (a2 / (math.sqrt(2.0) / math.cos(th))) else: tmp = ((a1 * a1) + (a2 * a2)) * math.sqrt(0.5) return tmp
function code(a1, a2, th) tmp = 0.0 if (cos(th) <= 0.9) tmp = Float64(a2 * Float64(a2 / Float64(sqrt(2.0) / cos(th)))); else tmp = Float64(Float64(Float64(a1 * a1) + Float64(a2 * a2)) * sqrt(0.5)); end return tmp end
function tmp_2 = code(a1, a2, th) tmp = 0.0; if (cos(th) <= 0.9) tmp = a2 * (a2 / (sqrt(2.0) / cos(th))); else tmp = ((a1 * a1) + (a2 * a2)) * sqrt(0.5); end tmp_2 = tmp; end
code[a1_, a2_, th_] := If[LessEqual[N[Cos[th], $MachinePrecision], 0.9], N[(a2 * N[(a2 / N[(N[Sqrt[2.0], $MachinePrecision] / N[Cos[th], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(a1 * a1), $MachinePrecision] + N[(a2 * a2), $MachinePrecision]), $MachinePrecision] * N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\cos th \leq 0.9:\\
\;\;\;\;a2 \cdot \frac{a2}{\frac{\sqrt{2}}{\cos th}}\\
\mathbf{else}:\\
\;\;\;\;\left(a1 \cdot a1 + a2 \cdot a2\right) \cdot \sqrt{0.5}\\
\end{array}
\end{array}
if (cos.f64 th) < 0.900000000000000022Initial program 99.6%
distribute-lft-out99.6%
associate-*l/99.6%
associate-*r/99.5%
fma-def99.5%
Simplified99.5%
Taylor expanded in a1 around 0 58.2%
unpow258.2%
associate-*l*58.2%
associate-*r/58.1%
associate-/l*58.2%
Simplified58.2%
if 0.900000000000000022 < (cos.f64 th) Initial program 99.5%
distribute-lft-out99.5%
Simplified99.5%
clear-num99.5%
associate-/r/99.5%
pow1/299.5%
pow-flip99.7%
metadata-eval99.7%
Applied egg-rr99.7%
Taylor expanded in th around 0 94.5%
Final simplification79.3%
(FPCore (a1 a2 th)
:precision binary64
(if (<= a2 4.5e-109)
(* (cos th) (* (* a1 a1) (sqrt 0.5)))
(if (or (<= a2 4e-76) (not (<= a2 3.6e-35)))
(* a2 (/ a2 (/ (sqrt 2.0) (cos th))))
(* (+ (* a1 a1) (* a2 a2)) (sqrt 0.5)))))
double code(double a1, double a2, double th) {
double tmp;
if (a2 <= 4.5e-109) {
tmp = cos(th) * ((a1 * a1) * sqrt(0.5));
} else if ((a2 <= 4e-76) || !(a2 <= 3.6e-35)) {
tmp = a2 * (a2 / (sqrt(2.0) / cos(th)));
} else {
tmp = ((a1 * a1) + (a2 * a2)) * sqrt(0.5);
}
return tmp;
}
real(8) function code(a1, a2, th)
real(8), intent (in) :: a1
real(8), intent (in) :: a2
real(8), intent (in) :: th
real(8) :: tmp
if (a2 <= 4.5d-109) then
tmp = cos(th) * ((a1 * a1) * sqrt(0.5d0))
else if ((a2 <= 4d-76) .or. (.not. (a2 <= 3.6d-35))) then
tmp = a2 * (a2 / (sqrt(2.0d0) / cos(th)))
else
tmp = ((a1 * a1) + (a2 * a2)) * sqrt(0.5d0)
end if
code = tmp
end function
public static double code(double a1, double a2, double th) {
double tmp;
if (a2 <= 4.5e-109) {
tmp = Math.cos(th) * ((a1 * a1) * Math.sqrt(0.5));
} else if ((a2 <= 4e-76) || !(a2 <= 3.6e-35)) {
tmp = a2 * (a2 / (Math.sqrt(2.0) / Math.cos(th)));
} else {
tmp = ((a1 * a1) + (a2 * a2)) * Math.sqrt(0.5);
}
return tmp;
}
def code(a1, a2, th): tmp = 0 if a2 <= 4.5e-109: tmp = math.cos(th) * ((a1 * a1) * math.sqrt(0.5)) elif (a2 <= 4e-76) or not (a2 <= 3.6e-35): tmp = a2 * (a2 / (math.sqrt(2.0) / math.cos(th))) else: tmp = ((a1 * a1) + (a2 * a2)) * math.sqrt(0.5) return tmp
function code(a1, a2, th) tmp = 0.0 if (a2 <= 4.5e-109) tmp = Float64(cos(th) * Float64(Float64(a1 * a1) * sqrt(0.5))); elseif ((a2 <= 4e-76) || !(a2 <= 3.6e-35)) tmp = Float64(a2 * Float64(a2 / Float64(sqrt(2.0) / cos(th)))); else tmp = Float64(Float64(Float64(a1 * a1) + Float64(a2 * a2)) * sqrt(0.5)); end return tmp end
function tmp_2 = code(a1, a2, th) tmp = 0.0; if (a2 <= 4.5e-109) tmp = cos(th) * ((a1 * a1) * sqrt(0.5)); elseif ((a2 <= 4e-76) || ~((a2 <= 3.6e-35))) tmp = a2 * (a2 / (sqrt(2.0) / cos(th))); else tmp = ((a1 * a1) + (a2 * a2)) * sqrt(0.5); end tmp_2 = tmp; end
code[a1_, a2_, th_] := If[LessEqual[a2, 4.5e-109], N[(N[Cos[th], $MachinePrecision] * N[(N[(a1 * a1), $MachinePrecision] * N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[a2, 4e-76], N[Not[LessEqual[a2, 3.6e-35]], $MachinePrecision]], N[(a2 * N[(a2 / N[(N[Sqrt[2.0], $MachinePrecision] / N[Cos[th], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(a1 * a1), $MachinePrecision] + N[(a2 * a2), $MachinePrecision]), $MachinePrecision] * N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a2 \leq 4.5 \cdot 10^{-109}:\\
\;\;\;\;\cos th \cdot \left(\left(a1 \cdot a1\right) \cdot \sqrt{0.5}\right)\\
\mathbf{elif}\;a2 \leq 4 \cdot 10^{-76} \lor \neg \left(a2 \leq 3.6 \cdot 10^{-35}\right):\\
\;\;\;\;a2 \cdot \frac{a2}{\frac{\sqrt{2}}{\cos th}}\\
\mathbf{else}:\\
\;\;\;\;\left(a1 \cdot a1 + a2 \cdot a2\right) \cdot \sqrt{0.5}\\
\end{array}
\end{array}
if a2 < 4.5000000000000001e-109Initial program 99.5%
distribute-lft-out99.6%
associate-*l/99.5%
associate-*r/99.5%
fma-def99.5%
Simplified99.5%
fma-def99.5%
div-inv99.5%
add-sqr-sqrt99.5%
pow299.5%
hypot-def99.5%
pow1/299.5%
pow-flip99.6%
metadata-eval99.6%
Applied egg-rr99.6%
Taylor expanded in a1 around inf 71.3%
unpow271.3%
Simplified71.3%
if 4.5000000000000001e-109 < a2 < 3.99999999999999971e-76 or 3.60000000000000019e-35 < a2 Initial program 99.6%
distribute-lft-out99.6%
associate-*l/99.7%
associate-*r/99.6%
fma-def99.6%
Simplified99.6%
Taylor expanded in a1 around 0 73.1%
unpow273.1%
associate-*l*73.1%
associate-*r/73.0%
associate-/l*73.1%
Simplified73.1%
if 3.99999999999999971e-76 < a2 < 3.60000000000000019e-35Initial program 99.4%
distribute-lft-out99.4%
Simplified99.4%
clear-num99.4%
associate-/r/99.4%
pow1/299.4%
pow-flip99.8%
metadata-eval99.8%
Applied egg-rr99.8%
Taylor expanded in th around 0 62.2%
Final simplification71.5%
(FPCore (a1 a2 th)
:precision binary64
(if (<= a2 3.25e-109)
(* (cos th) (* (* a1 a1) (sqrt 0.5)))
(if (or (<= a2 1.5e-76) (not (<= a2 2.7e-32)))
(* (cos th) (/ a2 (/ (sqrt 2.0) a2)))
(* (+ (* a1 a1) (* a2 a2)) (sqrt 0.5)))))
double code(double a1, double a2, double th) {
double tmp;
if (a2 <= 3.25e-109) {
tmp = cos(th) * ((a1 * a1) * sqrt(0.5));
} else if ((a2 <= 1.5e-76) || !(a2 <= 2.7e-32)) {
tmp = cos(th) * (a2 / (sqrt(2.0) / a2));
} else {
tmp = ((a1 * a1) + (a2 * a2)) * sqrt(0.5);
}
return tmp;
}
real(8) function code(a1, a2, th)
real(8), intent (in) :: a1
real(8), intent (in) :: a2
real(8), intent (in) :: th
real(8) :: tmp
if (a2 <= 3.25d-109) then
tmp = cos(th) * ((a1 * a1) * sqrt(0.5d0))
else if ((a2 <= 1.5d-76) .or. (.not. (a2 <= 2.7d-32))) then
tmp = cos(th) * (a2 / (sqrt(2.0d0) / a2))
else
tmp = ((a1 * a1) + (a2 * a2)) * sqrt(0.5d0)
end if
code = tmp
end function
public static double code(double a1, double a2, double th) {
double tmp;
if (a2 <= 3.25e-109) {
tmp = Math.cos(th) * ((a1 * a1) * Math.sqrt(0.5));
} else if ((a2 <= 1.5e-76) || !(a2 <= 2.7e-32)) {
tmp = Math.cos(th) * (a2 / (Math.sqrt(2.0) / a2));
} else {
tmp = ((a1 * a1) + (a2 * a2)) * Math.sqrt(0.5);
}
return tmp;
}
def code(a1, a2, th): tmp = 0 if a2 <= 3.25e-109: tmp = math.cos(th) * ((a1 * a1) * math.sqrt(0.5)) elif (a2 <= 1.5e-76) or not (a2 <= 2.7e-32): tmp = math.cos(th) * (a2 / (math.sqrt(2.0) / a2)) else: tmp = ((a1 * a1) + (a2 * a2)) * math.sqrt(0.5) return tmp
function code(a1, a2, th) tmp = 0.0 if (a2 <= 3.25e-109) tmp = Float64(cos(th) * Float64(Float64(a1 * a1) * sqrt(0.5))); elseif ((a2 <= 1.5e-76) || !(a2 <= 2.7e-32)) tmp = Float64(cos(th) * Float64(a2 / Float64(sqrt(2.0) / a2))); else tmp = Float64(Float64(Float64(a1 * a1) + Float64(a2 * a2)) * sqrt(0.5)); end return tmp end
function tmp_2 = code(a1, a2, th) tmp = 0.0; if (a2 <= 3.25e-109) tmp = cos(th) * ((a1 * a1) * sqrt(0.5)); elseif ((a2 <= 1.5e-76) || ~((a2 <= 2.7e-32))) tmp = cos(th) * (a2 / (sqrt(2.0) / a2)); else tmp = ((a1 * a1) + (a2 * a2)) * sqrt(0.5); end tmp_2 = tmp; end
code[a1_, a2_, th_] := If[LessEqual[a2, 3.25e-109], N[(N[Cos[th], $MachinePrecision] * N[(N[(a1 * a1), $MachinePrecision] * N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[a2, 1.5e-76], N[Not[LessEqual[a2, 2.7e-32]], $MachinePrecision]], N[(N[Cos[th], $MachinePrecision] * N[(a2 / N[(N[Sqrt[2.0], $MachinePrecision] / a2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(a1 * a1), $MachinePrecision] + N[(a2 * a2), $MachinePrecision]), $MachinePrecision] * N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a2 \leq 3.25 \cdot 10^{-109}:\\
\;\;\;\;\cos th \cdot \left(\left(a1 \cdot a1\right) \cdot \sqrt{0.5}\right)\\
\mathbf{elif}\;a2 \leq 1.5 \cdot 10^{-76} \lor \neg \left(a2 \leq 2.7 \cdot 10^{-32}\right):\\
\;\;\;\;\cos th \cdot \frac{a2}{\frac{\sqrt{2}}{a2}}\\
\mathbf{else}:\\
\;\;\;\;\left(a1 \cdot a1 + a2 \cdot a2\right) \cdot \sqrt{0.5}\\
\end{array}
\end{array}
if a2 < 3.2499999999999998e-109Initial program 99.5%
distribute-lft-out99.6%
associate-*l/99.5%
associate-*r/99.5%
fma-def99.5%
Simplified99.5%
fma-def99.5%
div-inv99.5%
add-sqr-sqrt99.5%
pow299.5%
hypot-def99.5%
pow1/299.5%
pow-flip99.6%
metadata-eval99.6%
Applied egg-rr99.6%
Taylor expanded in a1 around inf 71.3%
unpow271.3%
Simplified71.3%
if 3.2499999999999998e-109 < a2 < 1.50000000000000012e-76 or 2.69999999999999981e-32 < a2 Initial program 99.6%
distribute-lft-out99.6%
associate-*l/99.7%
associate-*r/99.6%
fma-def99.6%
Simplified99.6%
Taylor expanded in a1 around 0 73.1%
unpow273.1%
associate-/l*73.1%
Simplified73.1%
if 1.50000000000000012e-76 < a2 < 2.69999999999999981e-32Initial program 99.4%
distribute-lft-out99.4%
Simplified99.4%
clear-num99.4%
associate-/r/99.4%
pow1/299.4%
pow-flip99.8%
metadata-eval99.8%
Applied egg-rr99.8%
Taylor expanded in th around 0 62.2%
Final simplification71.5%
(FPCore (a1 a2 th)
:precision binary64
(if (<= a2 1.05e-109)
(* (sqrt 0.5) (* a1 (* (cos th) a1)))
(if (or (<= a2 1.65e-76) (not (<= a2 5.3e-33)))
(* (cos th) (/ a2 (/ (sqrt 2.0) a2)))
(* (+ (* a1 a1) (* a2 a2)) (sqrt 0.5)))))
double code(double a1, double a2, double th) {
double tmp;
if (a2 <= 1.05e-109) {
tmp = sqrt(0.5) * (a1 * (cos(th) * a1));
} else if ((a2 <= 1.65e-76) || !(a2 <= 5.3e-33)) {
tmp = cos(th) * (a2 / (sqrt(2.0) / a2));
} else {
tmp = ((a1 * a1) + (a2 * a2)) * sqrt(0.5);
}
return tmp;
}
real(8) function code(a1, a2, th)
real(8), intent (in) :: a1
real(8), intent (in) :: a2
real(8), intent (in) :: th
real(8) :: tmp
if (a2 <= 1.05d-109) then
tmp = sqrt(0.5d0) * (a1 * (cos(th) * a1))
else if ((a2 <= 1.65d-76) .or. (.not. (a2 <= 5.3d-33))) then
tmp = cos(th) * (a2 / (sqrt(2.0d0) / a2))
else
tmp = ((a1 * a1) + (a2 * a2)) * sqrt(0.5d0)
end if
code = tmp
end function
public static double code(double a1, double a2, double th) {
double tmp;
if (a2 <= 1.05e-109) {
tmp = Math.sqrt(0.5) * (a1 * (Math.cos(th) * a1));
} else if ((a2 <= 1.65e-76) || !(a2 <= 5.3e-33)) {
tmp = Math.cos(th) * (a2 / (Math.sqrt(2.0) / a2));
} else {
tmp = ((a1 * a1) + (a2 * a2)) * Math.sqrt(0.5);
}
return tmp;
}
def code(a1, a2, th): tmp = 0 if a2 <= 1.05e-109: tmp = math.sqrt(0.5) * (a1 * (math.cos(th) * a1)) elif (a2 <= 1.65e-76) or not (a2 <= 5.3e-33): tmp = math.cos(th) * (a2 / (math.sqrt(2.0) / a2)) else: tmp = ((a1 * a1) + (a2 * a2)) * math.sqrt(0.5) return tmp
function code(a1, a2, th) tmp = 0.0 if (a2 <= 1.05e-109) tmp = Float64(sqrt(0.5) * Float64(a1 * Float64(cos(th) * a1))); elseif ((a2 <= 1.65e-76) || !(a2 <= 5.3e-33)) tmp = Float64(cos(th) * Float64(a2 / Float64(sqrt(2.0) / a2))); else tmp = Float64(Float64(Float64(a1 * a1) + Float64(a2 * a2)) * sqrt(0.5)); end return tmp end
function tmp_2 = code(a1, a2, th) tmp = 0.0; if (a2 <= 1.05e-109) tmp = sqrt(0.5) * (a1 * (cos(th) * a1)); elseif ((a2 <= 1.65e-76) || ~((a2 <= 5.3e-33))) tmp = cos(th) * (a2 / (sqrt(2.0) / a2)); else tmp = ((a1 * a1) + (a2 * a2)) * sqrt(0.5); end tmp_2 = tmp; end
code[a1_, a2_, th_] := If[LessEqual[a2, 1.05e-109], N[(N[Sqrt[0.5], $MachinePrecision] * N[(a1 * N[(N[Cos[th], $MachinePrecision] * a1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[a2, 1.65e-76], N[Not[LessEqual[a2, 5.3e-33]], $MachinePrecision]], N[(N[Cos[th], $MachinePrecision] * N[(a2 / N[(N[Sqrt[2.0], $MachinePrecision] / a2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(a1 * a1), $MachinePrecision] + N[(a2 * a2), $MachinePrecision]), $MachinePrecision] * N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a2 \leq 1.05 \cdot 10^{-109}:\\
\;\;\;\;\sqrt{0.5} \cdot \left(a1 \cdot \left(\cos th \cdot a1\right)\right)\\
\mathbf{elif}\;a2 \leq 1.65 \cdot 10^{-76} \lor \neg \left(a2 \leq 5.3 \cdot 10^{-33}\right):\\
\;\;\;\;\cos th \cdot \frac{a2}{\frac{\sqrt{2}}{a2}}\\
\mathbf{else}:\\
\;\;\;\;\left(a1 \cdot a1 + a2 \cdot a2\right) \cdot \sqrt{0.5}\\
\end{array}
\end{array}
if a2 < 1.04999999999999998e-109Initial program 99.5%
distribute-lft-out99.6%
associate-*l/99.5%
associate-*r/99.5%
fma-def99.5%
Simplified99.5%
fma-def99.5%
div-inv99.5%
add-sqr-sqrt99.5%
pow299.5%
hypot-def99.5%
pow1/299.5%
pow-flip99.6%
metadata-eval99.6%
Applied egg-rr99.6%
Taylor expanded in a1 around inf 71.4%
unpow271.4%
associate-*r*71.4%
Simplified71.4%
if 1.04999999999999998e-109 < a2 < 1.64999999999999992e-76 or 5.29999999999999968e-33 < a2 Initial program 99.6%
distribute-lft-out99.6%
associate-*l/99.7%
associate-*r/99.6%
fma-def99.6%
Simplified99.6%
Taylor expanded in a1 around 0 73.1%
unpow273.1%
associate-/l*73.1%
Simplified73.1%
if 1.64999999999999992e-76 < a2 < 5.29999999999999968e-33Initial program 99.4%
distribute-lft-out99.4%
Simplified99.4%
clear-num99.4%
associate-/r/99.4%
pow1/299.4%
pow-flip99.8%
metadata-eval99.8%
Applied egg-rr99.8%
Taylor expanded in th around 0 62.2%
Final simplification71.6%
(FPCore (a1 a2 th)
:precision binary64
(if (<= a2 3.75e-109)
(/ (cos th) (/ (sqrt 2.0) (* a1 a1)))
(if (or (<= a2 2.2e-76) (not (<= a2 2.2e-32)))
(* (cos th) (/ a2 (/ (sqrt 2.0) a2)))
(* (+ (* a1 a1) (* a2 a2)) (sqrt 0.5)))))
double code(double a1, double a2, double th) {
double tmp;
if (a2 <= 3.75e-109) {
tmp = cos(th) / (sqrt(2.0) / (a1 * a1));
} else if ((a2 <= 2.2e-76) || !(a2 <= 2.2e-32)) {
tmp = cos(th) * (a2 / (sqrt(2.0) / a2));
} else {
tmp = ((a1 * a1) + (a2 * a2)) * sqrt(0.5);
}
return tmp;
}
real(8) function code(a1, a2, th)
real(8), intent (in) :: a1
real(8), intent (in) :: a2
real(8), intent (in) :: th
real(8) :: tmp
if (a2 <= 3.75d-109) then
tmp = cos(th) / (sqrt(2.0d0) / (a1 * a1))
else if ((a2 <= 2.2d-76) .or. (.not. (a2 <= 2.2d-32))) then
tmp = cos(th) * (a2 / (sqrt(2.0d0) / a2))
else
tmp = ((a1 * a1) + (a2 * a2)) * sqrt(0.5d0)
end if
code = tmp
end function
public static double code(double a1, double a2, double th) {
double tmp;
if (a2 <= 3.75e-109) {
tmp = Math.cos(th) / (Math.sqrt(2.0) / (a1 * a1));
} else if ((a2 <= 2.2e-76) || !(a2 <= 2.2e-32)) {
tmp = Math.cos(th) * (a2 / (Math.sqrt(2.0) / a2));
} else {
tmp = ((a1 * a1) + (a2 * a2)) * Math.sqrt(0.5);
}
return tmp;
}
def code(a1, a2, th): tmp = 0 if a2 <= 3.75e-109: tmp = math.cos(th) / (math.sqrt(2.0) / (a1 * a1)) elif (a2 <= 2.2e-76) or not (a2 <= 2.2e-32): tmp = math.cos(th) * (a2 / (math.sqrt(2.0) / a2)) else: tmp = ((a1 * a1) + (a2 * a2)) * math.sqrt(0.5) return tmp
function code(a1, a2, th) tmp = 0.0 if (a2 <= 3.75e-109) tmp = Float64(cos(th) / Float64(sqrt(2.0) / Float64(a1 * a1))); elseif ((a2 <= 2.2e-76) || !(a2 <= 2.2e-32)) tmp = Float64(cos(th) * Float64(a2 / Float64(sqrt(2.0) / a2))); else tmp = Float64(Float64(Float64(a1 * a1) + Float64(a2 * a2)) * sqrt(0.5)); end return tmp end
function tmp_2 = code(a1, a2, th) tmp = 0.0; if (a2 <= 3.75e-109) tmp = cos(th) / (sqrt(2.0) / (a1 * a1)); elseif ((a2 <= 2.2e-76) || ~((a2 <= 2.2e-32))) tmp = cos(th) * (a2 / (sqrt(2.0) / a2)); else tmp = ((a1 * a1) + (a2 * a2)) * sqrt(0.5); end tmp_2 = tmp; end
code[a1_, a2_, th_] := If[LessEqual[a2, 3.75e-109], N[(N[Cos[th], $MachinePrecision] / N[(N[Sqrt[2.0], $MachinePrecision] / N[(a1 * a1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[a2, 2.2e-76], N[Not[LessEqual[a2, 2.2e-32]], $MachinePrecision]], N[(N[Cos[th], $MachinePrecision] * N[(a2 / N[(N[Sqrt[2.0], $MachinePrecision] / a2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(a1 * a1), $MachinePrecision] + N[(a2 * a2), $MachinePrecision]), $MachinePrecision] * N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a2 \leq 3.75 \cdot 10^{-109}:\\
\;\;\;\;\frac{\cos th}{\frac{\sqrt{2}}{a1 \cdot a1}}\\
\mathbf{elif}\;a2 \leq 2.2 \cdot 10^{-76} \lor \neg \left(a2 \leq 2.2 \cdot 10^{-32}\right):\\
\;\;\;\;\cos th \cdot \frac{a2}{\frac{\sqrt{2}}{a2}}\\
\mathbf{else}:\\
\;\;\;\;\left(a1 \cdot a1 + a2 \cdot a2\right) \cdot \sqrt{0.5}\\
\end{array}
\end{array}
if a2 < 3.74999999999999991e-109Initial program 99.5%
distribute-lft-out99.6%
associate-*l/99.5%
associate-*r/99.5%
fma-def99.5%
Simplified99.5%
Taylor expanded in a1 around inf 71.3%
unpow271.3%
associate-/l*71.3%
Simplified71.3%
Taylor expanded in th around inf 71.3%
unpow271.3%
*-commutative71.3%
associate-/l*71.3%
Simplified71.3%
if 3.74999999999999991e-109 < a2 < 2.19999999999999999e-76 or 2.2e-32 < a2 Initial program 99.6%
distribute-lft-out99.6%
associate-*l/99.7%
associate-*r/99.6%
fma-def99.6%
Simplified99.6%
Taylor expanded in a1 around 0 73.1%
unpow273.1%
associate-/l*73.1%
Simplified73.1%
if 2.19999999999999999e-76 < a2 < 2.2e-32Initial program 99.4%
distribute-lft-out99.4%
Simplified99.4%
clear-num99.4%
associate-/r/99.4%
pow1/299.4%
pow-flip99.8%
metadata-eval99.8%
Applied egg-rr99.8%
Taylor expanded in th around 0 62.2%
Final simplification71.5%
(FPCore (a1 a2 th)
:precision binary64
(let* ((t_1 (/ (sqrt 2.0) a2)))
(if (<= a2 4.5e-109)
(/ (cos th) (/ (sqrt 2.0) (* a1 a1)))
(if (<= a2 1.5e-76)
(* (cos th) (/ a2 t_1))
(if (<= a2 9e-33)
(* (+ (* a1 a1) (* a2 a2)) (sqrt 0.5))
(/ (* (cos th) a2) t_1))))))
double code(double a1, double a2, double th) {
double t_1 = sqrt(2.0) / a2;
double tmp;
if (a2 <= 4.5e-109) {
tmp = cos(th) / (sqrt(2.0) / (a1 * a1));
} else if (a2 <= 1.5e-76) {
tmp = cos(th) * (a2 / t_1);
} else if (a2 <= 9e-33) {
tmp = ((a1 * a1) + (a2 * a2)) * sqrt(0.5);
} else {
tmp = (cos(th) * a2) / t_1;
}
return tmp;
}
real(8) function code(a1, a2, th)
real(8), intent (in) :: a1
real(8), intent (in) :: a2
real(8), intent (in) :: th
real(8) :: t_1
real(8) :: tmp
t_1 = sqrt(2.0d0) / a2
if (a2 <= 4.5d-109) then
tmp = cos(th) / (sqrt(2.0d0) / (a1 * a1))
else if (a2 <= 1.5d-76) then
tmp = cos(th) * (a2 / t_1)
else if (a2 <= 9d-33) then
tmp = ((a1 * a1) + (a2 * a2)) * sqrt(0.5d0)
else
tmp = (cos(th) * a2) / t_1
end if
code = tmp
end function
public static double code(double a1, double a2, double th) {
double t_1 = Math.sqrt(2.0) / a2;
double tmp;
if (a2 <= 4.5e-109) {
tmp = Math.cos(th) / (Math.sqrt(2.0) / (a1 * a1));
} else if (a2 <= 1.5e-76) {
tmp = Math.cos(th) * (a2 / t_1);
} else if (a2 <= 9e-33) {
tmp = ((a1 * a1) + (a2 * a2)) * Math.sqrt(0.5);
} else {
tmp = (Math.cos(th) * a2) / t_1;
}
return tmp;
}
def code(a1, a2, th): t_1 = math.sqrt(2.0) / a2 tmp = 0 if a2 <= 4.5e-109: tmp = math.cos(th) / (math.sqrt(2.0) / (a1 * a1)) elif a2 <= 1.5e-76: tmp = math.cos(th) * (a2 / t_1) elif a2 <= 9e-33: tmp = ((a1 * a1) + (a2 * a2)) * math.sqrt(0.5) else: tmp = (math.cos(th) * a2) / t_1 return tmp
function code(a1, a2, th) t_1 = Float64(sqrt(2.0) / a2) tmp = 0.0 if (a2 <= 4.5e-109) tmp = Float64(cos(th) / Float64(sqrt(2.0) / Float64(a1 * a1))); elseif (a2 <= 1.5e-76) tmp = Float64(cos(th) * Float64(a2 / t_1)); elseif (a2 <= 9e-33) tmp = Float64(Float64(Float64(a1 * a1) + Float64(a2 * a2)) * sqrt(0.5)); else tmp = Float64(Float64(cos(th) * a2) / t_1); end return tmp end
function tmp_2 = code(a1, a2, th) t_1 = sqrt(2.0) / a2; tmp = 0.0; if (a2 <= 4.5e-109) tmp = cos(th) / (sqrt(2.0) / (a1 * a1)); elseif (a2 <= 1.5e-76) tmp = cos(th) * (a2 / t_1); elseif (a2 <= 9e-33) tmp = ((a1 * a1) + (a2 * a2)) * sqrt(0.5); else tmp = (cos(th) * a2) / t_1; end tmp_2 = tmp; end
code[a1_, a2_, th_] := Block[{t$95$1 = N[(N[Sqrt[2.0], $MachinePrecision] / a2), $MachinePrecision]}, If[LessEqual[a2, 4.5e-109], N[(N[Cos[th], $MachinePrecision] / N[(N[Sqrt[2.0], $MachinePrecision] / N[(a1 * a1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a2, 1.5e-76], N[(N[Cos[th], $MachinePrecision] * N[(a2 / t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[a2, 9e-33], N[(N[(N[(a1 * a1), $MachinePrecision] + N[(a2 * a2), $MachinePrecision]), $MachinePrecision] * N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision], N[(N[(N[Cos[th], $MachinePrecision] * a2), $MachinePrecision] / t$95$1), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\sqrt{2}}{a2}\\
\mathbf{if}\;a2 \leq 4.5 \cdot 10^{-109}:\\
\;\;\;\;\frac{\cos th}{\frac{\sqrt{2}}{a1 \cdot a1}}\\
\mathbf{elif}\;a2 \leq 1.5 \cdot 10^{-76}:\\
\;\;\;\;\cos th \cdot \frac{a2}{t_1}\\
\mathbf{elif}\;a2 \leq 9 \cdot 10^{-33}:\\
\;\;\;\;\left(a1 \cdot a1 + a2 \cdot a2\right) \cdot \sqrt{0.5}\\
\mathbf{else}:\\
\;\;\;\;\frac{\cos th \cdot a2}{t_1}\\
\end{array}
\end{array}
if a2 < 4.5000000000000001e-109Initial program 99.5%
distribute-lft-out99.6%
associate-*l/99.5%
associate-*r/99.5%
fma-def99.5%
Simplified99.5%
Taylor expanded in a1 around inf 71.3%
unpow271.3%
associate-/l*71.3%
Simplified71.3%
Taylor expanded in th around inf 71.3%
unpow271.3%
*-commutative71.3%
associate-/l*71.3%
Simplified71.3%
if 4.5000000000000001e-109 < a2 < 1.50000000000000012e-76Initial program 99.6%
distribute-lft-out99.6%
associate-*l/99.8%
associate-*r/99.6%
fma-def99.6%
Simplified99.6%
Taylor expanded in a1 around 0 27.2%
unpow227.2%
associate-/l*27.2%
Simplified27.2%
if 1.50000000000000012e-76 < a2 < 8.99999999999999982e-33Initial program 99.4%
distribute-lft-out99.4%
Simplified99.4%
clear-num99.4%
associate-/r/99.4%
pow1/299.4%
pow-flip99.8%
metadata-eval99.8%
Applied egg-rr99.8%
Taylor expanded in th around 0 62.2%
if 8.99999999999999982e-33 < a2 Initial program 99.6%
distribute-lft-out99.6%
associate-*l/99.7%
associate-*r/99.6%
fma-def99.6%
Simplified99.6%
Taylor expanded in a1 around 0 78.0%
unpow278.0%
associate-/l*78.1%
Simplified78.1%
*-commutative78.1%
associate-*l/78.0%
Applied egg-rr78.0%
Final simplification71.5%
(FPCore (a1 a2 th) :precision binary64 (* (* (cos th) (pow 2.0 -0.5)) (+ (* a1 a1) (* a2 a2))))
double code(double a1, double a2, double th) {
return (cos(th) * pow(2.0, -0.5)) * ((a1 * a1) + (a2 * a2));
}
real(8) function code(a1, a2, th)
real(8), intent (in) :: a1
real(8), intent (in) :: a2
real(8), intent (in) :: th
code = (cos(th) * (2.0d0 ** (-0.5d0))) * ((a1 * a1) + (a2 * a2))
end function
public static double code(double a1, double a2, double th) {
return (Math.cos(th) * Math.pow(2.0, -0.5)) * ((a1 * a1) + (a2 * a2));
}
def code(a1, a2, th): return (math.cos(th) * math.pow(2.0, -0.5)) * ((a1 * a1) + (a2 * a2))
function code(a1, a2, th) return Float64(Float64(cos(th) * (2.0 ^ -0.5)) * Float64(Float64(a1 * a1) + Float64(a2 * a2))) end
function tmp = code(a1, a2, th) tmp = (cos(th) * (2.0 ^ -0.5)) * ((a1 * a1) + (a2 * a2)); end
code[a1_, a2_, th_] := N[(N[(N[Cos[th], $MachinePrecision] * N[Power[2.0, -0.5], $MachinePrecision]), $MachinePrecision] * N[(N[(a1 * a1), $MachinePrecision] + N[(a2 * a2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\cos th \cdot {2}^{-0.5}\right) \cdot \left(a1 \cdot a1 + a2 \cdot a2\right)
\end{array}
Initial program 99.5%
distribute-lft-out99.6%
Simplified99.6%
clear-num99.6%
associate-/r/99.5%
pow1/299.5%
pow-flip99.6%
metadata-eval99.6%
Applied egg-rr99.6%
Final simplification99.6%
(FPCore (a1 a2 th) :precision binary64 (* (+ (* a1 a1) (* a2 a2)) (/ (cos th) (sqrt 2.0))))
double code(double a1, double a2, double th) {
return ((a1 * a1) + (a2 * a2)) * (cos(th) / sqrt(2.0));
}
real(8) function code(a1, a2, th)
real(8), intent (in) :: a1
real(8), intent (in) :: a2
real(8), intent (in) :: th
code = ((a1 * a1) + (a2 * a2)) * (cos(th) / sqrt(2.0d0))
end function
public static double code(double a1, double a2, double th) {
return ((a1 * a1) + (a2 * a2)) * (Math.cos(th) / Math.sqrt(2.0));
}
def code(a1, a2, th): return ((a1 * a1) + (a2 * a2)) * (math.cos(th) / math.sqrt(2.0))
function code(a1, a2, th) return Float64(Float64(Float64(a1 * a1) + Float64(a2 * a2)) * Float64(cos(th) / sqrt(2.0))) end
function tmp = code(a1, a2, th) tmp = ((a1 * a1) + (a2 * a2)) * (cos(th) / sqrt(2.0)); end
code[a1_, a2_, th_] := N[(N[(N[(a1 * a1), $MachinePrecision] + N[(a2 * a2), $MachinePrecision]), $MachinePrecision] * N[(N[Cos[th], $MachinePrecision] / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(a1 \cdot a1 + a2 \cdot a2\right) \cdot \frac{\cos th}{\sqrt{2}}
\end{array}
Initial program 99.5%
distribute-lft-out99.6%
Simplified99.6%
Final simplification99.6%
(FPCore (a1 a2 th) :precision binary64 (if (<= a1 -1e+156) (* (sqrt 0.5) (* a1 (+ a1 (* -0.5 (* a1 (* th th)))))) (* (+ (* a1 a1) (* a2 a2)) (sqrt 0.5))))
double code(double a1, double a2, double th) {
double tmp;
if (a1 <= -1e+156) {
tmp = sqrt(0.5) * (a1 * (a1 + (-0.5 * (a1 * (th * th)))));
} else {
tmp = ((a1 * a1) + (a2 * a2)) * sqrt(0.5);
}
return tmp;
}
real(8) function code(a1, a2, th)
real(8), intent (in) :: a1
real(8), intent (in) :: a2
real(8), intent (in) :: th
real(8) :: tmp
if (a1 <= (-1d+156)) then
tmp = sqrt(0.5d0) * (a1 * (a1 + ((-0.5d0) * (a1 * (th * th)))))
else
tmp = ((a1 * a1) + (a2 * a2)) * sqrt(0.5d0)
end if
code = tmp
end function
public static double code(double a1, double a2, double th) {
double tmp;
if (a1 <= -1e+156) {
tmp = Math.sqrt(0.5) * (a1 * (a1 + (-0.5 * (a1 * (th * th)))));
} else {
tmp = ((a1 * a1) + (a2 * a2)) * Math.sqrt(0.5);
}
return tmp;
}
def code(a1, a2, th): tmp = 0 if a1 <= -1e+156: tmp = math.sqrt(0.5) * (a1 * (a1 + (-0.5 * (a1 * (th * th))))) else: tmp = ((a1 * a1) + (a2 * a2)) * math.sqrt(0.5) return tmp
function code(a1, a2, th) tmp = 0.0 if (a1 <= -1e+156) tmp = Float64(sqrt(0.5) * Float64(a1 * Float64(a1 + Float64(-0.5 * Float64(a1 * Float64(th * th)))))); else tmp = Float64(Float64(Float64(a1 * a1) + Float64(a2 * a2)) * sqrt(0.5)); end return tmp end
function tmp_2 = code(a1, a2, th) tmp = 0.0; if (a1 <= -1e+156) tmp = sqrt(0.5) * (a1 * (a1 + (-0.5 * (a1 * (th * th))))); else tmp = ((a1 * a1) + (a2 * a2)) * sqrt(0.5); end tmp_2 = tmp; end
code[a1_, a2_, th_] := If[LessEqual[a1, -1e+156], N[(N[Sqrt[0.5], $MachinePrecision] * N[(a1 * N[(a1 + N[(-0.5 * N[(a1 * N[(th * th), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(a1 * a1), $MachinePrecision] + N[(a2 * a2), $MachinePrecision]), $MachinePrecision] * N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a1 \leq -1 \cdot 10^{+156}:\\
\;\;\;\;\sqrt{0.5} \cdot \left(a1 \cdot \left(a1 + -0.5 \cdot \left(a1 \cdot \left(th \cdot th\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(a1 \cdot a1 + a2 \cdot a2\right) \cdot \sqrt{0.5}\\
\end{array}
\end{array}
if a1 < -9.9999999999999998e155Initial program 100.0%
distribute-lft-out100.0%
associate-*l/100.0%
associate-*r/100.0%
fma-def100.0%
Simplified100.0%
fma-def100.0%
div-inv100.0%
add-sqr-sqrt100.0%
pow2100.0%
hypot-def100.0%
pow1/2100.0%
pow-flip100.0%
metadata-eval100.0%
Applied egg-rr100.0%
Taylor expanded in a1 around inf 100.0%
unpow2100.0%
associate-*r*100.0%
Simplified100.0%
Taylor expanded in th around 0 90.0%
*-commutative90.0%
unpow290.0%
Simplified90.0%
if -9.9999999999999998e155 < a1 Initial program 99.5%
distribute-lft-out99.5%
Simplified99.5%
clear-num99.5%
associate-/r/99.5%
pow1/299.5%
pow-flip99.6%
metadata-eval99.6%
Applied egg-rr99.6%
Taylor expanded in th around 0 63.5%
Final simplification66.6%
(FPCore (a1 a2 th)
:precision binary64
(if (<= a2 3.5e-66)
(* (* a1 a1) (sqrt 0.5))
(if (or (<= a2 1.9e+164) (not (<= a2 1.45e+173)))
(* (* a2 a2) (sqrt 0.5))
(/ (* a2 (- a2)) (sqrt 2.0)))))
double code(double a1, double a2, double th) {
double tmp;
if (a2 <= 3.5e-66) {
tmp = (a1 * a1) * sqrt(0.5);
} else if ((a2 <= 1.9e+164) || !(a2 <= 1.45e+173)) {
tmp = (a2 * a2) * sqrt(0.5);
} else {
tmp = (a2 * -a2) / sqrt(2.0);
}
return tmp;
}
real(8) function code(a1, a2, th)
real(8), intent (in) :: a1
real(8), intent (in) :: a2
real(8), intent (in) :: th
real(8) :: tmp
if (a2 <= 3.5d-66) then
tmp = (a1 * a1) * sqrt(0.5d0)
else if ((a2 <= 1.9d+164) .or. (.not. (a2 <= 1.45d+173))) then
tmp = (a2 * a2) * sqrt(0.5d0)
else
tmp = (a2 * -a2) / sqrt(2.0d0)
end if
code = tmp
end function
public static double code(double a1, double a2, double th) {
double tmp;
if (a2 <= 3.5e-66) {
tmp = (a1 * a1) * Math.sqrt(0.5);
} else if ((a2 <= 1.9e+164) || !(a2 <= 1.45e+173)) {
tmp = (a2 * a2) * Math.sqrt(0.5);
} else {
tmp = (a2 * -a2) / Math.sqrt(2.0);
}
return tmp;
}
def code(a1, a2, th): tmp = 0 if a2 <= 3.5e-66: tmp = (a1 * a1) * math.sqrt(0.5) elif (a2 <= 1.9e+164) or not (a2 <= 1.45e+173): tmp = (a2 * a2) * math.sqrt(0.5) else: tmp = (a2 * -a2) / math.sqrt(2.0) return tmp
function code(a1, a2, th) tmp = 0.0 if (a2 <= 3.5e-66) tmp = Float64(Float64(a1 * a1) * sqrt(0.5)); elseif ((a2 <= 1.9e+164) || !(a2 <= 1.45e+173)) tmp = Float64(Float64(a2 * a2) * sqrt(0.5)); else tmp = Float64(Float64(a2 * Float64(-a2)) / sqrt(2.0)); end return tmp end
function tmp_2 = code(a1, a2, th) tmp = 0.0; if (a2 <= 3.5e-66) tmp = (a1 * a1) * sqrt(0.5); elseif ((a2 <= 1.9e+164) || ~((a2 <= 1.45e+173))) tmp = (a2 * a2) * sqrt(0.5); else tmp = (a2 * -a2) / sqrt(2.0); end tmp_2 = tmp; end
code[a1_, a2_, th_] := If[LessEqual[a2, 3.5e-66], N[(N[(a1 * a1), $MachinePrecision] * N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[a2, 1.9e+164], N[Not[LessEqual[a2, 1.45e+173]], $MachinePrecision]], N[(N[(a2 * a2), $MachinePrecision] * N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision], N[(N[(a2 * (-a2)), $MachinePrecision] / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a2 \leq 3.5 \cdot 10^{-66}:\\
\;\;\;\;\left(a1 \cdot a1\right) \cdot \sqrt{0.5}\\
\mathbf{elif}\;a2 \leq 1.9 \cdot 10^{+164} \lor \neg \left(a2 \leq 1.45 \cdot 10^{+173}\right):\\
\;\;\;\;\left(a2 \cdot a2\right) \cdot \sqrt{0.5}\\
\mathbf{else}:\\
\;\;\;\;\frac{a2 \cdot \left(-a2\right)}{\sqrt{2}}\\
\end{array}
\end{array}
if a2 < 3.5e-66Initial program 99.5%
distribute-lft-out99.5%
associate-*l/99.5%
associate-*r/99.5%
fma-def99.5%
Simplified99.5%
Taylor expanded in th around 0 64.3%
unpow264.3%
unpow264.3%
+-commutative64.3%
Simplified64.3%
Taylor expanded in a1 around inf 49.1%
unpow249.1%
Simplified49.1%
div-inv49.1%
add-sqr-sqrt49.1%
sqrt-unprod49.1%
frac-times49.1%
metadata-eval49.1%
add-sqr-sqrt49.2%
metadata-eval49.2%
Applied egg-rr49.2%
if 3.5e-66 < a2 < 1.90000000000000011e164 or 1.45000000000000003e173 < a2 Initial program 99.5%
distribute-lft-out99.6%
Simplified99.6%
clear-num99.6%
associate-/r/99.5%
pow1/299.5%
pow-flip99.6%
metadata-eval99.6%
Applied egg-rr99.6%
Taylor expanded in th around 0 65.1%
Taylor expanded in a1 around 0 47.6%
unpow247.6%
Simplified47.6%
if 1.90000000000000011e164 < a2 < 1.45000000000000003e173Initial program 100.0%
distribute-lft-out100.0%
associate-*l/100.0%
associate-*r/100.0%
fma-def100.0%
Simplified100.0%
Taylor expanded in th around 0 0.0%
unpow20.0%
unpow20.0%
+-commutative0.0%
Simplified0.0%
Taylor expanded in a1 around 0 0.0%
unpow20.0%
Simplified0.0%
Applied egg-rr100.0%
distribute-neg-frac100.0%
distribute-rgt-neg-out100.0%
Simplified100.0%
Final simplification49.3%
(FPCore (a1 a2 th) :precision binary64 (* (+ (* a1 a1) (* a2 a2)) (sqrt 0.5)))
double code(double a1, double a2, double th) {
return ((a1 * a1) + (a2 * a2)) * sqrt(0.5);
}
real(8) function code(a1, a2, th)
real(8), intent (in) :: a1
real(8), intent (in) :: a2
real(8), intent (in) :: th
code = ((a1 * a1) + (a2 * a2)) * sqrt(0.5d0)
end function
public static double code(double a1, double a2, double th) {
return ((a1 * a1) + (a2 * a2)) * Math.sqrt(0.5);
}
def code(a1, a2, th): return ((a1 * a1) + (a2 * a2)) * math.sqrt(0.5)
function code(a1, a2, th) return Float64(Float64(Float64(a1 * a1) + Float64(a2 * a2)) * sqrt(0.5)) end
function tmp = code(a1, a2, th) tmp = ((a1 * a1) + (a2 * a2)) * sqrt(0.5); end
code[a1_, a2_, th_] := N[(N[(N[(a1 * a1), $MachinePrecision] + N[(a2 * a2), $MachinePrecision]), $MachinePrecision] * N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(a1 \cdot a1 + a2 \cdot a2\right) \cdot \sqrt{0.5}
\end{array}
Initial program 99.5%
distribute-lft-out99.6%
Simplified99.6%
clear-num99.6%
associate-/r/99.5%
pow1/299.5%
pow-flip99.6%
metadata-eval99.6%
Applied egg-rr99.6%
Taylor expanded in th around 0 63.9%
Final simplification63.9%
(FPCore (a1 a2 th) :precision binary64 (if (<= a2 4.4e-66) (* (* a1 a1) (sqrt 0.5)) (* (* a2 a2) (sqrt 0.5))))
double code(double a1, double a2, double th) {
double tmp;
if (a2 <= 4.4e-66) {
tmp = (a1 * a1) * sqrt(0.5);
} else {
tmp = (a2 * a2) * sqrt(0.5);
}
return tmp;
}
real(8) function code(a1, a2, th)
real(8), intent (in) :: a1
real(8), intent (in) :: a2
real(8), intent (in) :: th
real(8) :: tmp
if (a2 <= 4.4d-66) then
tmp = (a1 * a1) * sqrt(0.5d0)
else
tmp = (a2 * a2) * sqrt(0.5d0)
end if
code = tmp
end function
public static double code(double a1, double a2, double th) {
double tmp;
if (a2 <= 4.4e-66) {
tmp = (a1 * a1) * Math.sqrt(0.5);
} else {
tmp = (a2 * a2) * Math.sqrt(0.5);
}
return tmp;
}
def code(a1, a2, th): tmp = 0 if a2 <= 4.4e-66: tmp = (a1 * a1) * math.sqrt(0.5) else: tmp = (a2 * a2) * math.sqrt(0.5) return tmp
function code(a1, a2, th) tmp = 0.0 if (a2 <= 4.4e-66) tmp = Float64(Float64(a1 * a1) * sqrt(0.5)); else tmp = Float64(Float64(a2 * a2) * sqrt(0.5)); end return tmp end
function tmp_2 = code(a1, a2, th) tmp = 0.0; if (a2 <= 4.4e-66) tmp = (a1 * a1) * sqrt(0.5); else tmp = (a2 * a2) * sqrt(0.5); end tmp_2 = tmp; end
code[a1_, a2_, th_] := If[LessEqual[a2, 4.4e-66], N[(N[(a1 * a1), $MachinePrecision] * N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision], N[(N[(a2 * a2), $MachinePrecision] * N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a2 \leq 4.4 \cdot 10^{-66}:\\
\;\;\;\;\left(a1 \cdot a1\right) \cdot \sqrt{0.5}\\
\mathbf{else}:\\
\;\;\;\;\left(a2 \cdot a2\right) \cdot \sqrt{0.5}\\
\end{array}
\end{array}
if a2 < 4.4000000000000002e-66Initial program 99.5%
distribute-lft-out99.5%
associate-*l/99.5%
associate-*r/99.5%
fma-def99.5%
Simplified99.5%
Taylor expanded in th around 0 64.3%
unpow264.3%
unpow264.3%
+-commutative64.3%
Simplified64.3%
Taylor expanded in a1 around inf 49.1%
unpow249.1%
Simplified49.1%
div-inv49.1%
add-sqr-sqrt49.1%
sqrt-unprod49.1%
frac-times49.1%
metadata-eval49.1%
add-sqr-sqrt49.2%
metadata-eval49.2%
Applied egg-rr49.2%
if 4.4000000000000002e-66 < a2 Initial program 99.6%
distribute-lft-out99.6%
Simplified99.6%
clear-num99.6%
associate-/r/99.5%
pow1/299.5%
pow-flip99.6%
metadata-eval99.6%
Applied egg-rr99.6%
Taylor expanded in th around 0 62.7%
Taylor expanded in a1 around 0 45.9%
unpow245.9%
Simplified45.9%
Final simplification48.2%
(FPCore (a1 a2 th) :precision binary64 (* (* a2 a2) (sqrt 0.5)))
double code(double a1, double a2, double th) {
return (a2 * a2) * sqrt(0.5);
}
real(8) function code(a1, a2, th)
real(8), intent (in) :: a1
real(8), intent (in) :: a2
real(8), intent (in) :: th
code = (a2 * a2) * sqrt(0.5d0)
end function
public static double code(double a1, double a2, double th) {
return (a2 * a2) * Math.sqrt(0.5);
}
def code(a1, a2, th): return (a2 * a2) * math.sqrt(0.5)
function code(a1, a2, th) return Float64(Float64(a2 * a2) * sqrt(0.5)) end
function tmp = code(a1, a2, th) tmp = (a2 * a2) * sqrt(0.5); end
code[a1_, a2_, th_] := N[(N[(a2 * a2), $MachinePrecision] * N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(a2 \cdot a2\right) \cdot \sqrt{0.5}
\end{array}
Initial program 99.5%
distribute-lft-out99.6%
Simplified99.6%
clear-num99.6%
associate-/r/99.5%
pow1/299.5%
pow-flip99.6%
metadata-eval99.6%
Applied egg-rr99.6%
Taylor expanded in th around 0 63.9%
Taylor expanded in a1 around 0 35.0%
unpow235.0%
Simplified35.0%
Final simplification35.0%
herbie shell --seed 2023171
(FPCore (a1 a2 th)
:name "Migdal et al, Equation (64)"
:precision binary64
(+ (* (/ (cos th) (sqrt 2.0)) (* a1 a1)) (* (/ (cos th) (sqrt 2.0)) (* a2 a2))))