
(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 8 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 (* (+ (* a1 a1) (* a2 a2)) (* (sqrt 0.5) (cos th))))
double code(double a1, double a2, double th) {
return ((a1 * a1) + (a2 * a2)) * (sqrt(0.5) * cos(th));
}
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) * cos(th))
end function
public static double code(double a1, double a2, double th) {
return ((a1 * a1) + (a2 * a2)) * (Math.sqrt(0.5) * Math.cos(th));
}
def code(a1, a2, th): return ((a1 * a1) + (a2 * a2)) * (math.sqrt(0.5) * math.cos(th))
function code(a1, a2, th) return Float64(Float64(Float64(a1 * a1) + Float64(a2 * a2)) * Float64(sqrt(0.5) * cos(th))) end
function tmp = code(a1, a2, th) tmp = ((a1 * a1) + (a2 * a2)) * (sqrt(0.5) * cos(th)); end
code[a1_, a2_, th_] := N[(N[(N[(a1 * a1), $MachinePrecision] + N[(a2 * a2), $MachinePrecision]), $MachinePrecision] * N[(N[Sqrt[0.5], $MachinePrecision] * N[Cos[th], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(a1 \cdot a1 + a2 \cdot a2\right) \cdot \left(\sqrt{0.5} \cdot \cos th\right)
\end{array}
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 inf 99.7%
*-commutative99.7%
Simplified99.7%
Final simplification99.7%
(FPCore (a1 a2 th) :precision binary64 (* a2 (* (cos th) (* (sqrt 0.5) a2))))
double code(double a1, double a2, double th) {
return a2 * (cos(th) * (sqrt(0.5) * a2));
}
real(8) function code(a1, a2, th)
real(8), intent (in) :: a1
real(8), intent (in) :: a2
real(8), intent (in) :: th
code = a2 * (cos(th) * (sqrt(0.5d0) * a2))
end function
public static double code(double a1, double a2, double th) {
return a2 * (Math.cos(th) * (Math.sqrt(0.5) * a2));
}
def code(a1, a2, th): return a2 * (math.cos(th) * (math.sqrt(0.5) * a2))
function code(a1, a2, th) return Float64(a2 * Float64(cos(th) * Float64(sqrt(0.5) * a2))) end
function tmp = code(a1, a2, th) tmp = a2 * (cos(th) * (sqrt(0.5) * a2)); end
code[a1_, a2_, th_] := N[(a2 * N[(N[Cos[th], $MachinePrecision] * N[(N[Sqrt[0.5], $MachinePrecision] * a2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
a2 \cdot \left(\cos th \cdot \left(\sqrt{0.5} \cdot a2\right)\right)
\end{array}
Initial program 99.5%
distribute-lft-out99.5%
cos-neg99.5%
associate-/r/99.3%
cos-neg99.3%
fma-def99.3%
Simplified99.3%
Taylor expanded in a1 around 0 62.7%
*-un-lft-identity62.7%
pow262.7%
times-frac62.7%
Applied egg-rr62.7%
associate-*l/62.7%
*-lft-identity62.7%
Simplified62.7%
associate-/r/63.0%
div-inv63.0%
clear-num62.9%
div-inv62.9%
add-sqr-sqrt62.9%
sqrt-unprod62.9%
frac-times62.9%
metadata-eval62.9%
rem-square-sqrt63.0%
metadata-eval63.0%
Applied egg-rr63.0%
Final simplification63.0%
(FPCore (a1 a2 th) :precision binary64 (* a2 (* (sqrt 0.5) (* (cos th) a2))))
double code(double a1, double a2, double th) {
return a2 * (sqrt(0.5) * (cos(th) * a2));
}
real(8) function code(a1, a2, th)
real(8), intent (in) :: a1
real(8), intent (in) :: a2
real(8), intent (in) :: th
code = a2 * (sqrt(0.5d0) * (cos(th) * a2))
end function
public static double code(double a1, double a2, double th) {
return a2 * (Math.sqrt(0.5) * (Math.cos(th) * a2));
}
def code(a1, a2, th): return a2 * (math.sqrt(0.5) * (math.cos(th) * a2))
function code(a1, a2, th) return Float64(a2 * Float64(sqrt(0.5) * Float64(cos(th) * a2))) end
function tmp = code(a1, a2, th) tmp = a2 * (sqrt(0.5) * (cos(th) * a2)); end
code[a1_, a2_, th_] := N[(a2 * N[(N[Sqrt[0.5], $MachinePrecision] * N[(N[Cos[th], $MachinePrecision] * a2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
a2 \cdot \left(\sqrt{0.5} \cdot \left(\cos th \cdot a2\right)\right)
\end{array}
Initial program 99.5%
distribute-lft-out99.5%
cos-neg99.5%
associate-/r/99.3%
cos-neg99.3%
fma-def99.3%
Simplified99.3%
Taylor expanded in a1 around 0 62.7%
*-un-lft-identity62.7%
pow262.7%
times-frac62.7%
Applied egg-rr62.7%
associate-*l/62.7%
*-lft-identity62.7%
Simplified62.7%
clear-num62.6%
associate-/r/62.7%
associate-/l/62.7%
clear-num62.9%
div-inv62.9%
add-sqr-sqrt62.9%
sqrt-unprod62.9%
frac-times62.9%
metadata-eval62.9%
rem-square-sqrt63.0%
metadata-eval63.0%
associate-*r*63.0%
*-commutative63.0%
associate-*r*63.0%
Applied egg-rr63.0%
Taylor expanded in th around inf 63.0%
*-commutative63.0%
*-commutative63.0%
associate-*r*63.0%
*-commutative63.0%
Simplified63.0%
Final simplification63.0%
(FPCore (a1 a2 th) :precision binary64 (* a2 (* a2 (* (sqrt 0.5) (cos th)))))
double code(double a1, double a2, double th) {
return a2 * (a2 * (sqrt(0.5) * cos(th)));
}
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) * cos(th)))
end function
public static double code(double a1, double a2, double th) {
return a2 * (a2 * (Math.sqrt(0.5) * Math.cos(th)));
}
def code(a1, a2, th): return a2 * (a2 * (math.sqrt(0.5) * math.cos(th)))
function code(a1, a2, th) return Float64(a2 * Float64(a2 * Float64(sqrt(0.5) * cos(th)))) end
function tmp = code(a1, a2, th) tmp = a2 * (a2 * (sqrt(0.5) * cos(th))); end
code[a1_, a2_, th_] := N[(a2 * N[(a2 * N[(N[Sqrt[0.5], $MachinePrecision] * N[Cos[th], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
a2 \cdot \left(a2 \cdot \left(\sqrt{0.5} \cdot \cos th\right)\right)
\end{array}
Initial program 99.5%
distribute-lft-out99.5%
cos-neg99.5%
associate-/r/99.3%
cos-neg99.3%
fma-def99.3%
Simplified99.3%
Taylor expanded in a1 around 0 62.7%
pow262.7%
associate-/r/62.9%
pow1/262.9%
metadata-eval62.9%
pow-prod-up63.0%
associate-/l/63.0%
associate-*r*63.0%
Applied egg-rr63.0%
Final simplification63.0%
(FPCore (a1 a2 th)
:precision binary64
(if (<= th 1.8e+90)
(* a2 (* (sqrt 0.5) a2))
(if (or (<= th 6e+205) (not (<= th 4.8e+260)))
(* (/ a2 (sqrt 2.0)) (- a2))
(/ 1.0 (/ (/ (sqrt 2.0) a2) a2)))))
double code(double a1, double a2, double th) {
double tmp;
if (th <= 1.8e+90) {
tmp = a2 * (sqrt(0.5) * a2);
} else if ((th <= 6e+205) || !(th <= 4.8e+260)) {
tmp = (a2 / sqrt(2.0)) * -a2;
} else {
tmp = 1.0 / ((sqrt(2.0) / a2) / a2);
}
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 (th <= 1.8d+90) then
tmp = a2 * (sqrt(0.5d0) * a2)
else if ((th <= 6d+205) .or. (.not. (th <= 4.8d+260))) then
tmp = (a2 / sqrt(2.0d0)) * -a2
else
tmp = 1.0d0 / ((sqrt(2.0d0) / a2) / a2)
end if
code = tmp
end function
public static double code(double a1, double a2, double th) {
double tmp;
if (th <= 1.8e+90) {
tmp = a2 * (Math.sqrt(0.5) * a2);
} else if ((th <= 6e+205) || !(th <= 4.8e+260)) {
tmp = (a2 / Math.sqrt(2.0)) * -a2;
} else {
tmp = 1.0 / ((Math.sqrt(2.0) / a2) / a2);
}
return tmp;
}
def code(a1, a2, th): tmp = 0 if th <= 1.8e+90: tmp = a2 * (math.sqrt(0.5) * a2) elif (th <= 6e+205) or not (th <= 4.8e+260): tmp = (a2 / math.sqrt(2.0)) * -a2 else: tmp = 1.0 / ((math.sqrt(2.0) / a2) / a2) return tmp
function code(a1, a2, th) tmp = 0.0 if (th <= 1.8e+90) tmp = Float64(a2 * Float64(sqrt(0.5) * a2)); elseif ((th <= 6e+205) || !(th <= 4.8e+260)) tmp = Float64(Float64(a2 / sqrt(2.0)) * Float64(-a2)); else tmp = Float64(1.0 / Float64(Float64(sqrt(2.0) / a2) / a2)); end return tmp end
function tmp_2 = code(a1, a2, th) tmp = 0.0; if (th <= 1.8e+90) tmp = a2 * (sqrt(0.5) * a2); elseif ((th <= 6e+205) || ~((th <= 4.8e+260))) tmp = (a2 / sqrt(2.0)) * -a2; else tmp = 1.0 / ((sqrt(2.0) / a2) / a2); end tmp_2 = tmp; end
code[a1_, a2_, th_] := If[LessEqual[th, 1.8e+90], N[(a2 * N[(N[Sqrt[0.5], $MachinePrecision] * a2), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[th, 6e+205], N[Not[LessEqual[th, 4.8e+260]], $MachinePrecision]], N[(N[(a2 / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] * (-a2)), $MachinePrecision], N[(1.0 / N[(N[(N[Sqrt[2.0], $MachinePrecision] / a2), $MachinePrecision] / a2), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;th \leq 1.8 \cdot 10^{+90}:\\
\;\;\;\;a2 \cdot \left(\sqrt{0.5} \cdot a2\right)\\
\mathbf{elif}\;th \leq 6 \cdot 10^{+205} \lor \neg \left(th \leq 4.8 \cdot 10^{+260}\right):\\
\;\;\;\;\frac{a2}{\sqrt{2}} \cdot \left(-a2\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{\frac{\sqrt{2}}{a2}}{a2}}\\
\end{array}
\end{array}
if th < 1.8e90Initial program 99.6%
distribute-lft-out99.6%
cos-neg99.6%
associate-/r/99.6%
cos-neg99.6%
fma-def99.6%
Simplified99.6%
Taylor expanded in a1 around 0 61.3%
Taylor expanded in th around 0 43.1%
pow243.1%
associate-/r/43.1%
add-sqr-sqrt43.1%
sqrt-unprod43.1%
frac-times43.1%
metadata-eval43.1%
rem-square-sqrt43.1%
metadata-eval43.1%
associate-*r*43.1%
Applied egg-rr43.1%
if 1.8e90 < th < 5.9999999999999999e205 or 4.8000000000000002e260 < th Initial program 99.3%
distribute-lft-out99.3%
cos-neg99.3%
associate-/r/97.7%
cos-neg97.7%
fma-def97.7%
Simplified97.7%
Taylor expanded in a1 around 0 59.9%
Taylor expanded in th around 0 14.9%
pow214.9%
associate-/l/14.9%
clear-num14.8%
frac-2neg14.8%
associate-/r/14.8%
Applied egg-rr14.8%
Applied egg-rr12.3%
expm1-def12.5%
expm1-log1p24.2%
Simplified24.2%
if 5.9999999999999999e205 < th < 4.8000000000000002e260Initial program 99.9%
distribute-lft-out99.9%
cos-neg99.9%
associate-/r/99.4%
cos-neg99.4%
fma-def99.4%
Simplified99.4%
Taylor expanded in a1 around 0 91.8%
*-un-lft-identity91.8%
pow291.8%
times-frac91.8%
Applied egg-rr91.8%
associate-*l/91.6%
*-lft-identity91.6%
Simplified91.6%
Taylor expanded in th around 0 63.2%
Final simplification41.5%
(FPCore (a1 a2 th)
:precision binary64
(if (<= th 1.8e+90)
(* (sqrt 0.5) (+ (* a1 a1) (* a2 a2)))
(if (or (<= th 6e+205) (not (<= th 4.8e+260)))
(* (/ a2 (sqrt 2.0)) (- a2))
(/ 1.0 (/ (/ (sqrt 2.0) a2) a2)))))
double code(double a1, double a2, double th) {
double tmp;
if (th <= 1.8e+90) {
tmp = sqrt(0.5) * ((a1 * a1) + (a2 * a2));
} else if ((th <= 6e+205) || !(th <= 4.8e+260)) {
tmp = (a2 / sqrt(2.0)) * -a2;
} else {
tmp = 1.0 / ((sqrt(2.0) / a2) / a2);
}
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 (th <= 1.8d+90) then
tmp = sqrt(0.5d0) * ((a1 * a1) + (a2 * a2))
else if ((th <= 6d+205) .or. (.not. (th <= 4.8d+260))) then
tmp = (a2 / sqrt(2.0d0)) * -a2
else
tmp = 1.0d0 / ((sqrt(2.0d0) / a2) / a2)
end if
code = tmp
end function
public static double code(double a1, double a2, double th) {
double tmp;
if (th <= 1.8e+90) {
tmp = Math.sqrt(0.5) * ((a1 * a1) + (a2 * a2));
} else if ((th <= 6e+205) || !(th <= 4.8e+260)) {
tmp = (a2 / Math.sqrt(2.0)) * -a2;
} else {
tmp = 1.0 / ((Math.sqrt(2.0) / a2) / a2);
}
return tmp;
}
def code(a1, a2, th): tmp = 0 if th <= 1.8e+90: tmp = math.sqrt(0.5) * ((a1 * a1) + (a2 * a2)) elif (th <= 6e+205) or not (th <= 4.8e+260): tmp = (a2 / math.sqrt(2.0)) * -a2 else: tmp = 1.0 / ((math.sqrt(2.0) / a2) / a2) return tmp
function code(a1, a2, th) tmp = 0.0 if (th <= 1.8e+90) tmp = Float64(sqrt(0.5) * Float64(Float64(a1 * a1) + Float64(a2 * a2))); elseif ((th <= 6e+205) || !(th <= 4.8e+260)) tmp = Float64(Float64(a2 / sqrt(2.0)) * Float64(-a2)); else tmp = Float64(1.0 / Float64(Float64(sqrt(2.0) / a2) / a2)); end return tmp end
function tmp_2 = code(a1, a2, th) tmp = 0.0; if (th <= 1.8e+90) tmp = sqrt(0.5) * ((a1 * a1) + (a2 * a2)); elseif ((th <= 6e+205) || ~((th <= 4.8e+260))) tmp = (a2 / sqrt(2.0)) * -a2; else tmp = 1.0 / ((sqrt(2.0) / a2) / a2); end tmp_2 = tmp; end
code[a1_, a2_, th_] := If[LessEqual[th, 1.8e+90], N[(N[Sqrt[0.5], $MachinePrecision] * N[(N[(a1 * a1), $MachinePrecision] + N[(a2 * a2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[th, 6e+205], N[Not[LessEqual[th, 4.8e+260]], $MachinePrecision]], N[(N[(a2 / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] * (-a2)), $MachinePrecision], N[(1.0 / N[(N[(N[Sqrt[2.0], $MachinePrecision] / a2), $MachinePrecision] / a2), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;th \leq 1.8 \cdot 10^{+90}:\\
\;\;\;\;\sqrt{0.5} \cdot \left(a1 \cdot a1 + a2 \cdot a2\right)\\
\mathbf{elif}\;th \leq 6 \cdot 10^{+205} \lor \neg \left(th \leq 4.8 \cdot 10^{+260}\right):\\
\;\;\;\;\frac{a2}{\sqrt{2}} \cdot \left(-a2\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{\frac{\sqrt{2}}{a2}}{a2}}\\
\end{array}
\end{array}
if th < 1.8e90Initial program 99.6%
distribute-lft-out99.6%
Simplified99.6%
clear-num99.6%
associate-/r/99.5%
pow1/299.5%
pow-flip99.7%
metadata-eval99.7%
Applied egg-rr99.7%
Taylor expanded in th around 0 69.8%
if 1.8e90 < th < 5.9999999999999999e205 or 4.8000000000000002e260 < th Initial program 99.3%
distribute-lft-out99.3%
cos-neg99.3%
associate-/r/97.7%
cos-neg97.7%
fma-def97.7%
Simplified97.7%
Taylor expanded in a1 around 0 59.9%
Taylor expanded in th around 0 14.9%
pow214.9%
associate-/l/14.9%
clear-num14.8%
frac-2neg14.8%
associate-/r/14.8%
Applied egg-rr14.8%
Applied egg-rr12.3%
expm1-def12.5%
expm1-log1p24.2%
Simplified24.2%
if 5.9999999999999999e205 < th < 4.8000000000000002e260Initial program 99.9%
distribute-lft-out99.9%
cos-neg99.9%
associate-/r/99.4%
cos-neg99.4%
fma-def99.4%
Simplified99.4%
Taylor expanded in a1 around 0 91.8%
*-un-lft-identity91.8%
pow291.8%
times-frac91.8%
Applied egg-rr91.8%
associate-*l/91.6%
*-lft-identity91.6%
Simplified91.6%
Taylor expanded in th around 0 63.2%
Final simplification63.1%
(FPCore (a1 a2 th) :precision binary64 (if (or (<= th 1.8e+90) (and (not (<= th 6e+205)) (<= th 4.8e+260))) (* a2 (* (sqrt 0.5) a2)) (* (/ a2 (sqrt 2.0)) (- a2))))
double code(double a1, double a2, double th) {
double tmp;
if ((th <= 1.8e+90) || (!(th <= 6e+205) && (th <= 4.8e+260))) {
tmp = a2 * (sqrt(0.5) * a2);
} else {
tmp = (a2 / sqrt(2.0)) * -a2;
}
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 ((th <= 1.8d+90) .or. (.not. (th <= 6d+205)) .and. (th <= 4.8d+260)) then
tmp = a2 * (sqrt(0.5d0) * a2)
else
tmp = (a2 / sqrt(2.0d0)) * -a2
end if
code = tmp
end function
public static double code(double a1, double a2, double th) {
double tmp;
if ((th <= 1.8e+90) || (!(th <= 6e+205) && (th <= 4.8e+260))) {
tmp = a2 * (Math.sqrt(0.5) * a2);
} else {
tmp = (a2 / Math.sqrt(2.0)) * -a2;
}
return tmp;
}
def code(a1, a2, th): tmp = 0 if (th <= 1.8e+90) or (not (th <= 6e+205) and (th <= 4.8e+260)): tmp = a2 * (math.sqrt(0.5) * a2) else: tmp = (a2 / math.sqrt(2.0)) * -a2 return tmp
function code(a1, a2, th) tmp = 0.0 if ((th <= 1.8e+90) || (!(th <= 6e+205) && (th <= 4.8e+260))) tmp = Float64(a2 * Float64(sqrt(0.5) * a2)); else tmp = Float64(Float64(a2 / sqrt(2.0)) * Float64(-a2)); end return tmp end
function tmp_2 = code(a1, a2, th) tmp = 0.0; if ((th <= 1.8e+90) || (~((th <= 6e+205)) && (th <= 4.8e+260))) tmp = a2 * (sqrt(0.5) * a2); else tmp = (a2 / sqrt(2.0)) * -a2; end tmp_2 = tmp; end
code[a1_, a2_, th_] := If[Or[LessEqual[th, 1.8e+90], And[N[Not[LessEqual[th, 6e+205]], $MachinePrecision], LessEqual[th, 4.8e+260]]], N[(a2 * N[(N[Sqrt[0.5], $MachinePrecision] * a2), $MachinePrecision]), $MachinePrecision], N[(N[(a2 / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] * (-a2)), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;th \leq 1.8 \cdot 10^{+90} \lor \neg \left(th \leq 6 \cdot 10^{+205}\right) \land th \leq 4.8 \cdot 10^{+260}:\\
\;\;\;\;a2 \cdot \left(\sqrt{0.5} \cdot a2\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{a2}{\sqrt{2}} \cdot \left(-a2\right)\\
\end{array}
\end{array}
if th < 1.8e90 or 5.9999999999999999e205 < th < 4.8000000000000002e260Initial program 99.6%
distribute-lft-out99.6%
cos-neg99.6%
associate-/r/99.6%
cos-neg99.6%
fma-def99.6%
Simplified99.6%
Taylor expanded in a1 around 0 63.1%
Taylor expanded in th around 0 44.3%
pow244.3%
associate-/r/44.2%
add-sqr-sqrt44.2%
sqrt-unprod44.2%
frac-times44.2%
metadata-eval44.2%
rem-square-sqrt44.3%
metadata-eval44.3%
associate-*r*44.3%
Applied egg-rr44.3%
if 1.8e90 < th < 5.9999999999999999e205 or 4.8000000000000002e260 < th Initial program 99.3%
distribute-lft-out99.3%
cos-neg99.3%
associate-/r/97.7%
cos-neg97.7%
fma-def97.7%
Simplified97.7%
Taylor expanded in a1 around 0 59.9%
Taylor expanded in th around 0 14.9%
pow214.9%
associate-/l/14.9%
clear-num14.8%
frac-2neg14.8%
associate-/r/14.8%
Applied egg-rr14.8%
Applied egg-rr12.3%
expm1-def12.5%
expm1-log1p24.2%
Simplified24.2%
Final simplification41.4%
(FPCore (a1 a2 th) :precision binary64 (* a2 (* (sqrt 0.5) a2)))
double code(double a1, double a2, double th) {
return a2 * (sqrt(0.5) * a2);
}
real(8) function code(a1, a2, th)
real(8), intent (in) :: a1
real(8), intent (in) :: a2
real(8), intent (in) :: th
code = a2 * (sqrt(0.5d0) * a2)
end function
public static double code(double a1, double a2, double th) {
return a2 * (Math.sqrt(0.5) * a2);
}
def code(a1, a2, th): return a2 * (math.sqrt(0.5) * a2)
function code(a1, a2, th) return Float64(a2 * Float64(sqrt(0.5) * a2)) end
function tmp = code(a1, a2, th) tmp = a2 * (sqrt(0.5) * a2); end
code[a1_, a2_, th_] := N[(a2 * N[(N[Sqrt[0.5], $MachinePrecision] * a2), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
a2 \cdot \left(\sqrt{0.5} \cdot a2\right)
\end{array}
Initial program 99.5%
distribute-lft-out99.5%
cos-neg99.5%
associate-/r/99.3%
cos-neg99.3%
fma-def99.3%
Simplified99.3%
Taylor expanded in a1 around 0 62.7%
Taylor expanded in th around 0 40.1%
pow240.1%
associate-/r/40.1%
add-sqr-sqrt40.1%
sqrt-unprod40.1%
frac-times40.1%
metadata-eval40.1%
rem-square-sqrt40.1%
metadata-eval40.1%
associate-*r*40.1%
Applied egg-rr40.1%
Final simplification40.1%
herbie shell --seed 2023305
(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))))