
(FPCore (eh ew t) :precision binary64 (let* ((t_1 (atan (/ (* (- eh) (tan t)) ew)))) (fabs (- (* (* ew (cos t)) (cos t_1)) (* (* eh (sin t)) (sin t_1))))))
double code(double eh, double ew, double t) {
double t_1 = atan(((-eh * tan(t)) / ew));
return fabs((((ew * cos(t)) * cos(t_1)) - ((eh * sin(t)) * sin(t_1))));
}
real(8) function code(eh, ew, t)
real(8), intent (in) :: eh
real(8), intent (in) :: ew
real(8), intent (in) :: t
real(8) :: t_1
t_1 = atan(((-eh * tan(t)) / ew))
code = abs((((ew * cos(t)) * cos(t_1)) - ((eh * sin(t)) * sin(t_1))))
end function
public static double code(double eh, double ew, double t) {
double t_1 = Math.atan(((-eh * Math.tan(t)) / ew));
return Math.abs((((ew * Math.cos(t)) * Math.cos(t_1)) - ((eh * Math.sin(t)) * Math.sin(t_1))));
}
def code(eh, ew, t): t_1 = math.atan(((-eh * math.tan(t)) / ew)) return math.fabs((((ew * math.cos(t)) * math.cos(t_1)) - ((eh * math.sin(t)) * math.sin(t_1))))
function code(eh, ew, t) t_1 = atan(Float64(Float64(Float64(-eh) * tan(t)) / ew)) return abs(Float64(Float64(Float64(ew * cos(t)) * cos(t_1)) - Float64(Float64(eh * sin(t)) * sin(t_1)))) end
function tmp = code(eh, ew, t) t_1 = atan(((-eh * tan(t)) / ew)); tmp = abs((((ew * cos(t)) * cos(t_1)) - ((eh * sin(t)) * sin(t_1)))); end
code[eh_, ew_, t_] := Block[{t$95$1 = N[ArcTan[N[(N[((-eh) * N[Tan[t], $MachinePrecision]), $MachinePrecision] / ew), $MachinePrecision]], $MachinePrecision]}, N[Abs[N[(N[(N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$1], $MachinePrecision]), $MachinePrecision] - N[(N[(eh * N[Sin[t], $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \tan^{-1} \left(\frac{\left(-eh\right) \cdot \tan t}{ew}\right)\\
\left|\left(ew \cdot \cos t\right) \cdot \cos t\_1 - \left(eh \cdot \sin t\right) \cdot \sin t\_1\right|
\end{array}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 18 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (eh ew t) :precision binary64 (let* ((t_1 (atan (/ (* (- eh) (tan t)) ew)))) (fabs (- (* (* ew (cos t)) (cos t_1)) (* (* eh (sin t)) (sin t_1))))))
double code(double eh, double ew, double t) {
double t_1 = atan(((-eh * tan(t)) / ew));
return fabs((((ew * cos(t)) * cos(t_1)) - ((eh * sin(t)) * sin(t_1))));
}
real(8) function code(eh, ew, t)
real(8), intent (in) :: eh
real(8), intent (in) :: ew
real(8), intent (in) :: t
real(8) :: t_1
t_1 = atan(((-eh * tan(t)) / ew))
code = abs((((ew * cos(t)) * cos(t_1)) - ((eh * sin(t)) * sin(t_1))))
end function
public static double code(double eh, double ew, double t) {
double t_1 = Math.atan(((-eh * Math.tan(t)) / ew));
return Math.abs((((ew * Math.cos(t)) * Math.cos(t_1)) - ((eh * Math.sin(t)) * Math.sin(t_1))));
}
def code(eh, ew, t): t_1 = math.atan(((-eh * math.tan(t)) / ew)) return math.fabs((((ew * math.cos(t)) * math.cos(t_1)) - ((eh * math.sin(t)) * math.sin(t_1))))
function code(eh, ew, t) t_1 = atan(Float64(Float64(Float64(-eh) * tan(t)) / ew)) return abs(Float64(Float64(Float64(ew * cos(t)) * cos(t_1)) - Float64(Float64(eh * sin(t)) * sin(t_1)))) end
function tmp = code(eh, ew, t) t_1 = atan(((-eh * tan(t)) / ew)); tmp = abs((((ew * cos(t)) * cos(t_1)) - ((eh * sin(t)) * sin(t_1)))); end
code[eh_, ew_, t_] := Block[{t$95$1 = N[ArcTan[N[(N[((-eh) * N[Tan[t], $MachinePrecision]), $MachinePrecision] / ew), $MachinePrecision]], $MachinePrecision]}, N[Abs[N[(N[(N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$1], $MachinePrecision]), $MachinePrecision] - N[(N[(eh * N[Sin[t], $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \tan^{-1} \left(\frac{\left(-eh\right) \cdot \tan t}{ew}\right)\\
\left|\left(ew \cdot \cos t\right) \cdot \cos t\_1 - \left(eh \cdot \sin t\right) \cdot \sin t\_1\right|
\end{array}
\end{array}
(FPCore (eh ew t) :precision binary64 (fabs (- (/ (* ew (cos t)) (hypot 1.0 (* (tan t) (/ eh ew)))) (* eh (* (sin t) (sin (atan (* eh (/ (tan t) (- ew))))))))))
double code(double eh, double ew, double t) {
return fabs((((ew * cos(t)) / hypot(1.0, (tan(t) * (eh / ew)))) - (eh * (sin(t) * sin(atan((eh * (tan(t) / -ew))))))));
}
public static double code(double eh, double ew, double t) {
return Math.abs((((ew * Math.cos(t)) / Math.hypot(1.0, (Math.tan(t) * (eh / ew)))) - (eh * (Math.sin(t) * Math.sin(Math.atan((eh * (Math.tan(t) / -ew))))))));
}
def code(eh, ew, t): return math.fabs((((ew * math.cos(t)) / math.hypot(1.0, (math.tan(t) * (eh / ew)))) - (eh * (math.sin(t) * math.sin(math.atan((eh * (math.tan(t) / -ew))))))))
function code(eh, ew, t) return abs(Float64(Float64(Float64(ew * cos(t)) / hypot(1.0, Float64(tan(t) * Float64(eh / ew)))) - Float64(eh * Float64(sin(t) * sin(atan(Float64(eh * Float64(tan(t) / Float64(-ew))))))))) end
function tmp = code(eh, ew, t) tmp = abs((((ew * cos(t)) / hypot(1.0, (tan(t) * (eh / ew)))) - (eh * (sin(t) * sin(atan((eh * (tan(t) / -ew)))))))); end
code[eh_, ew_, t_] := N[Abs[N[(N[(N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision] / N[Sqrt[1.0 ^ 2 + N[(N[Tan[t], $MachinePrecision] * N[(eh / ew), $MachinePrecision]), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] - N[(eh * N[(N[Sin[t], $MachinePrecision] * N[Sin[N[ArcTan[N[(eh * N[(N[Tan[t], $MachinePrecision] / (-ew)), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\left|\frac{ew \cdot \cos t}{\mathsf{hypot}\left(1, \tan t \cdot \frac{eh}{ew}\right)} - eh \cdot \left(\sin t \cdot \sin \tan^{-1} \left(eh \cdot \frac{\tan t}{-ew}\right)\right)\right|
\end{array}
Initial program 99.8%
sub-neg99.8%
associate-*l*99.8%
distribute-rgt-neg-in99.8%
cancel-sign-sub99.8%
associate-/l*99.8%
Simplified99.8%
cos-atan99.8%
un-div-inv99.8%
hypot-1-def99.8%
associate-*r/99.8%
*-commutative99.8%
associate-/l*99.8%
add-sqr-sqrt51.0%
sqrt-unprod93.6%
sqr-neg93.6%
sqrt-unprod48.8%
add-sqr-sqrt99.8%
Applied egg-rr99.8%
Final simplification99.8%
(FPCore (eh ew t)
:precision binary64
(let* ((t_1 (atan (* eh (/ (tan t) (- ew))))))
(if (<= ew -1.1e+23)
(fabs (* (* ew (cos t)) (cos t_1)))
(if (<= ew 2.25e+30)
(fabs
(-
(/ ew (hypot 1.0 (* (tan t) (/ eh ew))))
(* eh (* (sin t) (sin t_1)))))
(* ew (fabs (cos t)))))))
double code(double eh, double ew, double t) {
double t_1 = atan((eh * (tan(t) / -ew)));
double tmp;
if (ew <= -1.1e+23) {
tmp = fabs(((ew * cos(t)) * cos(t_1)));
} else if (ew <= 2.25e+30) {
tmp = fabs(((ew / hypot(1.0, (tan(t) * (eh / ew)))) - (eh * (sin(t) * sin(t_1)))));
} else {
tmp = ew * fabs(cos(t));
}
return tmp;
}
public static double code(double eh, double ew, double t) {
double t_1 = Math.atan((eh * (Math.tan(t) / -ew)));
double tmp;
if (ew <= -1.1e+23) {
tmp = Math.abs(((ew * Math.cos(t)) * Math.cos(t_1)));
} else if (ew <= 2.25e+30) {
tmp = Math.abs(((ew / Math.hypot(1.0, (Math.tan(t) * (eh / ew)))) - (eh * (Math.sin(t) * Math.sin(t_1)))));
} else {
tmp = ew * Math.abs(Math.cos(t));
}
return tmp;
}
def code(eh, ew, t): t_1 = math.atan((eh * (math.tan(t) / -ew))) tmp = 0 if ew <= -1.1e+23: tmp = math.fabs(((ew * math.cos(t)) * math.cos(t_1))) elif ew <= 2.25e+30: tmp = math.fabs(((ew / math.hypot(1.0, (math.tan(t) * (eh / ew)))) - (eh * (math.sin(t) * math.sin(t_1))))) else: tmp = ew * math.fabs(math.cos(t)) return tmp
function code(eh, ew, t) t_1 = atan(Float64(eh * Float64(tan(t) / Float64(-ew)))) tmp = 0.0 if (ew <= -1.1e+23) tmp = abs(Float64(Float64(ew * cos(t)) * cos(t_1))); elseif (ew <= 2.25e+30) tmp = abs(Float64(Float64(ew / hypot(1.0, Float64(tan(t) * Float64(eh / ew)))) - Float64(eh * Float64(sin(t) * sin(t_1))))); else tmp = Float64(ew * abs(cos(t))); end return tmp end
function tmp_2 = code(eh, ew, t) t_1 = atan((eh * (tan(t) / -ew))); tmp = 0.0; if (ew <= -1.1e+23) tmp = abs(((ew * cos(t)) * cos(t_1))); elseif (ew <= 2.25e+30) tmp = abs(((ew / hypot(1.0, (tan(t) * (eh / ew)))) - (eh * (sin(t) * sin(t_1))))); else tmp = ew * abs(cos(t)); end tmp_2 = tmp; end
code[eh_, ew_, t_] := Block[{t$95$1 = N[ArcTan[N[(eh * N[(N[Tan[t], $MachinePrecision] / (-ew)), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[ew, -1.1e+23], N[Abs[N[(N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$1], $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[ew, 2.25e+30], N[Abs[N[(N[(ew / N[Sqrt[1.0 ^ 2 + N[(N[Tan[t], $MachinePrecision] * N[(eh / ew), $MachinePrecision]), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] - N[(eh * N[(N[Sin[t], $MachinePrecision] * N[Sin[t$95$1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(ew * N[Abs[N[Cos[t], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \tan^{-1} \left(eh \cdot \frac{\tan t}{-ew}\right)\\
\mathbf{if}\;ew \leq -1.1 \cdot 10^{+23}:\\
\;\;\;\;\left|\left(ew \cdot \cos t\right) \cdot \cos t\_1\right|\\
\mathbf{elif}\;ew \leq 2.25 \cdot 10^{+30}:\\
\;\;\;\;\left|\frac{ew}{\mathsf{hypot}\left(1, \tan t \cdot \frac{eh}{ew}\right)} - eh \cdot \left(\sin t \cdot \sin t\_1\right)\right|\\
\mathbf{else}:\\
\;\;\;\;ew \cdot \left|\cos t\right|\\
\end{array}
\end{array}
if ew < -1.10000000000000004e23Initial program 99.8%
sub-neg99.8%
associate-*l*99.8%
distribute-rgt-neg-in99.8%
cancel-sign-sub99.8%
associate-/l*99.8%
Simplified99.8%
Taylor expanded in ew around inf 91.4%
associate-*r*91.4%
mul-1-neg91.4%
distribute-frac-neg291.4%
associate-/l*91.4%
Simplified91.4%
if -1.10000000000000004e23 < ew < 2.24999999999999997e30Initial program 99.8%
sub-neg99.8%
associate-*l*99.8%
distribute-rgt-neg-in99.8%
cancel-sign-sub99.8%
associate-/l*99.8%
Simplified99.8%
cos-atan99.8%
un-div-inv99.8%
hypot-1-def99.8%
associate-*r/99.8%
*-commutative99.8%
associate-/l*99.8%
add-sqr-sqrt52.7%
sqrt-unprod98.7%
sqr-neg98.7%
sqrt-unprod47.0%
add-sqr-sqrt99.8%
Applied egg-rr99.8%
Taylor expanded in t around 0 86.7%
if 2.24999999999999997e30 < ew Initial program 99.8%
sub-neg99.8%
associate-*l*99.8%
distribute-rgt-neg-in99.8%
cancel-sign-sub99.8%
associate-/l*99.8%
Simplified99.8%
Applied egg-rr73.9%
Taylor expanded in ew around inf 71.2%
add-sqr-sqrt71.0%
sqrt-unprod91.4%
pow291.4%
Applied egg-rr91.4%
unpow291.4%
rem-sqrt-square91.4%
Simplified91.4%
Final simplification88.8%
(FPCore (eh ew t)
:precision binary64
(let* ((t_1 (atan (* eh (/ (tan t) (- ew))))))
(if (<= t -3.9e+186)
(* ew (+ (cos t) (* eh (/ (* (sin t) (sin (atan (/ (* t eh) ew)))) ew))))
(if (or (<= t -0.00028) (not (<= t 1.15e-24)))
(fabs (* (* ew (cos t)) (cos t_1)))
(fabs (- ew (* (sin t_1) (* t eh))))))))
double code(double eh, double ew, double t) {
double t_1 = atan((eh * (tan(t) / -ew)));
double tmp;
if (t <= -3.9e+186) {
tmp = ew * (cos(t) + (eh * ((sin(t) * sin(atan(((t * eh) / ew)))) / ew)));
} else if ((t <= -0.00028) || !(t <= 1.15e-24)) {
tmp = fabs(((ew * cos(t)) * cos(t_1)));
} else {
tmp = fabs((ew - (sin(t_1) * (t * eh))));
}
return tmp;
}
real(8) function code(eh, ew, t)
real(8), intent (in) :: eh
real(8), intent (in) :: ew
real(8), intent (in) :: t
real(8) :: t_1
real(8) :: tmp
t_1 = atan((eh * (tan(t) / -ew)))
if (t <= (-3.9d+186)) then
tmp = ew * (cos(t) + (eh * ((sin(t) * sin(atan(((t * eh) / ew)))) / ew)))
else if ((t <= (-0.00028d0)) .or. (.not. (t <= 1.15d-24))) then
tmp = abs(((ew * cos(t)) * cos(t_1)))
else
tmp = abs((ew - (sin(t_1) * (t * eh))))
end if
code = tmp
end function
public static double code(double eh, double ew, double t) {
double t_1 = Math.atan((eh * (Math.tan(t) / -ew)));
double tmp;
if (t <= -3.9e+186) {
tmp = ew * (Math.cos(t) + (eh * ((Math.sin(t) * Math.sin(Math.atan(((t * eh) / ew)))) / ew)));
} else if ((t <= -0.00028) || !(t <= 1.15e-24)) {
tmp = Math.abs(((ew * Math.cos(t)) * Math.cos(t_1)));
} else {
tmp = Math.abs((ew - (Math.sin(t_1) * (t * eh))));
}
return tmp;
}
def code(eh, ew, t): t_1 = math.atan((eh * (math.tan(t) / -ew))) tmp = 0 if t <= -3.9e+186: tmp = ew * (math.cos(t) + (eh * ((math.sin(t) * math.sin(math.atan(((t * eh) / ew)))) / ew))) elif (t <= -0.00028) or not (t <= 1.15e-24): tmp = math.fabs(((ew * math.cos(t)) * math.cos(t_1))) else: tmp = math.fabs((ew - (math.sin(t_1) * (t * eh)))) return tmp
function code(eh, ew, t) t_1 = atan(Float64(eh * Float64(tan(t) / Float64(-ew)))) tmp = 0.0 if (t <= -3.9e+186) tmp = Float64(ew * Float64(cos(t) + Float64(eh * Float64(Float64(sin(t) * sin(atan(Float64(Float64(t * eh) / ew)))) / ew)))); elseif ((t <= -0.00028) || !(t <= 1.15e-24)) tmp = abs(Float64(Float64(ew * cos(t)) * cos(t_1))); else tmp = abs(Float64(ew - Float64(sin(t_1) * Float64(t * eh)))); end return tmp end
function tmp_2 = code(eh, ew, t) t_1 = atan((eh * (tan(t) / -ew))); tmp = 0.0; if (t <= -3.9e+186) tmp = ew * (cos(t) + (eh * ((sin(t) * sin(atan(((t * eh) / ew)))) / ew))); elseif ((t <= -0.00028) || ~((t <= 1.15e-24))) tmp = abs(((ew * cos(t)) * cos(t_1))); else tmp = abs((ew - (sin(t_1) * (t * eh)))); end tmp_2 = tmp; end
code[eh_, ew_, t_] := Block[{t$95$1 = N[ArcTan[N[(eh * N[(N[Tan[t], $MachinePrecision] / (-ew)), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t, -3.9e+186], N[(ew * N[(N[Cos[t], $MachinePrecision] + N[(eh * N[(N[(N[Sin[t], $MachinePrecision] * N[Sin[N[ArcTan[N[(N[(t * eh), $MachinePrecision] / ew), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / ew), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[t, -0.00028], N[Not[LessEqual[t, 1.15e-24]], $MachinePrecision]], N[Abs[N[(N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$1], $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Abs[N[(ew - N[(N[Sin[t$95$1], $MachinePrecision] * N[(t * eh), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \tan^{-1} \left(eh \cdot \frac{\tan t}{-ew}\right)\\
\mathbf{if}\;t \leq -3.9 \cdot 10^{+186}:\\
\;\;\;\;ew \cdot \left(\cos t + eh \cdot \frac{\sin t \cdot \sin \tan^{-1} \left(\frac{t \cdot eh}{ew}\right)}{ew}\right)\\
\mathbf{elif}\;t \leq -0.00028 \lor \neg \left(t \leq 1.15 \cdot 10^{-24}\right):\\
\;\;\;\;\left|\left(ew \cdot \cos t\right) \cdot \cos t\_1\right|\\
\mathbf{else}:\\
\;\;\;\;\left|ew - \sin t\_1 \cdot \left(t \cdot eh\right)\right|\\
\end{array}
\end{array}
if t < -3.9000000000000001e186Initial program 99.9%
sub-neg99.9%
associate-*l*99.9%
distribute-rgt-neg-in99.9%
cancel-sign-sub99.9%
associate-/l*99.9%
Simplified99.9%
Applied egg-rr45.4%
Taylor expanded in ew around inf 46.2%
associate-/l*46.0%
*-commutative46.0%
associate-*r/46.0%
Simplified46.0%
Taylor expanded in t around 0 71.3%
if -3.9000000000000001e186 < t < -2.7999999999999998e-4 or 1.1500000000000001e-24 < t Initial program 99.6%
sub-neg99.6%
associate-*l*99.6%
distribute-rgt-neg-in99.6%
cancel-sign-sub99.6%
associate-/l*99.6%
Simplified99.6%
Taylor expanded in ew around inf 62.2%
associate-*r*62.2%
mul-1-neg62.2%
distribute-frac-neg262.2%
associate-/l*62.2%
Simplified62.2%
if -2.7999999999999998e-4 < t < 1.1500000000000001e-24Initial program 100.0%
sub-neg100.0%
associate-*l*100.0%
distribute-rgt-neg-in100.0%
cancel-sign-sub100.0%
associate-/l*100.0%
Simplified100.0%
cos-atan100.0%
un-div-inv100.0%
hypot-1-def100.0%
associate-*r/100.0%
*-commutative100.0%
associate-/l*100.0%
add-sqr-sqrt55.3%
sqrt-unprod90.4%
sqr-neg90.4%
sqrt-unprod44.7%
add-sqr-sqrt100.0%
Applied egg-rr100.0%
Taylor expanded in t around 0 98.2%
mul-1-neg98.2%
unsub-neg98.2%
associate-*r*98.2%
mul-1-neg98.2%
distribute-frac-neg98.2%
*-commutative98.2%
distribute-rgt-neg-out98.2%
distribute-rgt-neg-out98.2%
*-commutative98.2%
distribute-frac-neg98.2%
distribute-frac-neg298.2%
associate-/l*98.2%
Simplified98.2%
Final simplification79.1%
(FPCore (eh ew t)
:precision binary64
(let* ((t_1 (atan (* eh (/ (tan t) (- ew))))))
(if (<= ew -1.9e-79)
(fabs (* (* ew (cos t)) (cos t_1)))
(if (<= ew 8.4e-156)
(fabs (* (* eh (sin t)) (sin t_1)))
(if (<= ew 1.9e+20)
(*
ew
(+ (cos t) (* eh (/ (* (sin t) (sin (atan (/ (* t eh) ew)))) ew))))
(* ew (fabs (cos t))))))))
double code(double eh, double ew, double t) {
double t_1 = atan((eh * (tan(t) / -ew)));
double tmp;
if (ew <= -1.9e-79) {
tmp = fabs(((ew * cos(t)) * cos(t_1)));
} else if (ew <= 8.4e-156) {
tmp = fabs(((eh * sin(t)) * sin(t_1)));
} else if (ew <= 1.9e+20) {
tmp = ew * (cos(t) + (eh * ((sin(t) * sin(atan(((t * eh) / ew)))) / ew)));
} else {
tmp = ew * fabs(cos(t));
}
return tmp;
}
real(8) function code(eh, ew, t)
real(8), intent (in) :: eh
real(8), intent (in) :: ew
real(8), intent (in) :: t
real(8) :: t_1
real(8) :: tmp
t_1 = atan((eh * (tan(t) / -ew)))
if (ew <= (-1.9d-79)) then
tmp = abs(((ew * cos(t)) * cos(t_1)))
else if (ew <= 8.4d-156) then
tmp = abs(((eh * sin(t)) * sin(t_1)))
else if (ew <= 1.9d+20) then
tmp = ew * (cos(t) + (eh * ((sin(t) * sin(atan(((t * eh) / ew)))) / ew)))
else
tmp = ew * abs(cos(t))
end if
code = tmp
end function
public static double code(double eh, double ew, double t) {
double t_1 = Math.atan((eh * (Math.tan(t) / -ew)));
double tmp;
if (ew <= -1.9e-79) {
tmp = Math.abs(((ew * Math.cos(t)) * Math.cos(t_1)));
} else if (ew <= 8.4e-156) {
tmp = Math.abs(((eh * Math.sin(t)) * Math.sin(t_1)));
} else if (ew <= 1.9e+20) {
tmp = ew * (Math.cos(t) + (eh * ((Math.sin(t) * Math.sin(Math.atan(((t * eh) / ew)))) / ew)));
} else {
tmp = ew * Math.abs(Math.cos(t));
}
return tmp;
}
def code(eh, ew, t): t_1 = math.atan((eh * (math.tan(t) / -ew))) tmp = 0 if ew <= -1.9e-79: tmp = math.fabs(((ew * math.cos(t)) * math.cos(t_1))) elif ew <= 8.4e-156: tmp = math.fabs(((eh * math.sin(t)) * math.sin(t_1))) elif ew <= 1.9e+20: tmp = ew * (math.cos(t) + (eh * ((math.sin(t) * math.sin(math.atan(((t * eh) / ew)))) / ew))) else: tmp = ew * math.fabs(math.cos(t)) return tmp
function code(eh, ew, t) t_1 = atan(Float64(eh * Float64(tan(t) / Float64(-ew)))) tmp = 0.0 if (ew <= -1.9e-79) tmp = abs(Float64(Float64(ew * cos(t)) * cos(t_1))); elseif (ew <= 8.4e-156) tmp = abs(Float64(Float64(eh * sin(t)) * sin(t_1))); elseif (ew <= 1.9e+20) tmp = Float64(ew * Float64(cos(t) + Float64(eh * Float64(Float64(sin(t) * sin(atan(Float64(Float64(t * eh) / ew)))) / ew)))); else tmp = Float64(ew * abs(cos(t))); end return tmp end
function tmp_2 = code(eh, ew, t) t_1 = atan((eh * (tan(t) / -ew))); tmp = 0.0; if (ew <= -1.9e-79) tmp = abs(((ew * cos(t)) * cos(t_1))); elseif (ew <= 8.4e-156) tmp = abs(((eh * sin(t)) * sin(t_1))); elseif (ew <= 1.9e+20) tmp = ew * (cos(t) + (eh * ((sin(t) * sin(atan(((t * eh) / ew)))) / ew))); else tmp = ew * abs(cos(t)); end tmp_2 = tmp; end
code[eh_, ew_, t_] := Block[{t$95$1 = N[ArcTan[N[(eh * N[(N[Tan[t], $MachinePrecision] / (-ew)), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[ew, -1.9e-79], N[Abs[N[(N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$1], $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[ew, 8.4e-156], N[Abs[N[(N[(eh * N[Sin[t], $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$1], $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[ew, 1.9e+20], N[(ew * N[(N[Cos[t], $MachinePrecision] + N[(eh * N[(N[(N[Sin[t], $MachinePrecision] * N[Sin[N[ArcTan[N[(N[(t * eh), $MachinePrecision] / ew), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / ew), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(ew * N[Abs[N[Cos[t], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \tan^{-1} \left(eh \cdot \frac{\tan t}{-ew}\right)\\
\mathbf{if}\;ew \leq -1.9 \cdot 10^{-79}:\\
\;\;\;\;\left|\left(ew \cdot \cos t\right) \cdot \cos t\_1\right|\\
\mathbf{elif}\;ew \leq 8.4 \cdot 10^{-156}:\\
\;\;\;\;\left|\left(eh \cdot \sin t\right) \cdot \sin t\_1\right|\\
\mathbf{elif}\;ew \leq 1.9 \cdot 10^{+20}:\\
\;\;\;\;ew \cdot \left(\cos t + eh \cdot \frac{\sin t \cdot \sin \tan^{-1} \left(\frac{t \cdot eh}{ew}\right)}{ew}\right)\\
\mathbf{else}:\\
\;\;\;\;ew \cdot \left|\cos t\right|\\
\end{array}
\end{array}
if ew < -1.9000000000000001e-79Initial program 99.8%
sub-neg99.8%
associate-*l*99.8%
distribute-rgt-neg-in99.8%
cancel-sign-sub99.8%
associate-/l*99.8%
Simplified99.8%
Taylor expanded in ew around inf 84.9%
associate-*r*84.9%
mul-1-neg84.9%
distribute-frac-neg284.9%
associate-/l*84.9%
Simplified84.9%
if -1.9000000000000001e-79 < ew < 8.40000000000000049e-156Initial program 99.8%
sub-neg99.8%
associate-*l*99.8%
distribute-rgt-neg-in99.8%
cancel-sign-sub99.8%
associate-/l*99.8%
Simplified99.8%
Taylor expanded in ew around 0 74.0%
mul-1-neg74.0%
associate-*r*74.0%
mul-1-neg74.0%
distribute-frac-neg274.0%
associate-/l*74.0%
Simplified74.0%
if 8.40000000000000049e-156 < ew < 1.9e20Initial program 99.9%
sub-neg99.9%
associate-*l*99.9%
distribute-rgt-neg-in99.9%
cancel-sign-sub99.9%
associate-/l*99.9%
Simplified99.9%
Applied egg-rr77.9%
Taylor expanded in ew around inf 76.3%
associate-/l*76.2%
*-commutative76.2%
associate-*r/76.2%
Simplified76.2%
Taylor expanded in t around 0 85.2%
if 1.9e20 < ew Initial program 99.8%
sub-neg99.8%
associate-*l*99.8%
distribute-rgt-neg-in99.8%
cancel-sign-sub99.8%
associate-/l*99.8%
Simplified99.8%
Applied egg-rr71.9%
Taylor expanded in ew around inf 69.5%
add-sqr-sqrt69.2%
sqrt-unprod90.2%
pow290.2%
Applied egg-rr90.2%
unpow290.2%
rem-sqrt-square90.2%
Simplified90.2%
Final simplification82.7%
(FPCore (eh ew t)
:precision binary64
(if (<= ew -2.9e+146)
(fabs (* ew (cos (atan (* eh (+ (- 1.0 (/ (tan t) ew)) -1.0))))))
(if (<= ew -1.32e-39)
(sqrt (pow (* ew (cos t)) 2.0))
(if (<= ew 5e-301)
(fabs (- ew (* (sin (atan (* eh (/ (tan t) (- ew))))) (* t eh))))
(if (<= ew 2.4e-163)
(* (* eh (sin t)) (sin (atan (* (tan t) (/ eh ew)))))
(* ew (fabs (cos t))))))))
double code(double eh, double ew, double t) {
double tmp;
if (ew <= -2.9e+146) {
tmp = fabs((ew * cos(atan((eh * ((1.0 - (tan(t) / ew)) + -1.0))))));
} else if (ew <= -1.32e-39) {
tmp = sqrt(pow((ew * cos(t)), 2.0));
} else if (ew <= 5e-301) {
tmp = fabs((ew - (sin(atan((eh * (tan(t) / -ew)))) * (t * eh))));
} else if (ew <= 2.4e-163) {
tmp = (eh * sin(t)) * sin(atan((tan(t) * (eh / ew))));
} else {
tmp = ew * fabs(cos(t));
}
return tmp;
}
real(8) function code(eh, ew, t)
real(8), intent (in) :: eh
real(8), intent (in) :: ew
real(8), intent (in) :: t
real(8) :: tmp
if (ew <= (-2.9d+146)) then
tmp = abs((ew * cos(atan((eh * ((1.0d0 - (tan(t) / ew)) + (-1.0d0)))))))
else if (ew <= (-1.32d-39)) then
tmp = sqrt(((ew * cos(t)) ** 2.0d0))
else if (ew <= 5d-301) then
tmp = abs((ew - (sin(atan((eh * (tan(t) / -ew)))) * (t * eh))))
else if (ew <= 2.4d-163) then
tmp = (eh * sin(t)) * sin(atan((tan(t) * (eh / ew))))
else
tmp = ew * abs(cos(t))
end if
code = tmp
end function
public static double code(double eh, double ew, double t) {
double tmp;
if (ew <= -2.9e+146) {
tmp = Math.abs((ew * Math.cos(Math.atan((eh * ((1.0 - (Math.tan(t) / ew)) + -1.0))))));
} else if (ew <= -1.32e-39) {
tmp = Math.sqrt(Math.pow((ew * Math.cos(t)), 2.0));
} else if (ew <= 5e-301) {
tmp = Math.abs((ew - (Math.sin(Math.atan((eh * (Math.tan(t) / -ew)))) * (t * eh))));
} else if (ew <= 2.4e-163) {
tmp = (eh * Math.sin(t)) * Math.sin(Math.atan((Math.tan(t) * (eh / ew))));
} else {
tmp = ew * Math.abs(Math.cos(t));
}
return tmp;
}
def code(eh, ew, t): tmp = 0 if ew <= -2.9e+146: tmp = math.fabs((ew * math.cos(math.atan((eh * ((1.0 - (math.tan(t) / ew)) + -1.0)))))) elif ew <= -1.32e-39: tmp = math.sqrt(math.pow((ew * math.cos(t)), 2.0)) elif ew <= 5e-301: tmp = math.fabs((ew - (math.sin(math.atan((eh * (math.tan(t) / -ew)))) * (t * eh)))) elif ew <= 2.4e-163: tmp = (eh * math.sin(t)) * math.sin(math.atan((math.tan(t) * (eh / ew)))) else: tmp = ew * math.fabs(math.cos(t)) return tmp
function code(eh, ew, t) tmp = 0.0 if (ew <= -2.9e+146) tmp = abs(Float64(ew * cos(atan(Float64(eh * Float64(Float64(1.0 - Float64(tan(t) / ew)) + -1.0)))))); elseif (ew <= -1.32e-39) tmp = sqrt((Float64(ew * cos(t)) ^ 2.0)); elseif (ew <= 5e-301) tmp = abs(Float64(ew - Float64(sin(atan(Float64(eh * Float64(tan(t) / Float64(-ew))))) * Float64(t * eh)))); elseif (ew <= 2.4e-163) tmp = Float64(Float64(eh * sin(t)) * sin(atan(Float64(tan(t) * Float64(eh / ew))))); else tmp = Float64(ew * abs(cos(t))); end return tmp end
function tmp_2 = code(eh, ew, t) tmp = 0.0; if (ew <= -2.9e+146) tmp = abs((ew * cos(atan((eh * ((1.0 - (tan(t) / ew)) + -1.0)))))); elseif (ew <= -1.32e-39) tmp = sqrt(((ew * cos(t)) ^ 2.0)); elseif (ew <= 5e-301) tmp = abs((ew - (sin(atan((eh * (tan(t) / -ew)))) * (t * eh)))); elseif (ew <= 2.4e-163) tmp = (eh * sin(t)) * sin(atan((tan(t) * (eh / ew)))); else tmp = ew * abs(cos(t)); end tmp_2 = tmp; end
code[eh_, ew_, t_] := If[LessEqual[ew, -2.9e+146], N[Abs[N[(ew * N[Cos[N[ArcTan[N[(eh * N[(N[(1.0 - N[(N[Tan[t], $MachinePrecision] / ew), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[ew, -1.32e-39], N[Sqrt[N[Power[N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]], $MachinePrecision], If[LessEqual[ew, 5e-301], N[Abs[N[(ew - N[(N[Sin[N[ArcTan[N[(eh * N[(N[Tan[t], $MachinePrecision] / (-ew)), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * N[(t * eh), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[ew, 2.4e-163], N[(N[(eh * N[Sin[t], $MachinePrecision]), $MachinePrecision] * N[Sin[N[ArcTan[N[(N[Tan[t], $MachinePrecision] * N[(eh / ew), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(ew * N[Abs[N[Cos[t], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;ew \leq -2.9 \cdot 10^{+146}:\\
\;\;\;\;\left|ew \cdot \cos \tan^{-1} \left(eh \cdot \left(\left(1 - \frac{\tan t}{ew}\right) + -1\right)\right)\right|\\
\mathbf{elif}\;ew \leq -1.32 \cdot 10^{-39}:\\
\;\;\;\;\sqrt{{\left(ew \cdot \cos t\right)}^{2}}\\
\mathbf{elif}\;ew \leq 5 \cdot 10^{-301}:\\
\;\;\;\;\left|ew - \sin \tan^{-1} \left(eh \cdot \frac{\tan t}{-ew}\right) \cdot \left(t \cdot eh\right)\right|\\
\mathbf{elif}\;ew \leq 2.4 \cdot 10^{-163}:\\
\;\;\;\;\left(eh \cdot \sin t\right) \cdot \sin \tan^{-1} \left(\tan t \cdot \frac{eh}{ew}\right)\\
\mathbf{else}:\\
\;\;\;\;ew \cdot \left|\cos t\right|\\
\end{array}
\end{array}
if ew < -2.8999999999999998e146Initial program 99.9%
sub-neg99.9%
associate-*l*99.9%
distribute-rgt-neg-in99.9%
cancel-sign-sub99.9%
associate-/l*99.9%
Simplified99.9%
Taylor expanded in t around 0 60.3%
mul-1-neg60.3%
distribute-frac-neg260.3%
associate-/l*60.3%
Simplified60.3%
expm1-log1p-u60.3%
expm1-undefine60.4%
Applied egg-rr60.4%
sub-neg60.4%
log1p-undefine60.4%
rem-exp-log60.4%
distribute-frac-neg260.4%
unsub-neg60.4%
metadata-eval60.4%
Simplified60.4%
if -2.8999999999999998e146 < ew < -1.31999999999999997e-39Initial program 99.6%
sub-neg99.6%
associate-*l*99.6%
distribute-rgt-neg-in99.6%
cancel-sign-sub99.6%
associate-/l*99.6%
Simplified99.6%
Applied egg-rr38.7%
Taylor expanded in ew around inf 27.0%
add-sqr-sqrt26.1%
sqrt-unprod78.5%
pow278.5%
Applied egg-rr78.5%
if -1.31999999999999997e-39 < ew < 5.00000000000000013e-301Initial program 99.8%
sub-neg99.8%
associate-*l*99.8%
distribute-rgt-neg-in99.8%
cancel-sign-sub99.8%
associate-/l*99.8%
Simplified99.8%
cos-atan99.8%
un-div-inv99.8%
hypot-1-def99.8%
associate-*r/99.8%
*-commutative99.8%
associate-/l*99.8%
add-sqr-sqrt56.0%
sqrt-unprod99.4%
sqr-neg99.4%
sqrt-unprod43.8%
add-sqr-sqrt99.8%
Applied egg-rr99.8%
Taylor expanded in t around 0 56.3%
mul-1-neg56.3%
unsub-neg56.3%
associate-*r*56.3%
mul-1-neg56.3%
distribute-frac-neg56.3%
*-commutative56.3%
distribute-rgt-neg-out56.3%
distribute-rgt-neg-out56.3%
*-commutative56.3%
distribute-frac-neg56.3%
distribute-frac-neg256.3%
associate-/l*56.3%
Simplified56.3%
if 5.00000000000000013e-301 < ew < 2.4000000000000001e-163Initial program 99.7%
sub-neg99.7%
associate-*l*99.8%
distribute-rgt-neg-in99.8%
cancel-sign-sub99.8%
associate-/l*99.8%
Simplified99.8%
Applied egg-rr72.8%
Taylor expanded in ew around 0 59.0%
associate-*r*59.0%
*-commutative59.0%
*-commutative59.0%
associate-*r/59.0%
Simplified59.0%
if 2.4000000000000001e-163 < ew Initial program 99.8%
sub-neg99.8%
associate-*l*99.8%
distribute-rgt-neg-in99.8%
cancel-sign-sub99.8%
associate-/l*99.8%
Simplified99.8%
Applied egg-rr72.6%
Taylor expanded in ew around inf 62.0%
add-sqr-sqrt61.7%
sqrt-unprod79.3%
pow279.3%
Applied egg-rr79.3%
unpow279.3%
rem-sqrt-square79.3%
Simplified79.3%
Final simplification68.8%
(FPCore (eh ew t)
:precision binary64
(let* ((t_1
(fabs (* ew (cos (atan (* eh (+ (- 1.0 (/ (tan t) ew)) -1.0))))))))
(if (<= ew -2.9e+146)
t_1
(if (<= ew -2.25e-159)
(sqrt (pow (* ew (cos t)) 2.0))
(if (<= ew -7.2e-290)
t_1
(if (<= ew 3.5e-160)
(* (* eh (sin t)) (sin (atan (* (tan t) (/ eh ew)))))
(* ew (fabs (cos t)))))))))
double code(double eh, double ew, double t) {
double t_1 = fabs((ew * cos(atan((eh * ((1.0 - (tan(t) / ew)) + -1.0))))));
double tmp;
if (ew <= -2.9e+146) {
tmp = t_1;
} else if (ew <= -2.25e-159) {
tmp = sqrt(pow((ew * cos(t)), 2.0));
} else if (ew <= -7.2e-290) {
tmp = t_1;
} else if (ew <= 3.5e-160) {
tmp = (eh * sin(t)) * sin(atan((tan(t) * (eh / ew))));
} else {
tmp = ew * fabs(cos(t));
}
return tmp;
}
real(8) function code(eh, ew, t)
real(8), intent (in) :: eh
real(8), intent (in) :: ew
real(8), intent (in) :: t
real(8) :: t_1
real(8) :: tmp
t_1 = abs((ew * cos(atan((eh * ((1.0d0 - (tan(t) / ew)) + (-1.0d0)))))))
if (ew <= (-2.9d+146)) then
tmp = t_1
else if (ew <= (-2.25d-159)) then
tmp = sqrt(((ew * cos(t)) ** 2.0d0))
else if (ew <= (-7.2d-290)) then
tmp = t_1
else if (ew <= 3.5d-160) then
tmp = (eh * sin(t)) * sin(atan((tan(t) * (eh / ew))))
else
tmp = ew * abs(cos(t))
end if
code = tmp
end function
public static double code(double eh, double ew, double t) {
double t_1 = Math.abs((ew * Math.cos(Math.atan((eh * ((1.0 - (Math.tan(t) / ew)) + -1.0))))));
double tmp;
if (ew <= -2.9e+146) {
tmp = t_1;
} else if (ew <= -2.25e-159) {
tmp = Math.sqrt(Math.pow((ew * Math.cos(t)), 2.0));
} else if (ew <= -7.2e-290) {
tmp = t_1;
} else if (ew <= 3.5e-160) {
tmp = (eh * Math.sin(t)) * Math.sin(Math.atan((Math.tan(t) * (eh / ew))));
} else {
tmp = ew * Math.abs(Math.cos(t));
}
return tmp;
}
def code(eh, ew, t): t_1 = math.fabs((ew * math.cos(math.atan((eh * ((1.0 - (math.tan(t) / ew)) + -1.0)))))) tmp = 0 if ew <= -2.9e+146: tmp = t_1 elif ew <= -2.25e-159: tmp = math.sqrt(math.pow((ew * math.cos(t)), 2.0)) elif ew <= -7.2e-290: tmp = t_1 elif ew <= 3.5e-160: tmp = (eh * math.sin(t)) * math.sin(math.atan((math.tan(t) * (eh / ew)))) else: tmp = ew * math.fabs(math.cos(t)) return tmp
function code(eh, ew, t) t_1 = abs(Float64(ew * cos(atan(Float64(eh * Float64(Float64(1.0 - Float64(tan(t) / ew)) + -1.0)))))) tmp = 0.0 if (ew <= -2.9e+146) tmp = t_1; elseif (ew <= -2.25e-159) tmp = sqrt((Float64(ew * cos(t)) ^ 2.0)); elseif (ew <= -7.2e-290) tmp = t_1; elseif (ew <= 3.5e-160) tmp = Float64(Float64(eh * sin(t)) * sin(atan(Float64(tan(t) * Float64(eh / ew))))); else tmp = Float64(ew * abs(cos(t))); end return tmp end
function tmp_2 = code(eh, ew, t) t_1 = abs((ew * cos(atan((eh * ((1.0 - (tan(t) / ew)) + -1.0)))))); tmp = 0.0; if (ew <= -2.9e+146) tmp = t_1; elseif (ew <= -2.25e-159) tmp = sqrt(((ew * cos(t)) ^ 2.0)); elseif (ew <= -7.2e-290) tmp = t_1; elseif (ew <= 3.5e-160) tmp = (eh * sin(t)) * sin(atan((tan(t) * (eh / ew)))); else tmp = ew * abs(cos(t)); end tmp_2 = tmp; end
code[eh_, ew_, t_] := Block[{t$95$1 = N[Abs[N[(ew * N[Cos[N[ArcTan[N[(eh * N[(N[(1.0 - N[(N[Tan[t], $MachinePrecision] / ew), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[ew, -2.9e+146], t$95$1, If[LessEqual[ew, -2.25e-159], N[Sqrt[N[Power[N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]], $MachinePrecision], If[LessEqual[ew, -7.2e-290], t$95$1, If[LessEqual[ew, 3.5e-160], N[(N[(eh * N[Sin[t], $MachinePrecision]), $MachinePrecision] * N[Sin[N[ArcTan[N[(N[Tan[t], $MachinePrecision] * N[(eh / ew), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(ew * N[Abs[N[Cos[t], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left|ew \cdot \cos \tan^{-1} \left(eh \cdot \left(\left(1 - \frac{\tan t}{ew}\right) + -1\right)\right)\right|\\
\mathbf{if}\;ew \leq -2.9 \cdot 10^{+146}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;ew \leq -2.25 \cdot 10^{-159}:\\
\;\;\;\;\sqrt{{\left(ew \cdot \cos t\right)}^{2}}\\
\mathbf{elif}\;ew \leq -7.2 \cdot 10^{-290}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;ew \leq 3.5 \cdot 10^{-160}:\\
\;\;\;\;\left(eh \cdot \sin t\right) \cdot \sin \tan^{-1} \left(\tan t \cdot \frac{eh}{ew}\right)\\
\mathbf{else}:\\
\;\;\;\;ew \cdot \left|\cos t\right|\\
\end{array}
\end{array}
if ew < -2.8999999999999998e146 or -2.24999999999999994e-159 < ew < -7.19999999999999959e-290Initial program 99.9%
sub-neg99.9%
associate-*l*99.9%
distribute-rgt-neg-in99.9%
cancel-sign-sub99.9%
associate-/l*99.9%
Simplified99.9%
Taylor expanded in t around 0 48.4%
mul-1-neg48.4%
distribute-frac-neg248.4%
associate-/l*48.4%
Simplified48.4%
expm1-log1p-u39.6%
expm1-undefine39.6%
Applied egg-rr39.6%
sub-neg39.6%
log1p-undefine39.6%
rem-exp-log48.5%
distribute-frac-neg248.5%
unsub-neg48.5%
metadata-eval48.5%
Simplified48.5%
if -2.8999999999999998e146 < ew < -2.24999999999999994e-159Initial program 99.7%
sub-neg99.7%
associate-*l*99.6%
distribute-rgt-neg-in99.6%
cancel-sign-sub99.6%
associate-/l*99.6%
Simplified99.6%
Applied egg-rr34.2%
Taylor expanded in ew around inf 20.5%
add-sqr-sqrt19.4%
sqrt-unprod64.2%
pow264.2%
Applied egg-rr64.2%
if -7.19999999999999959e-290 < ew < 3.5000000000000003e-160Initial program 99.7%
sub-neg99.7%
associate-*l*99.7%
distribute-rgt-neg-in99.7%
cancel-sign-sub99.7%
associate-/l*99.7%
Simplified99.7%
Applied egg-rr67.1%
Taylor expanded in ew around 0 56.2%
associate-*r*56.2%
*-commutative56.2%
*-commutative56.2%
associate-*r/56.2%
Simplified56.2%
if 3.5000000000000003e-160 < ew Initial program 99.8%
sub-neg99.8%
associate-*l*99.8%
distribute-rgt-neg-in99.8%
cancel-sign-sub99.8%
associate-/l*99.8%
Simplified99.8%
Applied egg-rr72.6%
Taylor expanded in ew around inf 62.0%
add-sqr-sqrt61.7%
sqrt-unprod79.3%
pow279.3%
Applied egg-rr79.3%
unpow279.3%
rem-sqrt-square79.3%
Simplified79.3%
Final simplification64.8%
(FPCore (eh ew t)
:precision binary64
(if (<= ew -1.35e+154)
(fabs (* ew (cos (atan (* eh (+ -1.0 (- 1.0 (/ t ew))))))))
(if (<= ew -1.8e-159)
(sqrt (pow (* ew (cos t)) 2.0))
(if (<= ew -3.9e-290)
(fabs (* ew (cos (atan (* eh (/ (tan t) (- ew)))))))
(if (<= ew 6.5e-163)
(* (* eh (sin t)) (sin (atan (* (tan t) (/ eh ew)))))
(* ew (fabs (cos t))))))))
double code(double eh, double ew, double t) {
double tmp;
if (ew <= -1.35e+154) {
tmp = fabs((ew * cos(atan((eh * (-1.0 + (1.0 - (t / ew))))))));
} else if (ew <= -1.8e-159) {
tmp = sqrt(pow((ew * cos(t)), 2.0));
} else if (ew <= -3.9e-290) {
tmp = fabs((ew * cos(atan((eh * (tan(t) / -ew))))));
} else if (ew <= 6.5e-163) {
tmp = (eh * sin(t)) * sin(atan((tan(t) * (eh / ew))));
} else {
tmp = ew * fabs(cos(t));
}
return tmp;
}
real(8) function code(eh, ew, t)
real(8), intent (in) :: eh
real(8), intent (in) :: ew
real(8), intent (in) :: t
real(8) :: tmp
if (ew <= (-1.35d+154)) then
tmp = abs((ew * cos(atan((eh * ((-1.0d0) + (1.0d0 - (t / ew))))))))
else if (ew <= (-1.8d-159)) then
tmp = sqrt(((ew * cos(t)) ** 2.0d0))
else if (ew <= (-3.9d-290)) then
tmp = abs((ew * cos(atan((eh * (tan(t) / -ew))))))
else if (ew <= 6.5d-163) then
tmp = (eh * sin(t)) * sin(atan((tan(t) * (eh / ew))))
else
tmp = ew * abs(cos(t))
end if
code = tmp
end function
public static double code(double eh, double ew, double t) {
double tmp;
if (ew <= -1.35e+154) {
tmp = Math.abs((ew * Math.cos(Math.atan((eh * (-1.0 + (1.0 - (t / ew))))))));
} else if (ew <= -1.8e-159) {
tmp = Math.sqrt(Math.pow((ew * Math.cos(t)), 2.0));
} else if (ew <= -3.9e-290) {
tmp = Math.abs((ew * Math.cos(Math.atan((eh * (Math.tan(t) / -ew))))));
} else if (ew <= 6.5e-163) {
tmp = (eh * Math.sin(t)) * Math.sin(Math.atan((Math.tan(t) * (eh / ew))));
} else {
tmp = ew * Math.abs(Math.cos(t));
}
return tmp;
}
def code(eh, ew, t): tmp = 0 if ew <= -1.35e+154: tmp = math.fabs((ew * math.cos(math.atan((eh * (-1.0 + (1.0 - (t / ew)))))))) elif ew <= -1.8e-159: tmp = math.sqrt(math.pow((ew * math.cos(t)), 2.0)) elif ew <= -3.9e-290: tmp = math.fabs((ew * math.cos(math.atan((eh * (math.tan(t) / -ew)))))) elif ew <= 6.5e-163: tmp = (eh * math.sin(t)) * math.sin(math.atan((math.tan(t) * (eh / ew)))) else: tmp = ew * math.fabs(math.cos(t)) return tmp
function code(eh, ew, t) tmp = 0.0 if (ew <= -1.35e+154) tmp = abs(Float64(ew * cos(atan(Float64(eh * Float64(-1.0 + Float64(1.0 - Float64(t / ew)))))))); elseif (ew <= -1.8e-159) tmp = sqrt((Float64(ew * cos(t)) ^ 2.0)); elseif (ew <= -3.9e-290) tmp = abs(Float64(ew * cos(atan(Float64(eh * Float64(tan(t) / Float64(-ew))))))); elseif (ew <= 6.5e-163) tmp = Float64(Float64(eh * sin(t)) * sin(atan(Float64(tan(t) * Float64(eh / ew))))); else tmp = Float64(ew * abs(cos(t))); end return tmp end
function tmp_2 = code(eh, ew, t) tmp = 0.0; if (ew <= -1.35e+154) tmp = abs((ew * cos(atan((eh * (-1.0 + (1.0 - (t / ew)))))))); elseif (ew <= -1.8e-159) tmp = sqrt(((ew * cos(t)) ^ 2.0)); elseif (ew <= -3.9e-290) tmp = abs((ew * cos(atan((eh * (tan(t) / -ew)))))); elseif (ew <= 6.5e-163) tmp = (eh * sin(t)) * sin(atan((tan(t) * (eh / ew)))); else tmp = ew * abs(cos(t)); end tmp_2 = tmp; end
code[eh_, ew_, t_] := If[LessEqual[ew, -1.35e+154], N[Abs[N[(ew * N[Cos[N[ArcTan[N[(eh * N[(-1.0 + N[(1.0 - N[(t / ew), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[ew, -1.8e-159], N[Sqrt[N[Power[N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]], $MachinePrecision], If[LessEqual[ew, -3.9e-290], N[Abs[N[(ew * N[Cos[N[ArcTan[N[(eh * N[(N[Tan[t], $MachinePrecision] / (-ew)), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[ew, 6.5e-163], N[(N[(eh * N[Sin[t], $MachinePrecision]), $MachinePrecision] * N[Sin[N[ArcTan[N[(N[Tan[t], $MachinePrecision] * N[(eh / ew), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(ew * N[Abs[N[Cos[t], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;ew \leq -1.35 \cdot 10^{+154}:\\
\;\;\;\;\left|ew \cdot \cos \tan^{-1} \left(eh \cdot \left(-1 + \left(1 - \frac{t}{ew}\right)\right)\right)\right|\\
\mathbf{elif}\;ew \leq -1.8 \cdot 10^{-159}:\\
\;\;\;\;\sqrt{{\left(ew \cdot \cos t\right)}^{2}}\\
\mathbf{elif}\;ew \leq -3.9 \cdot 10^{-290}:\\
\;\;\;\;\left|ew \cdot \cos \tan^{-1} \left(eh \cdot \frac{\tan t}{-ew}\right)\right|\\
\mathbf{elif}\;ew \leq 6.5 \cdot 10^{-163}:\\
\;\;\;\;\left(eh \cdot \sin t\right) \cdot \sin \tan^{-1} \left(\tan t \cdot \frac{eh}{ew}\right)\\
\mathbf{else}:\\
\;\;\;\;ew \cdot \left|\cos t\right|\\
\end{array}
\end{array}
if ew < -1.35000000000000003e154Initial program 99.9%
sub-neg99.9%
associate-*l*99.9%
distribute-rgt-neg-in99.9%
cancel-sign-sub99.9%
associate-/l*99.9%
Simplified99.9%
Taylor expanded in t around 0 62.3%
mul-1-neg62.3%
distribute-frac-neg262.3%
associate-/l*62.3%
Simplified62.3%
expm1-log1p-u62.3%
expm1-undefine62.3%
Applied egg-rr62.3%
sub-neg62.3%
log1p-undefine62.3%
rem-exp-log62.3%
distribute-frac-neg262.3%
unsub-neg62.3%
metadata-eval62.3%
Simplified62.3%
Taylor expanded in t around 0 62.3%
if -1.35000000000000003e154 < ew < -1.80000000000000011e-159Initial program 99.7%
sub-neg99.7%
associate-*l*99.7%
distribute-rgt-neg-in99.7%
cancel-sign-sub99.7%
associate-/l*99.7%
Simplified99.7%
Applied egg-rr32.4%
Taylor expanded in ew around inf 19.4%
add-sqr-sqrt18.3%
sqrt-unprod62.7%
pow262.7%
Applied egg-rr62.7%
if -1.80000000000000011e-159 < ew < -3.89999999999999973e-290Initial program 99.9%
sub-neg99.9%
associate-*l*99.9%
distribute-rgt-neg-in99.9%
cancel-sign-sub99.9%
associate-/l*99.9%
Simplified99.9%
Taylor expanded in t around 0 31.9%
mul-1-neg31.9%
distribute-frac-neg231.9%
associate-/l*31.9%
Simplified31.9%
if -3.89999999999999973e-290 < ew < 6.4999999999999999e-163Initial program 99.7%
sub-neg99.7%
associate-*l*99.7%
distribute-rgt-neg-in99.7%
cancel-sign-sub99.7%
associate-/l*99.7%
Simplified99.7%
Applied egg-rr67.1%
Taylor expanded in ew around 0 56.2%
associate-*r*56.2%
*-commutative56.2%
*-commutative56.2%
associate-*r/56.2%
Simplified56.2%
if 6.4999999999999999e-163 < ew Initial program 99.8%
sub-neg99.8%
associate-*l*99.8%
distribute-rgt-neg-in99.8%
cancel-sign-sub99.8%
associate-/l*99.8%
Simplified99.8%
Applied egg-rr72.6%
Taylor expanded in ew around inf 62.0%
add-sqr-sqrt61.7%
sqrt-unprod79.3%
pow279.3%
Applied egg-rr79.3%
unpow279.3%
rem-sqrt-square79.3%
Simplified79.3%
Final simplification64.8%
(FPCore (eh ew t)
:precision binary64
(if (<= t -1.16e+186)
(* ew (+ (cos t) (* eh (/ (* (sin t) (sin (atan (/ (* t eh) ew)))) ew))))
(if (or (<= t -0.00033) (not (<= t 1.15e-24)))
(fabs (/ (* ew (cos t)) (hypot 1.0 (* (tan t) (/ eh ew)))))
(fabs (- ew (* (sin (atan (* eh (/ (tan t) (- ew))))) (* t eh)))))))
double code(double eh, double ew, double t) {
double tmp;
if (t <= -1.16e+186) {
tmp = ew * (cos(t) + (eh * ((sin(t) * sin(atan(((t * eh) / ew)))) / ew)));
} else if ((t <= -0.00033) || !(t <= 1.15e-24)) {
tmp = fabs(((ew * cos(t)) / hypot(1.0, (tan(t) * (eh / ew)))));
} else {
tmp = fabs((ew - (sin(atan((eh * (tan(t) / -ew)))) * (t * eh))));
}
return tmp;
}
public static double code(double eh, double ew, double t) {
double tmp;
if (t <= -1.16e+186) {
tmp = ew * (Math.cos(t) + (eh * ((Math.sin(t) * Math.sin(Math.atan(((t * eh) / ew)))) / ew)));
} else if ((t <= -0.00033) || !(t <= 1.15e-24)) {
tmp = Math.abs(((ew * Math.cos(t)) / Math.hypot(1.0, (Math.tan(t) * (eh / ew)))));
} else {
tmp = Math.abs((ew - (Math.sin(Math.atan((eh * (Math.tan(t) / -ew)))) * (t * eh))));
}
return tmp;
}
def code(eh, ew, t): tmp = 0 if t <= -1.16e+186: tmp = ew * (math.cos(t) + (eh * ((math.sin(t) * math.sin(math.atan(((t * eh) / ew)))) / ew))) elif (t <= -0.00033) or not (t <= 1.15e-24): tmp = math.fabs(((ew * math.cos(t)) / math.hypot(1.0, (math.tan(t) * (eh / ew))))) else: tmp = math.fabs((ew - (math.sin(math.atan((eh * (math.tan(t) / -ew)))) * (t * eh)))) return tmp
function code(eh, ew, t) tmp = 0.0 if (t <= -1.16e+186) tmp = Float64(ew * Float64(cos(t) + Float64(eh * Float64(Float64(sin(t) * sin(atan(Float64(Float64(t * eh) / ew)))) / ew)))); elseif ((t <= -0.00033) || !(t <= 1.15e-24)) tmp = abs(Float64(Float64(ew * cos(t)) / hypot(1.0, Float64(tan(t) * Float64(eh / ew))))); else tmp = abs(Float64(ew - Float64(sin(atan(Float64(eh * Float64(tan(t) / Float64(-ew))))) * Float64(t * eh)))); end return tmp end
function tmp_2 = code(eh, ew, t) tmp = 0.0; if (t <= -1.16e+186) tmp = ew * (cos(t) + (eh * ((sin(t) * sin(atan(((t * eh) / ew)))) / ew))); elseif ((t <= -0.00033) || ~((t <= 1.15e-24))) tmp = abs(((ew * cos(t)) / hypot(1.0, (tan(t) * (eh / ew))))); else tmp = abs((ew - (sin(atan((eh * (tan(t) / -ew)))) * (t * eh)))); end tmp_2 = tmp; end
code[eh_, ew_, t_] := If[LessEqual[t, -1.16e+186], N[(ew * N[(N[Cos[t], $MachinePrecision] + N[(eh * N[(N[(N[Sin[t], $MachinePrecision] * N[Sin[N[ArcTan[N[(N[(t * eh), $MachinePrecision] / ew), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / ew), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[t, -0.00033], N[Not[LessEqual[t, 1.15e-24]], $MachinePrecision]], N[Abs[N[(N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision] / N[Sqrt[1.0 ^ 2 + N[(N[Tan[t], $MachinePrecision] * N[(eh / ew), $MachinePrecision]), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Abs[N[(ew - N[(N[Sin[N[ArcTan[N[(eh * N[(N[Tan[t], $MachinePrecision] / (-ew)), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * N[(t * eh), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.16 \cdot 10^{+186}:\\
\;\;\;\;ew \cdot \left(\cos t + eh \cdot \frac{\sin t \cdot \sin \tan^{-1} \left(\frac{t \cdot eh}{ew}\right)}{ew}\right)\\
\mathbf{elif}\;t \leq -0.00033 \lor \neg \left(t \leq 1.15 \cdot 10^{-24}\right):\\
\;\;\;\;\left|\frac{ew \cdot \cos t}{\mathsf{hypot}\left(1, \tan t \cdot \frac{eh}{ew}\right)}\right|\\
\mathbf{else}:\\
\;\;\;\;\left|ew - \sin \tan^{-1} \left(eh \cdot \frac{\tan t}{-ew}\right) \cdot \left(t \cdot eh\right)\right|\\
\end{array}
\end{array}
if t < -1.15999999999999995e186Initial program 99.9%
sub-neg99.9%
associate-*l*99.9%
distribute-rgt-neg-in99.9%
cancel-sign-sub99.9%
associate-/l*99.9%
Simplified99.9%
Applied egg-rr45.4%
Taylor expanded in ew around inf 46.2%
associate-/l*46.0%
*-commutative46.0%
associate-*r/46.0%
Simplified46.0%
Taylor expanded in t around 0 71.3%
if -1.15999999999999995e186 < t < -3.3e-4 or 1.1500000000000001e-24 < t Initial program 99.6%
sub-neg99.6%
associate-*l*99.6%
distribute-rgt-neg-in99.6%
cancel-sign-sub99.6%
associate-/l*99.6%
Simplified99.6%
cos-atan99.6%
un-div-inv99.6%
hypot-1-def99.6%
associate-*r/99.6%
*-commutative99.6%
associate-/l*99.6%
add-sqr-sqrt50.6%
sqrt-unprod95.5%
sqr-neg95.5%
sqrt-unprod49.0%
add-sqr-sqrt99.6%
Applied egg-rr99.6%
sin-mult64.8%
associate-*r/64.8%
Applied egg-rr62.0%
+-inverses62.0%
mul0-rgt62.0%
metadata-eval62.0%
Simplified62.0%
if -3.3e-4 < t < 1.1500000000000001e-24Initial program 100.0%
sub-neg100.0%
associate-*l*100.0%
distribute-rgt-neg-in100.0%
cancel-sign-sub100.0%
associate-/l*100.0%
Simplified100.0%
cos-atan100.0%
un-div-inv100.0%
hypot-1-def100.0%
associate-*r/100.0%
*-commutative100.0%
associate-/l*100.0%
add-sqr-sqrt55.3%
sqrt-unprod90.4%
sqr-neg90.4%
sqrt-unprod44.7%
add-sqr-sqrt100.0%
Applied egg-rr100.0%
Taylor expanded in t around 0 98.2%
mul-1-neg98.2%
unsub-neg98.2%
associate-*r*98.2%
mul-1-neg98.2%
distribute-frac-neg98.2%
*-commutative98.2%
distribute-rgt-neg-out98.2%
distribute-rgt-neg-out98.2%
*-commutative98.2%
distribute-frac-neg98.2%
distribute-frac-neg298.2%
associate-/l*98.2%
Simplified98.2%
Final simplification79.0%
(FPCore (eh ew t)
:precision binary64
(if (<= ew -1.5e+154)
(fabs (* ew (cos (atan (* eh (+ -1.0 (- 1.0 (/ t ew))))))))
(if (<= ew -2.2e-159)
(sqrt (pow (* ew (cos t)) 2.0))
(if (<= ew -1e-310)
(fabs (* ew (cos (atan (* eh (/ (tan t) (- ew)))))))
(if (<= ew 1.5e-144)
(+ ew (* eh (* t (sin (atan (/ (* t eh) ew))))))
(* ew (fabs (cos t))))))))
double code(double eh, double ew, double t) {
double tmp;
if (ew <= -1.5e+154) {
tmp = fabs((ew * cos(atan((eh * (-1.0 + (1.0 - (t / ew))))))));
} else if (ew <= -2.2e-159) {
tmp = sqrt(pow((ew * cos(t)), 2.0));
} else if (ew <= -1e-310) {
tmp = fabs((ew * cos(atan((eh * (tan(t) / -ew))))));
} else if (ew <= 1.5e-144) {
tmp = ew + (eh * (t * sin(atan(((t * eh) / ew)))));
} else {
tmp = ew * fabs(cos(t));
}
return tmp;
}
real(8) function code(eh, ew, t)
real(8), intent (in) :: eh
real(8), intent (in) :: ew
real(8), intent (in) :: t
real(8) :: tmp
if (ew <= (-1.5d+154)) then
tmp = abs((ew * cos(atan((eh * ((-1.0d0) + (1.0d0 - (t / ew))))))))
else if (ew <= (-2.2d-159)) then
tmp = sqrt(((ew * cos(t)) ** 2.0d0))
else if (ew <= (-1d-310)) then
tmp = abs((ew * cos(atan((eh * (tan(t) / -ew))))))
else if (ew <= 1.5d-144) then
tmp = ew + (eh * (t * sin(atan(((t * eh) / ew)))))
else
tmp = ew * abs(cos(t))
end if
code = tmp
end function
public static double code(double eh, double ew, double t) {
double tmp;
if (ew <= -1.5e+154) {
tmp = Math.abs((ew * Math.cos(Math.atan((eh * (-1.0 + (1.0 - (t / ew))))))));
} else if (ew <= -2.2e-159) {
tmp = Math.sqrt(Math.pow((ew * Math.cos(t)), 2.0));
} else if (ew <= -1e-310) {
tmp = Math.abs((ew * Math.cos(Math.atan((eh * (Math.tan(t) / -ew))))));
} else if (ew <= 1.5e-144) {
tmp = ew + (eh * (t * Math.sin(Math.atan(((t * eh) / ew)))));
} else {
tmp = ew * Math.abs(Math.cos(t));
}
return tmp;
}
def code(eh, ew, t): tmp = 0 if ew <= -1.5e+154: tmp = math.fabs((ew * math.cos(math.atan((eh * (-1.0 + (1.0 - (t / ew)))))))) elif ew <= -2.2e-159: tmp = math.sqrt(math.pow((ew * math.cos(t)), 2.0)) elif ew <= -1e-310: tmp = math.fabs((ew * math.cos(math.atan((eh * (math.tan(t) / -ew)))))) elif ew <= 1.5e-144: tmp = ew + (eh * (t * math.sin(math.atan(((t * eh) / ew))))) else: tmp = ew * math.fabs(math.cos(t)) return tmp
function code(eh, ew, t) tmp = 0.0 if (ew <= -1.5e+154) tmp = abs(Float64(ew * cos(atan(Float64(eh * Float64(-1.0 + Float64(1.0 - Float64(t / ew)))))))); elseif (ew <= -2.2e-159) tmp = sqrt((Float64(ew * cos(t)) ^ 2.0)); elseif (ew <= -1e-310) tmp = abs(Float64(ew * cos(atan(Float64(eh * Float64(tan(t) / Float64(-ew))))))); elseif (ew <= 1.5e-144) tmp = Float64(ew + Float64(eh * Float64(t * sin(atan(Float64(Float64(t * eh) / ew)))))); else tmp = Float64(ew * abs(cos(t))); end return tmp end
function tmp_2 = code(eh, ew, t) tmp = 0.0; if (ew <= -1.5e+154) tmp = abs((ew * cos(atan((eh * (-1.0 + (1.0 - (t / ew)))))))); elseif (ew <= -2.2e-159) tmp = sqrt(((ew * cos(t)) ^ 2.0)); elseif (ew <= -1e-310) tmp = abs((ew * cos(atan((eh * (tan(t) / -ew)))))); elseif (ew <= 1.5e-144) tmp = ew + (eh * (t * sin(atan(((t * eh) / ew))))); else tmp = ew * abs(cos(t)); end tmp_2 = tmp; end
code[eh_, ew_, t_] := If[LessEqual[ew, -1.5e+154], N[Abs[N[(ew * N[Cos[N[ArcTan[N[(eh * N[(-1.0 + N[(1.0 - N[(t / ew), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[ew, -2.2e-159], N[Sqrt[N[Power[N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]], $MachinePrecision], If[LessEqual[ew, -1e-310], N[Abs[N[(ew * N[Cos[N[ArcTan[N[(eh * N[(N[Tan[t], $MachinePrecision] / (-ew)), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[ew, 1.5e-144], N[(ew + N[(eh * N[(t * N[Sin[N[ArcTan[N[(N[(t * eh), $MachinePrecision] / ew), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(ew * N[Abs[N[Cos[t], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;ew \leq -1.5 \cdot 10^{+154}:\\
\;\;\;\;\left|ew \cdot \cos \tan^{-1} \left(eh \cdot \left(-1 + \left(1 - \frac{t}{ew}\right)\right)\right)\right|\\
\mathbf{elif}\;ew \leq -2.2 \cdot 10^{-159}:\\
\;\;\;\;\sqrt{{\left(ew \cdot \cos t\right)}^{2}}\\
\mathbf{elif}\;ew \leq -1 \cdot 10^{-310}:\\
\;\;\;\;\left|ew \cdot \cos \tan^{-1} \left(eh \cdot \frac{\tan t}{-ew}\right)\right|\\
\mathbf{elif}\;ew \leq 1.5 \cdot 10^{-144}:\\
\;\;\;\;ew + eh \cdot \left(t \cdot \sin \tan^{-1} \left(\frac{t \cdot eh}{ew}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;ew \cdot \left|\cos t\right|\\
\end{array}
\end{array}
if ew < -1.50000000000000013e154Initial program 99.9%
sub-neg99.9%
associate-*l*99.9%
distribute-rgt-neg-in99.9%
cancel-sign-sub99.9%
associate-/l*99.9%
Simplified99.9%
Taylor expanded in t around 0 62.3%
mul-1-neg62.3%
distribute-frac-neg262.3%
associate-/l*62.3%
Simplified62.3%
expm1-log1p-u62.3%
expm1-undefine62.3%
Applied egg-rr62.3%
sub-neg62.3%
log1p-undefine62.3%
rem-exp-log62.3%
distribute-frac-neg262.3%
unsub-neg62.3%
metadata-eval62.3%
Simplified62.3%
Taylor expanded in t around 0 62.3%
if -1.50000000000000013e154 < ew < -2.2e-159Initial program 99.7%
sub-neg99.7%
associate-*l*99.7%
distribute-rgt-neg-in99.7%
cancel-sign-sub99.7%
associate-/l*99.7%
Simplified99.7%
Applied egg-rr32.4%
Taylor expanded in ew around inf 19.4%
add-sqr-sqrt18.3%
sqrt-unprod62.7%
pow262.7%
Applied egg-rr62.7%
if -2.2e-159 < ew < -9.999999999999969e-311Initial program 99.9%
sub-neg99.9%
associate-*l*99.9%
distribute-rgt-neg-in99.9%
cancel-sign-sub99.9%
associate-/l*99.9%
Simplified99.9%
Taylor expanded in t around 0 29.1%
mul-1-neg29.1%
distribute-frac-neg229.1%
associate-/l*29.1%
Simplified29.1%
if -9.999999999999969e-311 < ew < 1.4999999999999999e-144Initial program 99.7%
sub-neg99.7%
associate-*l*99.7%
distribute-rgt-neg-in99.7%
cancel-sign-sub99.7%
associate-/l*99.7%
Simplified99.7%
Applied egg-rr68.1%
Taylor expanded in t around 0 43.5%
Taylor expanded in t around 0 44.7%
*-commutative44.7%
Simplified44.7%
if 1.4999999999999999e-144 < ew Initial program 99.8%
sub-neg99.8%
associate-*l*99.8%
distribute-rgt-neg-in99.8%
cancel-sign-sub99.8%
associate-/l*99.8%
Simplified99.8%
Applied egg-rr73.3%
Taylor expanded in ew around inf 64.1%
add-sqr-sqrt63.8%
sqrt-unprod81.3%
pow281.3%
Applied egg-rr81.3%
unpow281.3%
rem-sqrt-square81.3%
Simplified81.3%
Final simplification62.6%
(FPCore (eh ew t) :precision binary64 (if (or (<= t -0.00025) (not (<= t 1.15e-24))) (fabs (/ (* ew (cos t)) (hypot 1.0 (* (tan t) (/ eh ew))))) (fabs (- ew (* (sin (atan (* eh (/ (tan t) (- ew))))) (* t eh))))))
double code(double eh, double ew, double t) {
double tmp;
if ((t <= -0.00025) || !(t <= 1.15e-24)) {
tmp = fabs(((ew * cos(t)) / hypot(1.0, (tan(t) * (eh / ew)))));
} else {
tmp = fabs((ew - (sin(atan((eh * (tan(t) / -ew)))) * (t * eh))));
}
return tmp;
}
public static double code(double eh, double ew, double t) {
double tmp;
if ((t <= -0.00025) || !(t <= 1.15e-24)) {
tmp = Math.abs(((ew * Math.cos(t)) / Math.hypot(1.0, (Math.tan(t) * (eh / ew)))));
} else {
tmp = Math.abs((ew - (Math.sin(Math.atan((eh * (Math.tan(t) / -ew)))) * (t * eh))));
}
return tmp;
}
def code(eh, ew, t): tmp = 0 if (t <= -0.00025) or not (t <= 1.15e-24): tmp = math.fabs(((ew * math.cos(t)) / math.hypot(1.0, (math.tan(t) * (eh / ew))))) else: tmp = math.fabs((ew - (math.sin(math.atan((eh * (math.tan(t) / -ew)))) * (t * eh)))) return tmp
function code(eh, ew, t) tmp = 0.0 if ((t <= -0.00025) || !(t <= 1.15e-24)) tmp = abs(Float64(Float64(ew * cos(t)) / hypot(1.0, Float64(tan(t) * Float64(eh / ew))))); else tmp = abs(Float64(ew - Float64(sin(atan(Float64(eh * Float64(tan(t) / Float64(-ew))))) * Float64(t * eh)))); end return tmp end
function tmp_2 = code(eh, ew, t) tmp = 0.0; if ((t <= -0.00025) || ~((t <= 1.15e-24))) tmp = abs(((ew * cos(t)) / hypot(1.0, (tan(t) * (eh / ew))))); else tmp = abs((ew - (sin(atan((eh * (tan(t) / -ew)))) * (t * eh)))); end tmp_2 = tmp; end
code[eh_, ew_, t_] := If[Or[LessEqual[t, -0.00025], N[Not[LessEqual[t, 1.15e-24]], $MachinePrecision]], N[Abs[N[(N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision] / N[Sqrt[1.0 ^ 2 + N[(N[Tan[t], $MachinePrecision] * N[(eh / ew), $MachinePrecision]), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Abs[N[(ew - N[(N[Sin[N[ArcTan[N[(eh * N[(N[Tan[t], $MachinePrecision] / (-ew)), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * N[(t * eh), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -0.00025 \lor \neg \left(t \leq 1.15 \cdot 10^{-24}\right):\\
\;\;\;\;\left|\frac{ew \cdot \cos t}{\mathsf{hypot}\left(1, \tan t \cdot \frac{eh}{ew}\right)}\right|\\
\mathbf{else}:\\
\;\;\;\;\left|ew - \sin \tan^{-1} \left(eh \cdot \frac{\tan t}{-ew}\right) \cdot \left(t \cdot eh\right)\right|\\
\end{array}
\end{array}
if t < -2.5000000000000001e-4 or 1.1500000000000001e-24 < t Initial program 99.6%
sub-neg99.6%
associate-*l*99.6%
distribute-rgt-neg-in99.6%
cancel-sign-sub99.6%
associate-/l*99.6%
Simplified99.6%
cos-atan99.6%
un-div-inv99.6%
hypot-1-def99.6%
associate-*r/99.6%
*-commutative99.6%
associate-/l*99.6%
add-sqr-sqrt47.6%
sqrt-unprod96.2%
sqr-neg96.2%
sqrt-unprod52.0%
add-sqr-sqrt99.6%
Applied egg-rr99.6%
sin-mult59.9%
associate-*r/59.9%
Applied egg-rr57.5%
+-inverses57.5%
mul0-rgt57.5%
metadata-eval57.5%
Simplified57.5%
if -2.5000000000000001e-4 < t < 1.1500000000000001e-24Initial program 100.0%
sub-neg100.0%
associate-*l*100.0%
distribute-rgt-neg-in100.0%
cancel-sign-sub100.0%
associate-/l*100.0%
Simplified100.0%
cos-atan100.0%
un-div-inv100.0%
hypot-1-def100.0%
associate-*r/100.0%
*-commutative100.0%
associate-/l*100.0%
add-sqr-sqrt55.3%
sqrt-unprod90.4%
sqr-neg90.4%
sqrt-unprod44.7%
add-sqr-sqrt100.0%
Applied egg-rr100.0%
Taylor expanded in t around 0 98.2%
mul-1-neg98.2%
unsub-neg98.2%
associate-*r*98.2%
mul-1-neg98.2%
distribute-frac-neg98.2%
*-commutative98.2%
distribute-rgt-neg-out98.2%
distribute-rgt-neg-out98.2%
*-commutative98.2%
distribute-frac-neg98.2%
distribute-frac-neg298.2%
associate-/l*98.2%
Simplified98.2%
Final simplification75.6%
(FPCore (eh ew t)
:precision binary64
(if (<= ew -1.35e+154)
(fabs (* ew (cos (atan (* eh (+ -1.0 (- 1.0 (/ t ew))))))))
(if (<= ew -1.8e-159)
(sqrt (pow (* ew (cos t)) 2.0))
(if (<= ew -1e-310)
(fabs (* ew (/ 1.0 (hypot 1.0 (* eh (/ (tan t) ew))))))
(if (<= ew 2.9e-145)
(+ ew (* eh (* t (sin (atan (/ (* t eh) ew))))))
(* ew (fabs (cos t))))))))
double code(double eh, double ew, double t) {
double tmp;
if (ew <= -1.35e+154) {
tmp = fabs((ew * cos(atan((eh * (-1.0 + (1.0 - (t / ew))))))));
} else if (ew <= -1.8e-159) {
tmp = sqrt(pow((ew * cos(t)), 2.0));
} else if (ew <= -1e-310) {
tmp = fabs((ew * (1.0 / hypot(1.0, (eh * (tan(t) / ew))))));
} else if (ew <= 2.9e-145) {
tmp = ew + (eh * (t * sin(atan(((t * eh) / ew)))));
} else {
tmp = ew * fabs(cos(t));
}
return tmp;
}
public static double code(double eh, double ew, double t) {
double tmp;
if (ew <= -1.35e+154) {
tmp = Math.abs((ew * Math.cos(Math.atan((eh * (-1.0 + (1.0 - (t / ew))))))));
} else if (ew <= -1.8e-159) {
tmp = Math.sqrt(Math.pow((ew * Math.cos(t)), 2.0));
} else if (ew <= -1e-310) {
tmp = Math.abs((ew * (1.0 / Math.hypot(1.0, (eh * (Math.tan(t) / ew))))));
} else if (ew <= 2.9e-145) {
tmp = ew + (eh * (t * Math.sin(Math.atan(((t * eh) / ew)))));
} else {
tmp = ew * Math.abs(Math.cos(t));
}
return tmp;
}
def code(eh, ew, t): tmp = 0 if ew <= -1.35e+154: tmp = math.fabs((ew * math.cos(math.atan((eh * (-1.0 + (1.0 - (t / ew)))))))) elif ew <= -1.8e-159: tmp = math.sqrt(math.pow((ew * math.cos(t)), 2.0)) elif ew <= -1e-310: tmp = math.fabs((ew * (1.0 / math.hypot(1.0, (eh * (math.tan(t) / ew)))))) elif ew <= 2.9e-145: tmp = ew + (eh * (t * math.sin(math.atan(((t * eh) / ew))))) else: tmp = ew * math.fabs(math.cos(t)) return tmp
function code(eh, ew, t) tmp = 0.0 if (ew <= -1.35e+154) tmp = abs(Float64(ew * cos(atan(Float64(eh * Float64(-1.0 + Float64(1.0 - Float64(t / ew)))))))); elseif (ew <= -1.8e-159) tmp = sqrt((Float64(ew * cos(t)) ^ 2.0)); elseif (ew <= -1e-310) tmp = abs(Float64(ew * Float64(1.0 / hypot(1.0, Float64(eh * Float64(tan(t) / ew)))))); elseif (ew <= 2.9e-145) tmp = Float64(ew + Float64(eh * Float64(t * sin(atan(Float64(Float64(t * eh) / ew)))))); else tmp = Float64(ew * abs(cos(t))); end return tmp end
function tmp_2 = code(eh, ew, t) tmp = 0.0; if (ew <= -1.35e+154) tmp = abs((ew * cos(atan((eh * (-1.0 + (1.0 - (t / ew)))))))); elseif (ew <= -1.8e-159) tmp = sqrt(((ew * cos(t)) ^ 2.0)); elseif (ew <= -1e-310) tmp = abs((ew * (1.0 / hypot(1.0, (eh * (tan(t) / ew)))))); elseif (ew <= 2.9e-145) tmp = ew + (eh * (t * sin(atan(((t * eh) / ew))))); else tmp = ew * abs(cos(t)); end tmp_2 = tmp; end
code[eh_, ew_, t_] := If[LessEqual[ew, -1.35e+154], N[Abs[N[(ew * N[Cos[N[ArcTan[N[(eh * N[(-1.0 + N[(1.0 - N[(t / ew), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[ew, -1.8e-159], N[Sqrt[N[Power[N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]], $MachinePrecision], If[LessEqual[ew, -1e-310], N[Abs[N[(ew * N[(1.0 / N[Sqrt[1.0 ^ 2 + N[(eh * N[(N[Tan[t], $MachinePrecision] / ew), $MachinePrecision]), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[ew, 2.9e-145], N[(ew + N[(eh * N[(t * N[Sin[N[ArcTan[N[(N[(t * eh), $MachinePrecision] / ew), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(ew * N[Abs[N[Cos[t], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;ew \leq -1.35 \cdot 10^{+154}:\\
\;\;\;\;\left|ew \cdot \cos \tan^{-1} \left(eh \cdot \left(-1 + \left(1 - \frac{t}{ew}\right)\right)\right)\right|\\
\mathbf{elif}\;ew \leq -1.8 \cdot 10^{-159}:\\
\;\;\;\;\sqrt{{\left(ew \cdot \cos t\right)}^{2}}\\
\mathbf{elif}\;ew \leq -1 \cdot 10^{-310}:\\
\;\;\;\;\left|ew \cdot \frac{1}{\mathsf{hypot}\left(1, eh \cdot \frac{\tan t}{ew}\right)}\right|\\
\mathbf{elif}\;ew \leq 2.9 \cdot 10^{-145}:\\
\;\;\;\;ew + eh \cdot \left(t \cdot \sin \tan^{-1} \left(\frac{t \cdot eh}{ew}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;ew \cdot \left|\cos t\right|\\
\end{array}
\end{array}
if ew < -1.35000000000000003e154Initial program 99.9%
sub-neg99.9%
associate-*l*99.9%
distribute-rgt-neg-in99.9%
cancel-sign-sub99.9%
associate-/l*99.9%
Simplified99.9%
Taylor expanded in t around 0 62.3%
mul-1-neg62.3%
distribute-frac-neg262.3%
associate-/l*62.3%
Simplified62.3%
expm1-log1p-u62.3%
expm1-undefine62.3%
Applied egg-rr62.3%
sub-neg62.3%
log1p-undefine62.3%
rem-exp-log62.3%
distribute-frac-neg262.3%
unsub-neg62.3%
metadata-eval62.3%
Simplified62.3%
Taylor expanded in t around 0 62.3%
if -1.35000000000000003e154 < ew < -1.80000000000000011e-159Initial program 99.7%
sub-neg99.7%
associate-*l*99.7%
distribute-rgt-neg-in99.7%
cancel-sign-sub99.7%
associate-/l*99.7%
Simplified99.7%
Applied egg-rr32.4%
Taylor expanded in ew around inf 19.4%
add-sqr-sqrt18.3%
sqrt-unprod62.7%
pow262.7%
Applied egg-rr62.7%
if -1.80000000000000011e-159 < ew < -9.999999999999969e-311Initial program 99.9%
sub-neg99.9%
associate-*l*99.9%
distribute-rgt-neg-in99.9%
cancel-sign-sub99.9%
associate-/l*99.9%
Simplified99.9%
Taylor expanded in t around 0 29.1%
mul-1-neg29.1%
distribute-frac-neg229.1%
associate-/l*29.1%
Simplified29.1%
cos-atan28.8%
hypot-1-def28.8%
associate-*r/28.8%
Applied egg-rr28.8%
distribute-frac-neg228.8%
distribute-frac-neg28.8%
*-commutative28.8%
distribute-rgt-neg-out28.8%
hypot-undefine28.8%
distribute-rgt-neg-out28.8%
*-commutative28.8%
distribute-frac-neg28.8%
distribute-frac-neg228.8%
distribute-rgt-neg-out28.8%
*-commutative28.8%
distribute-frac-neg28.8%
distribute-frac-neg228.8%
Simplified28.8%
if -9.999999999999969e-311 < ew < 2.89999999999999984e-145Initial program 99.7%
sub-neg99.7%
associate-*l*99.7%
distribute-rgt-neg-in99.7%
cancel-sign-sub99.7%
associate-/l*99.7%
Simplified99.7%
Applied egg-rr68.1%
Taylor expanded in t around 0 43.5%
Taylor expanded in t around 0 44.7%
*-commutative44.7%
Simplified44.7%
if 2.89999999999999984e-145 < ew Initial program 99.8%
sub-neg99.8%
associate-*l*99.8%
distribute-rgt-neg-in99.8%
cancel-sign-sub99.8%
associate-/l*99.8%
Simplified99.8%
Applied egg-rr73.3%
Taylor expanded in ew around inf 64.1%
add-sqr-sqrt63.8%
sqrt-unprod81.3%
pow281.3%
Applied egg-rr81.3%
unpow281.3%
rem-sqrt-square81.3%
Simplified81.3%
Final simplification62.6%
(FPCore (eh ew t)
:precision binary64
(let* ((t_1 (fabs (* ew (/ 1.0 (hypot 1.0 (* eh (/ (tan t) ew))))))))
(if (<= ew -1.35e+154)
t_1
(if (<= ew -2.25e-159)
(sqrt (pow (* ew (cos t)) 2.0))
(if (<= ew -1e-310)
t_1
(if (<= ew 3.1e-143)
(+ ew (* eh (* t (sin (atan (/ (* t eh) ew))))))
(* ew (fabs (cos t)))))))))
double code(double eh, double ew, double t) {
double t_1 = fabs((ew * (1.0 / hypot(1.0, (eh * (tan(t) / ew))))));
double tmp;
if (ew <= -1.35e+154) {
tmp = t_1;
} else if (ew <= -2.25e-159) {
tmp = sqrt(pow((ew * cos(t)), 2.0));
} else if (ew <= -1e-310) {
tmp = t_1;
} else if (ew <= 3.1e-143) {
tmp = ew + (eh * (t * sin(atan(((t * eh) / ew)))));
} else {
tmp = ew * fabs(cos(t));
}
return tmp;
}
public static double code(double eh, double ew, double t) {
double t_1 = Math.abs((ew * (1.0 / Math.hypot(1.0, (eh * (Math.tan(t) / ew))))));
double tmp;
if (ew <= -1.35e+154) {
tmp = t_1;
} else if (ew <= -2.25e-159) {
tmp = Math.sqrt(Math.pow((ew * Math.cos(t)), 2.0));
} else if (ew <= -1e-310) {
tmp = t_1;
} else if (ew <= 3.1e-143) {
tmp = ew + (eh * (t * Math.sin(Math.atan(((t * eh) / ew)))));
} else {
tmp = ew * Math.abs(Math.cos(t));
}
return tmp;
}
def code(eh, ew, t): t_1 = math.fabs((ew * (1.0 / math.hypot(1.0, (eh * (math.tan(t) / ew)))))) tmp = 0 if ew <= -1.35e+154: tmp = t_1 elif ew <= -2.25e-159: tmp = math.sqrt(math.pow((ew * math.cos(t)), 2.0)) elif ew <= -1e-310: tmp = t_1 elif ew <= 3.1e-143: tmp = ew + (eh * (t * math.sin(math.atan(((t * eh) / ew))))) else: tmp = ew * math.fabs(math.cos(t)) return tmp
function code(eh, ew, t) t_1 = abs(Float64(ew * Float64(1.0 / hypot(1.0, Float64(eh * Float64(tan(t) / ew)))))) tmp = 0.0 if (ew <= -1.35e+154) tmp = t_1; elseif (ew <= -2.25e-159) tmp = sqrt((Float64(ew * cos(t)) ^ 2.0)); elseif (ew <= -1e-310) tmp = t_1; elseif (ew <= 3.1e-143) tmp = Float64(ew + Float64(eh * Float64(t * sin(atan(Float64(Float64(t * eh) / ew)))))); else tmp = Float64(ew * abs(cos(t))); end return tmp end
function tmp_2 = code(eh, ew, t) t_1 = abs((ew * (1.0 / hypot(1.0, (eh * (tan(t) / ew)))))); tmp = 0.0; if (ew <= -1.35e+154) tmp = t_1; elseif (ew <= -2.25e-159) tmp = sqrt(((ew * cos(t)) ^ 2.0)); elseif (ew <= -1e-310) tmp = t_1; elseif (ew <= 3.1e-143) tmp = ew + (eh * (t * sin(atan(((t * eh) / ew))))); else tmp = ew * abs(cos(t)); end tmp_2 = tmp; end
code[eh_, ew_, t_] := Block[{t$95$1 = N[Abs[N[(ew * N[(1.0 / N[Sqrt[1.0 ^ 2 + N[(eh * N[(N[Tan[t], $MachinePrecision] / ew), $MachinePrecision]), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[ew, -1.35e+154], t$95$1, If[LessEqual[ew, -2.25e-159], N[Sqrt[N[Power[N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]], $MachinePrecision], If[LessEqual[ew, -1e-310], t$95$1, If[LessEqual[ew, 3.1e-143], N[(ew + N[(eh * N[(t * N[Sin[N[ArcTan[N[(N[(t * eh), $MachinePrecision] / ew), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(ew * N[Abs[N[Cos[t], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left|ew \cdot \frac{1}{\mathsf{hypot}\left(1, eh \cdot \frac{\tan t}{ew}\right)}\right|\\
\mathbf{if}\;ew \leq -1.35 \cdot 10^{+154}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;ew \leq -2.25 \cdot 10^{-159}:\\
\;\;\;\;\sqrt{{\left(ew \cdot \cos t\right)}^{2}}\\
\mathbf{elif}\;ew \leq -1 \cdot 10^{-310}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;ew \leq 3.1 \cdot 10^{-143}:\\
\;\;\;\;ew + eh \cdot \left(t \cdot \sin \tan^{-1} \left(\frac{t \cdot eh}{ew}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;ew \cdot \left|\cos t\right|\\
\end{array}
\end{array}
if ew < -1.35000000000000003e154 or -2.24999999999999994e-159 < ew < -9.999999999999969e-311Initial program 99.9%
sub-neg99.9%
associate-*l*99.9%
distribute-rgt-neg-in99.9%
cancel-sign-sub99.9%
associate-/l*99.9%
Simplified99.9%
Taylor expanded in t around 0 46.9%
mul-1-neg46.9%
distribute-frac-neg246.9%
associate-/l*46.9%
Simplified46.9%
cos-atan46.8%
hypot-1-def46.8%
associate-*r/46.8%
Applied egg-rr46.8%
distribute-frac-neg246.8%
distribute-frac-neg46.8%
*-commutative46.8%
distribute-rgt-neg-out46.8%
hypot-undefine46.8%
distribute-rgt-neg-out46.8%
*-commutative46.8%
distribute-frac-neg46.8%
distribute-frac-neg246.8%
distribute-rgt-neg-out46.8%
*-commutative46.8%
distribute-frac-neg46.8%
distribute-frac-neg246.8%
Simplified46.8%
if -1.35000000000000003e154 < ew < -2.24999999999999994e-159Initial program 99.7%
sub-neg99.7%
associate-*l*99.7%
distribute-rgt-neg-in99.7%
cancel-sign-sub99.7%
associate-/l*99.7%
Simplified99.7%
Applied egg-rr32.4%
Taylor expanded in ew around inf 19.4%
add-sqr-sqrt18.3%
sqrt-unprod62.7%
pow262.7%
Applied egg-rr62.7%
if -9.999999999999969e-311 < ew < 3.10000000000000007e-143Initial program 99.7%
sub-neg99.7%
associate-*l*99.7%
distribute-rgt-neg-in99.7%
cancel-sign-sub99.7%
associate-/l*99.7%
Simplified99.7%
Applied egg-rr68.1%
Taylor expanded in t around 0 43.5%
Taylor expanded in t around 0 44.7%
*-commutative44.7%
Simplified44.7%
if 3.10000000000000007e-143 < ew Initial program 99.8%
sub-neg99.8%
associate-*l*99.8%
distribute-rgt-neg-in99.8%
cancel-sign-sub99.8%
associate-/l*99.8%
Simplified99.8%
Applied egg-rr73.3%
Taylor expanded in ew around inf 64.1%
add-sqr-sqrt63.8%
sqrt-unprod81.3%
pow281.3%
Applied egg-rr81.3%
unpow281.3%
rem-sqrt-square81.3%
Simplified81.3%
(FPCore (eh ew t)
:precision binary64
(let* ((t_1 (fabs (* ew (cos (atan (* eh (/ (- t) ew))))))))
(if (<= ew -1.65e+154)
t_1
(if (<= ew -2.4e-161)
(sqrt (pow (* ew (cos t)) 2.0))
(if (<= ew -1e-310)
t_1
(if (<= ew 9.6e-146)
(+ ew (* eh (* t (sin (atan (/ (* t eh) ew))))))
(* ew (fabs (cos t)))))))))
double code(double eh, double ew, double t) {
double t_1 = fabs((ew * cos(atan((eh * (-t / ew))))));
double tmp;
if (ew <= -1.65e+154) {
tmp = t_1;
} else if (ew <= -2.4e-161) {
tmp = sqrt(pow((ew * cos(t)), 2.0));
} else if (ew <= -1e-310) {
tmp = t_1;
} else if (ew <= 9.6e-146) {
tmp = ew + (eh * (t * sin(atan(((t * eh) / ew)))));
} else {
tmp = ew * fabs(cos(t));
}
return tmp;
}
real(8) function code(eh, ew, t)
real(8), intent (in) :: eh
real(8), intent (in) :: ew
real(8), intent (in) :: t
real(8) :: t_1
real(8) :: tmp
t_1 = abs((ew * cos(atan((eh * (-t / ew))))))
if (ew <= (-1.65d+154)) then
tmp = t_1
else if (ew <= (-2.4d-161)) then
tmp = sqrt(((ew * cos(t)) ** 2.0d0))
else if (ew <= (-1d-310)) then
tmp = t_1
else if (ew <= 9.6d-146) then
tmp = ew + (eh * (t * sin(atan(((t * eh) / ew)))))
else
tmp = ew * abs(cos(t))
end if
code = tmp
end function
public static double code(double eh, double ew, double t) {
double t_1 = Math.abs((ew * Math.cos(Math.atan((eh * (-t / ew))))));
double tmp;
if (ew <= -1.65e+154) {
tmp = t_1;
} else if (ew <= -2.4e-161) {
tmp = Math.sqrt(Math.pow((ew * Math.cos(t)), 2.0));
} else if (ew <= -1e-310) {
tmp = t_1;
} else if (ew <= 9.6e-146) {
tmp = ew + (eh * (t * Math.sin(Math.atan(((t * eh) / ew)))));
} else {
tmp = ew * Math.abs(Math.cos(t));
}
return tmp;
}
def code(eh, ew, t): t_1 = math.fabs((ew * math.cos(math.atan((eh * (-t / ew)))))) tmp = 0 if ew <= -1.65e+154: tmp = t_1 elif ew <= -2.4e-161: tmp = math.sqrt(math.pow((ew * math.cos(t)), 2.0)) elif ew <= -1e-310: tmp = t_1 elif ew <= 9.6e-146: tmp = ew + (eh * (t * math.sin(math.atan(((t * eh) / ew))))) else: tmp = ew * math.fabs(math.cos(t)) return tmp
function code(eh, ew, t) t_1 = abs(Float64(ew * cos(atan(Float64(eh * Float64(Float64(-t) / ew)))))) tmp = 0.0 if (ew <= -1.65e+154) tmp = t_1; elseif (ew <= -2.4e-161) tmp = sqrt((Float64(ew * cos(t)) ^ 2.0)); elseif (ew <= -1e-310) tmp = t_1; elseif (ew <= 9.6e-146) tmp = Float64(ew + Float64(eh * Float64(t * sin(atan(Float64(Float64(t * eh) / ew)))))); else tmp = Float64(ew * abs(cos(t))); end return tmp end
function tmp_2 = code(eh, ew, t) t_1 = abs((ew * cos(atan((eh * (-t / ew)))))); tmp = 0.0; if (ew <= -1.65e+154) tmp = t_1; elseif (ew <= -2.4e-161) tmp = sqrt(((ew * cos(t)) ^ 2.0)); elseif (ew <= -1e-310) tmp = t_1; elseif (ew <= 9.6e-146) tmp = ew + (eh * (t * sin(atan(((t * eh) / ew))))); else tmp = ew * abs(cos(t)); end tmp_2 = tmp; end
code[eh_, ew_, t_] := Block[{t$95$1 = N[Abs[N[(ew * N[Cos[N[ArcTan[N[(eh * N[((-t) / ew), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[ew, -1.65e+154], t$95$1, If[LessEqual[ew, -2.4e-161], N[Sqrt[N[Power[N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]], $MachinePrecision], If[LessEqual[ew, -1e-310], t$95$1, If[LessEqual[ew, 9.6e-146], N[(ew + N[(eh * N[(t * N[Sin[N[ArcTan[N[(N[(t * eh), $MachinePrecision] / ew), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(ew * N[Abs[N[Cos[t], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left|ew \cdot \cos \tan^{-1} \left(eh \cdot \frac{-t}{ew}\right)\right|\\
\mathbf{if}\;ew \leq -1.65 \cdot 10^{+154}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;ew \leq -2.4 \cdot 10^{-161}:\\
\;\;\;\;\sqrt{{\left(ew \cdot \cos t\right)}^{2}}\\
\mathbf{elif}\;ew \leq -1 \cdot 10^{-310}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;ew \leq 9.6 \cdot 10^{-146}:\\
\;\;\;\;ew + eh \cdot \left(t \cdot \sin \tan^{-1} \left(\frac{t \cdot eh}{ew}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;ew \cdot \left|\cos t\right|\\
\end{array}
\end{array}
if ew < -1.65e154 or -2.39999999999999999e-161 < ew < -9.999999999999969e-311Initial program 99.9%
sub-neg99.9%
associate-*l*99.9%
distribute-rgt-neg-in99.9%
cancel-sign-sub99.9%
associate-/l*99.9%
Simplified99.9%
Taylor expanded in t around 0 46.9%
mul-1-neg46.9%
distribute-frac-neg246.9%
associate-/l*46.9%
Simplified46.9%
Taylor expanded in t around 0 45.8%
mul-1-neg45.8%
associate-/l*45.8%
distribute-rgt-neg-in45.8%
distribute-neg-frac245.8%
Simplified45.8%
if -1.65e154 < ew < -2.39999999999999999e-161Initial program 99.7%
sub-neg99.7%
associate-*l*99.7%
distribute-rgt-neg-in99.7%
cancel-sign-sub99.7%
associate-/l*99.7%
Simplified99.7%
Applied egg-rr32.4%
Taylor expanded in ew around inf 19.4%
add-sqr-sqrt18.3%
sqrt-unprod62.7%
pow262.7%
Applied egg-rr62.7%
if -9.999999999999969e-311 < ew < 9.6000000000000006e-146Initial program 99.7%
sub-neg99.7%
associate-*l*99.7%
distribute-rgt-neg-in99.7%
cancel-sign-sub99.7%
associate-/l*99.7%
Simplified99.7%
Applied egg-rr68.1%
Taylor expanded in t around 0 43.5%
Taylor expanded in t around 0 44.7%
*-commutative44.7%
Simplified44.7%
if 9.6000000000000006e-146 < ew Initial program 99.8%
sub-neg99.8%
associate-*l*99.8%
distribute-rgt-neg-in99.8%
cancel-sign-sub99.8%
associate-/l*99.8%
Simplified99.8%
Applied egg-rr73.3%
Taylor expanded in ew around inf 64.1%
add-sqr-sqrt63.8%
sqrt-unprod81.3%
pow281.3%
Applied egg-rr81.3%
unpow281.3%
rem-sqrt-square81.3%
Simplified81.3%
Final simplification62.3%
(FPCore (eh ew t)
:precision binary64
(if (<= ew -1e-310)
(sqrt (pow (* ew (cos t)) 2.0))
(if (<= ew 3.4e-144)
(+ ew (* eh (* t (sin (atan (/ (* t eh) ew))))))
(* ew (fabs (cos t))))))
double code(double eh, double ew, double t) {
double tmp;
if (ew <= -1e-310) {
tmp = sqrt(pow((ew * cos(t)), 2.0));
} else if (ew <= 3.4e-144) {
tmp = ew + (eh * (t * sin(atan(((t * eh) / ew)))));
} else {
tmp = ew * fabs(cos(t));
}
return tmp;
}
real(8) function code(eh, ew, t)
real(8), intent (in) :: eh
real(8), intent (in) :: ew
real(8), intent (in) :: t
real(8) :: tmp
if (ew <= (-1d-310)) then
tmp = sqrt(((ew * cos(t)) ** 2.0d0))
else if (ew <= 3.4d-144) then
tmp = ew + (eh * (t * sin(atan(((t * eh) / ew)))))
else
tmp = ew * abs(cos(t))
end if
code = tmp
end function
public static double code(double eh, double ew, double t) {
double tmp;
if (ew <= -1e-310) {
tmp = Math.sqrt(Math.pow((ew * Math.cos(t)), 2.0));
} else if (ew <= 3.4e-144) {
tmp = ew + (eh * (t * Math.sin(Math.atan(((t * eh) / ew)))));
} else {
tmp = ew * Math.abs(Math.cos(t));
}
return tmp;
}
def code(eh, ew, t): tmp = 0 if ew <= -1e-310: tmp = math.sqrt(math.pow((ew * math.cos(t)), 2.0)) elif ew <= 3.4e-144: tmp = ew + (eh * (t * math.sin(math.atan(((t * eh) / ew))))) else: tmp = ew * math.fabs(math.cos(t)) return tmp
function code(eh, ew, t) tmp = 0.0 if (ew <= -1e-310) tmp = sqrt((Float64(ew * cos(t)) ^ 2.0)); elseif (ew <= 3.4e-144) tmp = Float64(ew + Float64(eh * Float64(t * sin(atan(Float64(Float64(t * eh) / ew)))))); else tmp = Float64(ew * abs(cos(t))); end return tmp end
function tmp_2 = code(eh, ew, t) tmp = 0.0; if (ew <= -1e-310) tmp = sqrt(((ew * cos(t)) ^ 2.0)); elseif (ew <= 3.4e-144) tmp = ew + (eh * (t * sin(atan(((t * eh) / ew))))); else tmp = ew * abs(cos(t)); end tmp_2 = tmp; end
code[eh_, ew_, t_] := If[LessEqual[ew, -1e-310], N[Sqrt[N[Power[N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]], $MachinePrecision], If[LessEqual[ew, 3.4e-144], N[(ew + N[(eh * N[(t * N[Sin[N[ArcTan[N[(N[(t * eh), $MachinePrecision] / ew), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(ew * N[Abs[N[Cos[t], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;ew \leq -1 \cdot 10^{-310}:\\
\;\;\;\;\sqrt{{\left(ew \cdot \cos t\right)}^{2}}\\
\mathbf{elif}\;ew \leq 3.4 \cdot 10^{-144}:\\
\;\;\;\;ew + eh \cdot \left(t \cdot \sin \tan^{-1} \left(\frac{t \cdot eh}{ew}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;ew \cdot \left|\cos t\right|\\
\end{array}
\end{array}
if ew < -9.999999999999969e-311Initial program 99.8%
sub-neg99.8%
associate-*l*99.8%
distribute-rgt-neg-in99.8%
cancel-sign-sub99.8%
associate-/l*99.8%
Simplified99.8%
Applied egg-rr23.5%
Taylor expanded in ew around inf 15.5%
add-sqr-sqrt14.0%
sqrt-unprod31.7%
pow231.7%
Applied egg-rr31.7%
if -9.999999999999969e-311 < ew < 3.40000000000000017e-144Initial program 99.7%
sub-neg99.7%
associate-*l*99.7%
distribute-rgt-neg-in99.7%
cancel-sign-sub99.7%
associate-/l*99.7%
Simplified99.7%
Applied egg-rr68.1%
Taylor expanded in t around 0 43.5%
Taylor expanded in t around 0 44.7%
*-commutative44.7%
Simplified44.7%
if 3.40000000000000017e-144 < ew Initial program 99.8%
sub-neg99.8%
associate-*l*99.8%
distribute-rgt-neg-in99.8%
cancel-sign-sub99.8%
associate-/l*99.8%
Simplified99.8%
Applied egg-rr73.3%
Taylor expanded in ew around inf 64.1%
add-sqr-sqrt63.8%
sqrt-unprod81.3%
pow281.3%
Applied egg-rr81.3%
unpow281.3%
rem-sqrt-square81.3%
Simplified81.3%
(FPCore (eh ew t)
:precision binary64
(if (<= ew -1e-310)
(* ew (cos t))
(if (<= ew 4.7e-147)
(+ ew (* eh (* t (sin (atan (/ (* t eh) ew))))))
(* ew (fabs (cos t))))))
double code(double eh, double ew, double t) {
double tmp;
if (ew <= -1e-310) {
tmp = ew * cos(t);
} else if (ew <= 4.7e-147) {
tmp = ew + (eh * (t * sin(atan(((t * eh) / ew)))));
} else {
tmp = ew * fabs(cos(t));
}
return tmp;
}
real(8) function code(eh, ew, t)
real(8), intent (in) :: eh
real(8), intent (in) :: ew
real(8), intent (in) :: t
real(8) :: tmp
if (ew <= (-1d-310)) then
tmp = ew * cos(t)
else if (ew <= 4.7d-147) then
tmp = ew + (eh * (t * sin(atan(((t * eh) / ew)))))
else
tmp = ew * abs(cos(t))
end if
code = tmp
end function
public static double code(double eh, double ew, double t) {
double tmp;
if (ew <= -1e-310) {
tmp = ew * Math.cos(t);
} else if (ew <= 4.7e-147) {
tmp = ew + (eh * (t * Math.sin(Math.atan(((t * eh) / ew)))));
} else {
tmp = ew * Math.abs(Math.cos(t));
}
return tmp;
}
def code(eh, ew, t): tmp = 0 if ew <= -1e-310: tmp = ew * math.cos(t) elif ew <= 4.7e-147: tmp = ew + (eh * (t * math.sin(math.atan(((t * eh) / ew))))) else: tmp = ew * math.fabs(math.cos(t)) return tmp
function code(eh, ew, t) tmp = 0.0 if (ew <= -1e-310) tmp = Float64(ew * cos(t)); elseif (ew <= 4.7e-147) tmp = Float64(ew + Float64(eh * Float64(t * sin(atan(Float64(Float64(t * eh) / ew)))))); else tmp = Float64(ew * abs(cos(t))); end return tmp end
function tmp_2 = code(eh, ew, t) tmp = 0.0; if (ew <= -1e-310) tmp = ew * cos(t); elseif (ew <= 4.7e-147) tmp = ew + (eh * (t * sin(atan(((t * eh) / ew))))); else tmp = ew * abs(cos(t)); end tmp_2 = tmp; end
code[eh_, ew_, t_] := If[LessEqual[ew, -1e-310], N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision], If[LessEqual[ew, 4.7e-147], N[(ew + N[(eh * N[(t * N[Sin[N[ArcTan[N[(N[(t * eh), $MachinePrecision] / ew), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(ew * N[Abs[N[Cos[t], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;ew \leq -1 \cdot 10^{-310}:\\
\;\;\;\;ew \cdot \cos t\\
\mathbf{elif}\;ew \leq 4.7 \cdot 10^{-147}:\\
\;\;\;\;ew + eh \cdot \left(t \cdot \sin \tan^{-1} \left(\frac{t \cdot eh}{ew}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;ew \cdot \left|\cos t\right|\\
\end{array}
\end{array}
if ew < -9.999999999999969e-311Initial program 99.8%
sub-neg99.8%
associate-*l*99.8%
distribute-rgt-neg-in99.8%
cancel-sign-sub99.8%
associate-/l*99.8%
Simplified99.8%
Applied egg-rr23.5%
Taylor expanded in ew around inf 15.5%
if -9.999999999999969e-311 < ew < 4.69999999999999989e-147Initial program 99.7%
sub-neg99.7%
associate-*l*99.7%
distribute-rgt-neg-in99.7%
cancel-sign-sub99.7%
associate-/l*99.7%
Simplified99.7%
Applied egg-rr68.1%
Taylor expanded in t around 0 43.5%
Taylor expanded in t around 0 44.7%
*-commutative44.7%
Simplified44.7%
if 4.69999999999999989e-147 < ew Initial program 99.8%
sub-neg99.8%
associate-*l*99.8%
distribute-rgt-neg-in99.8%
cancel-sign-sub99.8%
associate-/l*99.8%
Simplified99.8%
Applied egg-rr73.3%
Taylor expanded in ew around inf 64.1%
add-sqr-sqrt63.8%
sqrt-unprod81.3%
pow281.3%
Applied egg-rr81.3%
unpow281.3%
rem-sqrt-square81.3%
Simplified81.3%
(FPCore (eh ew t) :precision binary64 (if (<= ew -2.5e-302) (* ew (cos t)) (* ew (fabs (cos t)))))
double code(double eh, double ew, double t) {
double tmp;
if (ew <= -2.5e-302) {
tmp = ew * cos(t);
} else {
tmp = ew * fabs(cos(t));
}
return tmp;
}
real(8) function code(eh, ew, t)
real(8), intent (in) :: eh
real(8), intent (in) :: ew
real(8), intent (in) :: t
real(8) :: tmp
if (ew <= (-2.5d-302)) then
tmp = ew * cos(t)
else
tmp = ew * abs(cos(t))
end if
code = tmp
end function
public static double code(double eh, double ew, double t) {
double tmp;
if (ew <= -2.5e-302) {
tmp = ew * Math.cos(t);
} else {
tmp = ew * Math.abs(Math.cos(t));
}
return tmp;
}
def code(eh, ew, t): tmp = 0 if ew <= -2.5e-302: tmp = ew * math.cos(t) else: tmp = ew * math.fabs(math.cos(t)) return tmp
function code(eh, ew, t) tmp = 0.0 if (ew <= -2.5e-302) tmp = Float64(ew * cos(t)); else tmp = Float64(ew * abs(cos(t))); end return tmp end
function tmp_2 = code(eh, ew, t) tmp = 0.0; if (ew <= -2.5e-302) tmp = ew * cos(t); else tmp = ew * abs(cos(t)); end tmp_2 = tmp; end
code[eh_, ew_, t_] := If[LessEqual[ew, -2.5e-302], N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision], N[(ew * N[Abs[N[Cos[t], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;ew \leq -2.5 \cdot 10^{-302}:\\
\;\;\;\;ew \cdot \cos t\\
\mathbf{else}:\\
\;\;\;\;ew \cdot \left|\cos t\right|\\
\end{array}
\end{array}
if ew < -2.50000000000000017e-302Initial program 99.8%
sub-neg99.8%
associate-*l*99.8%
distribute-rgt-neg-in99.8%
cancel-sign-sub99.8%
associate-/l*99.8%
Simplified99.8%
Applied egg-rr23.7%
Taylor expanded in ew around inf 15.6%
if -2.50000000000000017e-302 < ew Initial program 99.8%
sub-neg99.8%
associate-*l*99.8%
distribute-rgt-neg-in99.8%
cancel-sign-sub99.8%
associate-/l*99.8%
Simplified99.8%
Applied egg-rr71.3%
Taylor expanded in ew around inf 49.9%
add-sqr-sqrt49.4%
sqrt-unprod62.7%
pow262.7%
Applied egg-rr62.7%
unpow262.7%
rem-sqrt-square62.7%
Simplified62.7%
(FPCore (eh ew t) :precision binary64 (* ew (cos t)))
double code(double eh, double ew, double t) {
return ew * cos(t);
}
real(8) function code(eh, ew, t)
real(8), intent (in) :: eh
real(8), intent (in) :: ew
real(8), intent (in) :: t
code = ew * cos(t)
end function
public static double code(double eh, double ew, double t) {
return ew * Math.cos(t);
}
def code(eh, ew, t): return ew * math.cos(t)
function code(eh, ew, t) return Float64(ew * cos(t)) end
function tmp = code(eh, ew, t) tmp = ew * cos(t); end
code[eh_, ew_, t_] := N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
ew \cdot \cos t
\end{array}
Initial program 99.8%
sub-neg99.8%
associate-*l*99.8%
distribute-rgt-neg-in99.8%
cancel-sign-sub99.8%
associate-/l*99.8%
Simplified99.8%
Applied egg-rr48.6%
Taylor expanded in ew around inf 33.5%
(FPCore (eh ew t) :precision binary64 ew)
double code(double eh, double ew, double t) {
return ew;
}
real(8) function code(eh, ew, t)
real(8), intent (in) :: eh
real(8), intent (in) :: ew
real(8), intent (in) :: t
code = ew
end function
public static double code(double eh, double ew, double t) {
return ew;
}
def code(eh, ew, t): return ew
function code(eh, ew, t) return ew end
function tmp = code(eh, ew, t) tmp = ew; end
code[eh_, ew_, t_] := ew
\begin{array}{l}
\\
ew
\end{array}
Initial program 99.8%
sub-neg99.8%
associate-*l*99.8%
distribute-rgt-neg-in99.8%
cancel-sign-sub99.8%
associate-/l*99.8%
Simplified99.8%
Applied egg-rr48.6%
Taylor expanded in t around 0 22.0%
herbie shell --seed 2024113
(FPCore (eh ew t)
:name "Example 2 from Robby"
:precision binary64
(fabs (- (* (* ew (cos t)) (cos (atan (/ (* (- eh) (tan t)) ew)))) (* (* eh (sin t)) (sin (atan (/ (* (- eh) (tan t)) ew)))))))