
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(*
(acos
(+
(* (sin phi1) (sin phi2))
(* (* (cos phi1) (cos phi2)) (cos (- lambda1 lambda2)))))
R))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return acos(((sin(phi1) * sin(phi2)) + ((cos(phi1) * cos(phi2)) * cos((lambda1 - lambda2))))) * R;
}
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
code = acos(((sin(phi1) * sin(phi2)) + ((cos(phi1) * cos(phi2)) * cos((lambda1 - lambda2))))) * r
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return Math.acos(((Math.sin(phi1) * Math.sin(phi2)) + ((Math.cos(phi1) * Math.cos(phi2)) * Math.cos((lambda1 - lambda2))))) * R;
}
def code(R, lambda1, lambda2, phi1, phi2): return math.acos(((math.sin(phi1) * math.sin(phi2)) + ((math.cos(phi1) * math.cos(phi2)) * math.cos((lambda1 - lambda2))))) * R
function code(R, lambda1, lambda2, phi1, phi2) return Float64(acos(Float64(Float64(sin(phi1) * sin(phi2)) + Float64(Float64(cos(phi1) * cos(phi2)) * cos(Float64(lambda1 - lambda2))))) * R) end
function tmp = code(R, lambda1, lambda2, phi1, phi2) tmp = acos(((sin(phi1) * sin(phi2)) + ((cos(phi1) * cos(phi2)) * cos((lambda1 - lambda2))))) * R; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(N[ArcCos[N[(N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] + N[(N[(N[Cos[phi1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * R), $MachinePrecision]
\begin{array}{l}
\\
\cos^{-1} \left(\sin \phi_1 \cdot \sin \phi_2 + \left(\cos \phi_1 \cdot \cos \phi_2\right) \cdot \cos \left(\lambda_1 - \lambda_2\right)\right) \cdot R
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 31 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(*
(acos
(+
(* (sin phi1) (sin phi2))
(* (* (cos phi1) (cos phi2)) (cos (- lambda1 lambda2)))))
R))
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return acos(((sin(phi1) * sin(phi2)) + ((cos(phi1) * cos(phi2)) * cos((lambda1 - lambda2))))) * R;
}
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
code = acos(((sin(phi1) * sin(phi2)) + ((cos(phi1) * cos(phi2)) * cos((lambda1 - lambda2))))) * r
end function
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return Math.acos(((Math.sin(phi1) * Math.sin(phi2)) + ((Math.cos(phi1) * Math.cos(phi2)) * Math.cos((lambda1 - lambda2))))) * R;
}
def code(R, lambda1, lambda2, phi1, phi2): return math.acos(((math.sin(phi1) * math.sin(phi2)) + ((math.cos(phi1) * math.cos(phi2)) * math.cos((lambda1 - lambda2))))) * R
function code(R, lambda1, lambda2, phi1, phi2) return Float64(acos(Float64(Float64(sin(phi1) * sin(phi2)) + Float64(Float64(cos(phi1) * cos(phi2)) * cos(Float64(lambda1 - lambda2))))) * R) end
function tmp = code(R, lambda1, lambda2, phi1, phi2) tmp = acos(((sin(phi1) * sin(phi2)) + ((cos(phi1) * cos(phi2)) * cos((lambda1 - lambda2))))) * R; end
code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(N[ArcCos[N[(N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] + N[(N[(N[Cos[phi1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * R), $MachinePrecision]
\begin{array}{l}
\\
\cos^{-1} \left(\sin \phi_1 \cdot \sin \phi_2 + \left(\cos \phi_1 \cdot \cos \phi_2\right) \cdot \cos \left(\lambda_1 - \lambda_2\right)\right) \cdot R
\end{array}
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (cos phi2))))
(if (<=
(+ (* (sin phi1) (sin phi2)) (* t_0 (cos (- lambda1 lambda2))))
0.9999)
(*
(acos
(+
(* (sin phi2) (cbrt (pow (sin phi1) 3.0)))
(*
t_0
(fma (cos lambda1) (cos lambda2) (* (sin lambda1) (sin lambda2))))))
R)
(* R (fabs (remainder lambda1 (* 2.0 PI)))))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi1) * cos(phi2);
double tmp;
if (((sin(phi1) * sin(phi2)) + (t_0 * cos((lambda1 - lambda2)))) <= 0.9999) {
tmp = acos(((sin(phi2) * cbrt(pow(sin(phi1), 3.0))) + (t_0 * fma(cos(lambda1), cos(lambda2), (sin(lambda1) * sin(lambda2)))))) * R;
} else {
tmp = R * fabs(remainder(lambda1, (2.0 * ((double) M_PI))));
}
return tmp;
}
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] + N[(t$95$0 * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.9999], N[(N[ArcCos[N[(N[(N[Sin[phi2], $MachinePrecision] * N[Power[N[Power[N[Sin[phi1], $MachinePrecision], 3.0], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision] + N[(t$95$0 * N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * R), $MachinePrecision], N[(R * N[Abs[N[With[{TMP1 = lambda1, TMP2 = N[(2.0 * Pi), $MachinePrecision]}, TMP1 - Round[TMP1 / TMP2] * TMP2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
t_0 := \cos \phi_1 \cdot \cos \phi_2\\
\mathbf{if}\;\sin \phi_1 \cdot \sin \phi_2 + t\_0 \cdot \cos \left(\lambda_1 - \lambda_2\right) \leq 0.9999:\\
\;\;\;\;\cos^{-1} \left(\sin \phi_2 \cdot \sqrt[3]{{\sin \phi_1}^{3}} + t\_0 \cdot \mathsf{fma}\left(\cos \lambda_1, \cos \lambda_2, \sin \lambda_1 \cdot \sin \lambda_2\right)\right) \cdot R\\
\mathbf{else}:\\
\;\;\;\;R \cdot \left|\left(\lambda_1 \mathsf{rem} \left(2 \cdot \pi\right)\right)\right|\\
\end{array}
\end{array}
if (+.f64 (*.f64 (sin.f64 phi1) (sin.f64 phi2)) (*.f64 (*.f64 (cos.f64 phi1) (cos.f64 phi2)) (cos.f64 (-.f64 lambda1 lambda2)))) < 0.99990000000000001Initial program 77.3%
cos-diff99.2%
distribute-lft-in99.1%
Applied egg-rr99.1%
distribute-lft-out99.2%
*-commutative99.2%
fma-define99.2%
Simplified99.2%
add-cbrt-cube99.2%
pow399.2%
Applied egg-rr99.2%
if 0.99990000000000001 < (+.f64 (*.f64 (sin.f64 phi1) (sin.f64 phi2)) (*.f64 (*.f64 (cos.f64 phi1) (cos.f64 phi2)) (cos.f64 (-.f64 lambda1 lambda2)))) Initial program 11.2%
+-commutative11.2%
associate-*l*11.2%
fma-define11.2%
Simplified11.2%
Taylor expanded in lambda2 around 0 10.0%
associate-*r*10.0%
fma-define10.0%
*-commutative10.0%
*-commutative10.0%
Simplified10.0%
Taylor expanded in phi1 around 0 10.0%
Taylor expanded in phi2 around 0 10.0%
acos-cos24.7%
Applied egg-rr24.7%
Final simplification94.5%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (cos phi2))))
(if (<=
(+ (* (sin phi1) (sin phi2)) (* t_0 (cos (- lambda1 lambda2))))
0.9999)
(*
R
(acos
(fma
(sin phi2)
(sin phi1)
(*
t_0
(fma (cos lambda1) (cos lambda2) (* (sin lambda1) (sin lambda2)))))))
(* R (fabs (remainder lambda1 (* 2.0 PI)))))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi1) * cos(phi2);
double tmp;
if (((sin(phi1) * sin(phi2)) + (t_0 * cos((lambda1 - lambda2)))) <= 0.9999) {
tmp = R * acos(fma(sin(phi2), sin(phi1), (t_0 * fma(cos(lambda1), cos(lambda2), (sin(lambda1) * sin(lambda2))))));
} else {
tmp = R * fabs(remainder(lambda1, (2.0 * ((double) M_PI))));
}
return tmp;
}
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] + N[(t$95$0 * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.9999], N[(R * N[ArcCos[N[(N[Sin[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision] + N[(t$95$0 * N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[Abs[N[With[{TMP1 = lambda1, TMP2 = N[(2.0 * Pi), $MachinePrecision]}, TMP1 - Round[TMP1 / TMP2] * TMP2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
t_0 := \cos \phi_1 \cdot \cos \phi_2\\
\mathbf{if}\;\sin \phi_1 \cdot \sin \phi_2 + t\_0 \cdot \cos \left(\lambda_1 - \lambda_2\right) \leq 0.9999:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\sin \phi_2, \sin \phi_1, t\_0 \cdot \mathsf{fma}\left(\cos \lambda_1, \cos \lambda_2, \sin \lambda_1 \cdot \sin \lambda_2\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \left|\left(\lambda_1 \mathsf{rem} \left(2 \cdot \pi\right)\right)\right|\\
\end{array}
\end{array}
if (+.f64 (*.f64 (sin.f64 phi1) (sin.f64 phi2)) (*.f64 (*.f64 (cos.f64 phi1) (cos.f64 phi2)) (cos.f64 (-.f64 lambda1 lambda2)))) < 0.99990000000000001Initial program 77.3%
cos-diff99.2%
distribute-lft-in99.1%
Applied egg-rr99.1%
distribute-lft-out99.2%
*-commutative99.2%
fma-define99.2%
Simplified99.2%
add-cbrt-cube99.2%
pow399.2%
Applied egg-rr99.2%
Taylor expanded in phi1 around 0 99.1%
+-commutative99.1%
*-commutative99.1%
fma-define99.2%
*-commutative99.2%
*-commutative99.2%
associate-*l*99.2%
fma-define99.2%
*-commutative99.2%
Simplified99.2%
if 0.99990000000000001 < (+.f64 (*.f64 (sin.f64 phi1) (sin.f64 phi2)) (*.f64 (*.f64 (cos.f64 phi1) (cos.f64 phi2)) (cos.f64 (-.f64 lambda1 lambda2)))) Initial program 11.2%
+-commutative11.2%
associate-*l*11.2%
fma-define11.2%
Simplified11.2%
Taylor expanded in lambda2 around 0 10.0%
associate-*r*10.0%
fma-define10.0%
*-commutative10.0%
*-commutative10.0%
Simplified10.0%
Taylor expanded in phi1 around 0 10.0%
Taylor expanded in phi2 around 0 10.0%
acos-cos24.7%
Applied egg-rr24.7%
Final simplification94.5%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (sin phi1) (sin phi2))) (t_1 (* (cos phi1) (cos phi2))))
(if (<= (+ t_0 (* t_1 (cos (- lambda1 lambda2)))) 0.9999)
(*
R
(acos
(+
t_0
(*
t_1
(fma (cos lambda1) (cos lambda2) (* (sin lambda1) (sin lambda2)))))))
(* R (fabs (remainder lambda1 (* 2.0 PI)))))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = sin(phi1) * sin(phi2);
double t_1 = cos(phi1) * cos(phi2);
double tmp;
if ((t_0 + (t_1 * cos((lambda1 - lambda2)))) <= 0.9999) {
tmp = R * acos((t_0 + (t_1 * fma(cos(lambda1), cos(lambda2), (sin(lambda1) * sin(lambda2))))));
} else {
tmp = R * fabs(remainder(lambda1, (2.0 * ((double) M_PI))));
}
return tmp;
}
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[Cos[phi1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(t$95$0 + N[(t$95$1 * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.9999], N[(R * N[ArcCos[N[(t$95$0 + N[(t$95$1 * N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[Abs[N[With[{TMP1 = lambda1, TMP2 = N[(2.0 * Pi), $MachinePrecision]}, TMP1 - Round[TMP1 / TMP2] * TMP2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
t_0 := \sin \phi_1 \cdot \sin \phi_2\\
t_1 := \cos \phi_1 \cdot \cos \phi_2\\
\mathbf{if}\;t\_0 + t\_1 \cdot \cos \left(\lambda_1 - \lambda_2\right) \leq 0.9999:\\
\;\;\;\;R \cdot \cos^{-1} \left(t\_0 + t\_1 \cdot \mathsf{fma}\left(\cos \lambda_1, \cos \lambda_2, \sin \lambda_1 \cdot \sin \lambda_2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \left|\left(\lambda_1 \mathsf{rem} \left(2 \cdot \pi\right)\right)\right|\\
\end{array}
\end{array}
if (+.f64 (*.f64 (sin.f64 phi1) (sin.f64 phi2)) (*.f64 (*.f64 (cos.f64 phi1) (cos.f64 phi2)) (cos.f64 (-.f64 lambda1 lambda2)))) < 0.99990000000000001Initial program 77.3%
cos-diff99.2%
distribute-lft-in99.1%
Applied egg-rr99.1%
distribute-lft-out99.2%
*-commutative99.2%
fma-define99.2%
Simplified99.2%
if 0.99990000000000001 < (+.f64 (*.f64 (sin.f64 phi1) (sin.f64 phi2)) (*.f64 (*.f64 (cos.f64 phi1) (cos.f64 phi2)) (cos.f64 (-.f64 lambda1 lambda2)))) Initial program 11.2%
+-commutative11.2%
associate-*l*11.2%
fma-define11.2%
Simplified11.2%
Taylor expanded in lambda2 around 0 10.0%
associate-*r*10.0%
fma-define10.0%
*-commutative10.0%
*-commutative10.0%
Simplified10.0%
Taylor expanded in phi1 around 0 10.0%
Taylor expanded in phi2 around 0 10.0%
acos-cos24.7%
Applied egg-rr24.7%
Final simplification94.5%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (sin phi1) (sin phi2))) (t_1 (* (cos phi1) (cos phi2))))
(if (<= (+ t_0 (* t_1 (cos (- lambda1 lambda2)))) 0.9999)
(*
R
(acos
(+
t_0
(*
t_1
(+
(* (sin lambda1) (sin lambda2))
(* (cos lambda1) (cos lambda2)))))))
(* R (fabs (remainder lambda1 (* 2.0 PI)))))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = sin(phi1) * sin(phi2);
double t_1 = cos(phi1) * cos(phi2);
double tmp;
if ((t_0 + (t_1 * cos((lambda1 - lambda2)))) <= 0.9999) {
tmp = R * acos((t_0 + (t_1 * ((sin(lambda1) * sin(lambda2)) + (cos(lambda1) * cos(lambda2))))));
} else {
tmp = R * fabs(remainder(lambda1, (2.0 * ((double) M_PI))));
}
return tmp;
}
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = Math.sin(phi1) * Math.sin(phi2);
double t_1 = Math.cos(phi1) * Math.cos(phi2);
double tmp;
if ((t_0 + (t_1 * Math.cos((lambda1 - lambda2)))) <= 0.9999) {
tmp = R * Math.acos((t_0 + (t_1 * ((Math.sin(lambda1) * Math.sin(lambda2)) + (Math.cos(lambda1) * Math.cos(lambda2))))));
} else {
tmp = R * Math.abs(Math.IEEEremainder(lambda1, (2.0 * Math.PI)));
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) [R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): t_0 = math.sin(phi1) * math.sin(phi2) t_1 = math.cos(phi1) * math.cos(phi2) tmp = 0 if (t_0 + (t_1 * math.cos((lambda1 - lambda2)))) <= 0.9999: tmp = R * math.acos((t_0 + (t_1 * ((math.sin(lambda1) * math.sin(lambda2)) + (math.cos(lambda1) * math.cos(lambda2)))))) else: tmp = R * math.fabs(math.remainder(lambda1, (2.0 * math.pi))) return tmp
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[Cos[phi1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(t$95$0 + N[(t$95$1 * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.9999], N[(R * N[ArcCos[N[(t$95$0 + N[(t$95$1 * N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision] + N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[Abs[N[With[{TMP1 = lambda1, TMP2 = N[(2.0 * Pi), $MachinePrecision]}, TMP1 - Round[TMP1 / TMP2] * TMP2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
t_0 := \sin \phi_1 \cdot \sin \phi_2\\
t_1 := \cos \phi_1 \cdot \cos \phi_2\\
\mathbf{if}\;t\_0 + t\_1 \cdot \cos \left(\lambda_1 - \lambda_2\right) \leq 0.9999:\\
\;\;\;\;R \cdot \cos^{-1} \left(t\_0 + t\_1 \cdot \left(\sin \lambda_1 \cdot \sin \lambda_2 + \cos \lambda_1 \cdot \cos \lambda_2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \left|\left(\lambda_1 \mathsf{rem} \left(2 \cdot \pi\right)\right)\right|\\
\end{array}
\end{array}
if (+.f64 (*.f64 (sin.f64 phi1) (sin.f64 phi2)) (*.f64 (*.f64 (cos.f64 phi1) (cos.f64 phi2)) (cos.f64 (-.f64 lambda1 lambda2)))) < 0.99990000000000001Initial program 77.3%
cos-diff99.2%
+-commutative99.2%
Applied egg-rr99.2%
if 0.99990000000000001 < (+.f64 (*.f64 (sin.f64 phi1) (sin.f64 phi2)) (*.f64 (*.f64 (cos.f64 phi1) (cos.f64 phi2)) (cos.f64 (-.f64 lambda1 lambda2)))) Initial program 11.2%
+-commutative11.2%
associate-*l*11.2%
fma-define11.2%
Simplified11.2%
Taylor expanded in lambda2 around 0 10.0%
associate-*r*10.0%
fma-define10.0%
*-commutative10.0%
*-commutative10.0%
Simplified10.0%
Taylor expanded in phi1 around 0 10.0%
Taylor expanded in phi2 around 0 10.0%
acos-cos24.7%
Applied egg-rr24.7%
Final simplification94.5%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (cos (- lambda1 lambda2))) (t_1 (* (cos phi1) (cos phi2))))
(if (<= phi1 -3.25e+47)
(* R (acos (+ (* t_1 t_0) (* (sin phi2) (log1p (expm1 (sin phi1)))))))
(if (<= phi1 0.033)
(*
R
(acos
(+
(*
t_1
(fma (cos lambda1) (cos lambda2) (* (sin lambda1) (sin lambda2))))
(* phi1 (sin phi2)))))
(* R (acos (log (exp (fma t_1 t_0 (* (sin phi1) (sin phi2)))))))))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos((lambda1 - lambda2));
double t_1 = cos(phi1) * cos(phi2);
double tmp;
if (phi1 <= -3.25e+47) {
tmp = R * acos(((t_1 * t_0) + (sin(phi2) * log1p(expm1(sin(phi1))))));
} else if (phi1 <= 0.033) {
tmp = R * acos(((t_1 * fma(cos(lambda1), cos(lambda2), (sin(lambda1) * sin(lambda2)))) + (phi1 * sin(phi2))));
} else {
tmp = R * acos(log(exp(fma(t_1, t_0, (sin(phi1) * sin(phi2))))));
}
return tmp;
}
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) t_0 = cos(Float64(lambda1 - lambda2)) t_1 = Float64(cos(phi1) * cos(phi2)) tmp = 0.0 if (phi1 <= -3.25e+47) tmp = Float64(R * acos(Float64(Float64(t_1 * t_0) + Float64(sin(phi2) * log1p(expm1(sin(phi1))))))); elseif (phi1 <= 0.033) tmp = Float64(R * acos(Float64(Float64(t_1 * fma(cos(lambda1), cos(lambda2), Float64(sin(lambda1) * sin(lambda2)))) + Float64(phi1 * sin(phi2))))); else tmp = Float64(R * acos(log(exp(fma(t_1, t_0, Float64(sin(phi1) * sin(phi2))))))); end return tmp end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[(N[Cos[phi1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[phi1, -3.25e+47], N[(R * N[ArcCos[N[(N[(t$95$1 * t$95$0), $MachinePrecision] + N[(N[Sin[phi2], $MachinePrecision] * N[Log[1 + N[(Exp[N[Sin[phi1], $MachinePrecision]] - 1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 0.033], N[(R * N[ArcCos[N[(N[(t$95$1 * N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(phi1 * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[Log[N[Exp[N[(t$95$1 * t$95$0 + N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
t_0 := \cos \left(\lambda_1 - \lambda_2\right)\\
t_1 := \cos \phi_1 \cdot \cos \phi_2\\
\mathbf{if}\;\phi_1 \leq -3.25 \cdot 10^{+47}:\\
\;\;\;\;R \cdot \cos^{-1} \left(t\_1 \cdot t\_0 + \sin \phi_2 \cdot \mathsf{log1p}\left(\mathsf{expm1}\left(\sin \phi_1\right)\right)\right)\\
\mathbf{elif}\;\phi_1 \leq 0.033:\\
\;\;\;\;R \cdot \cos^{-1} \left(t\_1 \cdot \mathsf{fma}\left(\cos \lambda_1, \cos \lambda_2, \sin \lambda_1 \cdot \sin \lambda_2\right) + \phi_1 \cdot \sin \phi_2\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \log \left(e^{\mathsf{fma}\left(t\_1, t\_0, \sin \phi_1 \cdot \sin \phi_2\right)}\right)\\
\end{array}
\end{array}
if phi1 < -3.24999999999999994e47Initial program 86.1%
log1p-expm1-u86.1%
Applied egg-rr86.1%
if -3.24999999999999994e47 < phi1 < 0.033000000000000002Initial program 64.1%
cos-diff88.9%
distribute-lft-in88.9%
Applied egg-rr88.9%
distribute-lft-out88.9%
*-commutative88.9%
fma-define88.9%
Simplified88.9%
Taylor expanded in phi1 around 0 86.0%
if 0.033000000000000002 < phi1 Initial program 81.3%
+-commutative81.3%
associate-*l*81.3%
fma-define81.3%
Simplified81.3%
fma-undefine81.3%
associate-*r*81.3%
+-commutative81.3%
flip-+81.3%
fmm-def81.2%
associate-*r*81.2%
*-commutative81.2%
Applied egg-rr81.3%
Final simplification85.0%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (cos (- lambda1 lambda2))) (t_1 (* (cos phi1) (cos phi2))))
(if (<= phi1 -1.45e-6)
(* R (acos (+ (* t_1 t_0) (* (sin phi2) (log1p (expm1 (sin phi1)))))))
(if (<= phi1 1.95e-5)
(*
R
(acos
(+
(* phi1 (sin phi2))
(*
(cos phi2)
(fma
(cos lambda2)
(cos lambda1)
(* (sin lambda1) (sin lambda2)))))))
(* R (acos (log (exp (fma t_1 t_0 (* (sin phi1) (sin phi2)))))))))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos((lambda1 - lambda2));
double t_1 = cos(phi1) * cos(phi2);
double tmp;
if (phi1 <= -1.45e-6) {
tmp = R * acos(((t_1 * t_0) + (sin(phi2) * log1p(expm1(sin(phi1))))));
} else if (phi1 <= 1.95e-5) {
tmp = R * acos(((phi1 * sin(phi2)) + (cos(phi2) * fma(cos(lambda2), cos(lambda1), (sin(lambda1) * sin(lambda2))))));
} else {
tmp = R * acos(log(exp(fma(t_1, t_0, (sin(phi1) * sin(phi2))))));
}
return tmp;
}
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) t_0 = cos(Float64(lambda1 - lambda2)) t_1 = Float64(cos(phi1) * cos(phi2)) tmp = 0.0 if (phi1 <= -1.45e-6) tmp = Float64(R * acos(Float64(Float64(t_1 * t_0) + Float64(sin(phi2) * log1p(expm1(sin(phi1))))))); elseif (phi1 <= 1.95e-5) tmp = Float64(R * acos(Float64(Float64(phi1 * sin(phi2)) + Float64(cos(phi2) * fma(cos(lambda2), cos(lambda1), Float64(sin(lambda1) * sin(lambda2))))))); else tmp = Float64(R * acos(log(exp(fma(t_1, t_0, Float64(sin(phi1) * sin(phi2))))))); end return tmp end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[(N[Cos[phi1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[phi1, -1.45e-6], N[(R * N[ArcCos[N[(N[(t$95$1 * t$95$0), $MachinePrecision] + N[(N[Sin[phi2], $MachinePrecision] * N[Log[1 + N[(Exp[N[Sin[phi1], $MachinePrecision]] - 1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 1.95e-5], N[(R * N[ArcCos[N[(N[(phi1 * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] + N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision] + N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[Log[N[Exp[N[(t$95$1 * t$95$0 + N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
t_0 := \cos \left(\lambda_1 - \lambda_2\right)\\
t_1 := \cos \phi_1 \cdot \cos \phi_2\\
\mathbf{if}\;\phi_1 \leq -1.45 \cdot 10^{-6}:\\
\;\;\;\;R \cdot \cos^{-1} \left(t\_1 \cdot t\_0 + \sin \phi_2 \cdot \mathsf{log1p}\left(\mathsf{expm1}\left(\sin \phi_1\right)\right)\right)\\
\mathbf{elif}\;\phi_1 \leq 1.95 \cdot 10^{-5}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\phi_1 \cdot \sin \phi_2 + \cos \phi_2 \cdot \mathsf{fma}\left(\cos \lambda_2, \cos \lambda_1, \sin \lambda_1 \cdot \sin \lambda_2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \log \left(e^{\mathsf{fma}\left(t\_1, t\_0, \sin \phi_1 \cdot \sin \phi_2\right)}\right)\\
\end{array}
\end{array}
if phi1 < -1.4500000000000001e-6Initial program 82.0%
log1p-expm1-u82.0%
Applied egg-rr82.0%
if -1.4500000000000001e-6 < phi1 < 1.95e-5Initial program 64.4%
+-commutative64.4%
associate-*l*64.4%
fma-define64.4%
Simplified64.4%
Taylor expanded in phi1 around 0 64.4%
cos-diff87.8%
distribute-lft-in87.8%
Applied egg-rr87.8%
distribute-lft-out87.8%
cos-neg87.8%
*-commutative87.8%
fma-define87.8%
cos-neg87.8%
Simplified87.8%
if 1.95e-5 < phi1 Initial program 81.3%
+-commutative81.3%
associate-*l*81.3%
fma-define81.3%
Simplified81.3%
fma-undefine81.3%
associate-*r*81.3%
+-commutative81.3%
flip-+81.3%
fmm-def81.2%
associate-*r*81.2%
*-commutative81.2%
Applied egg-rr81.3%
Final simplification84.7%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (* (cos phi1) (cos phi2)) (cos (- lambda1 lambda2)))))
(if (<= phi1 -1.85e-6)
(* R (acos (+ t_0 (* (sin phi2) (log1p (expm1 (sin phi1)))))))
(if (<= phi1 9.4e-6)
(*
R
(acos
(+
(* phi1 (sin phi2))
(*
(cos phi2)
(fma
(cos lambda2)
(cos lambda1)
(* (sin lambda1) (sin lambda2)))))))
(* R (acos (+ t_0 (* (sin phi2) (pow (cbrt (sin phi1)) 3.0)))))))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = (cos(phi1) * cos(phi2)) * cos((lambda1 - lambda2));
double tmp;
if (phi1 <= -1.85e-6) {
tmp = R * acos((t_0 + (sin(phi2) * log1p(expm1(sin(phi1))))));
} else if (phi1 <= 9.4e-6) {
tmp = R * acos(((phi1 * sin(phi2)) + (cos(phi2) * fma(cos(lambda2), cos(lambda1), (sin(lambda1) * sin(lambda2))))));
} else {
tmp = R * acos((t_0 + (sin(phi2) * pow(cbrt(sin(phi1)), 3.0))));
}
return tmp;
}
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) t_0 = Float64(Float64(cos(phi1) * cos(phi2)) * cos(Float64(lambda1 - lambda2))) tmp = 0.0 if (phi1 <= -1.85e-6) tmp = Float64(R * acos(Float64(t_0 + Float64(sin(phi2) * log1p(expm1(sin(phi1))))))); elseif (phi1 <= 9.4e-6) tmp = Float64(R * acos(Float64(Float64(phi1 * sin(phi2)) + Float64(cos(phi2) * fma(cos(lambda2), cos(lambda1), Float64(sin(lambda1) * sin(lambda2))))))); else tmp = Float64(R * acos(Float64(t_0 + Float64(sin(phi2) * (cbrt(sin(phi1)) ^ 3.0))))); end return tmp end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[(N[Cos[phi1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[phi1, -1.85e-6], N[(R * N[ArcCos[N[(t$95$0 + N[(N[Sin[phi2], $MachinePrecision] * N[Log[1 + N[(Exp[N[Sin[phi1], $MachinePrecision]] - 1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 9.4e-6], N[(R * N[ArcCos[N[(N[(phi1 * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] + N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision] + N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(t$95$0 + N[(N[Sin[phi2], $MachinePrecision] * N[Power[N[Power[N[Sin[phi1], $MachinePrecision], 1/3], $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
t_0 := \left(\cos \phi_1 \cdot \cos \phi_2\right) \cdot \cos \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_1 \leq -1.85 \cdot 10^{-6}:\\
\;\;\;\;R \cdot \cos^{-1} \left(t\_0 + \sin \phi_2 \cdot \mathsf{log1p}\left(\mathsf{expm1}\left(\sin \phi_1\right)\right)\right)\\
\mathbf{elif}\;\phi_1 \leq 9.4 \cdot 10^{-6}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\phi_1 \cdot \sin \phi_2 + \cos \phi_2 \cdot \mathsf{fma}\left(\cos \lambda_2, \cos \lambda_1, \sin \lambda_1 \cdot \sin \lambda_2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(t\_0 + \sin \phi_2 \cdot {\left(\sqrt[3]{\sin \phi_1}\right)}^{3}\right)\\
\end{array}
\end{array}
if phi1 < -1.8500000000000001e-6Initial program 82.0%
log1p-expm1-u82.0%
Applied egg-rr82.0%
if -1.8500000000000001e-6 < phi1 < 9.39999999999999979e-6Initial program 64.4%
+-commutative64.4%
associate-*l*64.4%
fma-define64.4%
Simplified64.4%
Taylor expanded in phi1 around 0 64.4%
cos-diff87.8%
distribute-lft-in87.8%
Applied egg-rr87.8%
distribute-lft-out87.8%
cos-neg87.8%
*-commutative87.8%
fma-define87.8%
cos-neg87.8%
Simplified87.8%
if 9.39999999999999979e-6 < phi1 Initial program 81.3%
add-cube-cbrt81.3%
pow381.3%
Applied egg-rr81.3%
Final simplification84.7%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (* (cos phi1) (cos phi2)) (cos (- lambda1 lambda2)))))
(if (<= phi1 -1.2e-6)
(* R (acos (+ t_0 (* (sin phi2) (log1p (expm1 (sin phi1)))))))
(if (<= phi1 6.8e-6)
(*
R
(acos
(+
(* phi1 (sin phi2))
(*
(cos phi2)
(fma
(cos lambda2)
(cos lambda1)
(* (sin lambda1) (sin lambda2)))))))
(* R (acos (+ t_0 (* (sin phi2) (log (exp (sin phi1)))))))))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = (cos(phi1) * cos(phi2)) * cos((lambda1 - lambda2));
double tmp;
if (phi1 <= -1.2e-6) {
tmp = R * acos((t_0 + (sin(phi2) * log1p(expm1(sin(phi1))))));
} else if (phi1 <= 6.8e-6) {
tmp = R * acos(((phi1 * sin(phi2)) + (cos(phi2) * fma(cos(lambda2), cos(lambda1), (sin(lambda1) * sin(lambda2))))));
} else {
tmp = R * acos((t_0 + (sin(phi2) * log(exp(sin(phi1))))));
}
return tmp;
}
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) t_0 = Float64(Float64(cos(phi1) * cos(phi2)) * cos(Float64(lambda1 - lambda2))) tmp = 0.0 if (phi1 <= -1.2e-6) tmp = Float64(R * acos(Float64(t_0 + Float64(sin(phi2) * log1p(expm1(sin(phi1))))))); elseif (phi1 <= 6.8e-6) tmp = Float64(R * acos(Float64(Float64(phi1 * sin(phi2)) + Float64(cos(phi2) * fma(cos(lambda2), cos(lambda1), Float64(sin(lambda1) * sin(lambda2))))))); else tmp = Float64(R * acos(Float64(t_0 + Float64(sin(phi2) * log(exp(sin(phi1))))))); end return tmp end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[(N[Cos[phi1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[phi1, -1.2e-6], N[(R * N[ArcCos[N[(t$95$0 + N[(N[Sin[phi2], $MachinePrecision] * N[Log[1 + N[(Exp[N[Sin[phi1], $MachinePrecision]] - 1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 6.8e-6], N[(R * N[ArcCos[N[(N[(phi1 * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] + N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision] + N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(t$95$0 + N[(N[Sin[phi2], $MachinePrecision] * N[Log[N[Exp[N[Sin[phi1], $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
t_0 := \left(\cos \phi_1 \cdot \cos \phi_2\right) \cdot \cos \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_1 \leq -1.2 \cdot 10^{-6}:\\
\;\;\;\;R \cdot \cos^{-1} \left(t\_0 + \sin \phi_2 \cdot \mathsf{log1p}\left(\mathsf{expm1}\left(\sin \phi_1\right)\right)\right)\\
\mathbf{elif}\;\phi_1 \leq 6.8 \cdot 10^{-6}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\phi_1 \cdot \sin \phi_2 + \cos \phi_2 \cdot \mathsf{fma}\left(\cos \lambda_2, \cos \lambda_1, \sin \lambda_1 \cdot \sin \lambda_2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(t\_0 + \sin \phi_2 \cdot \log \left(e^{\sin \phi_1}\right)\right)\\
\end{array}
\end{array}
if phi1 < -1.1999999999999999e-6Initial program 82.0%
log1p-expm1-u82.0%
Applied egg-rr82.0%
if -1.1999999999999999e-6 < phi1 < 6.80000000000000012e-6Initial program 64.4%
+-commutative64.4%
associate-*l*64.4%
fma-define64.4%
Simplified64.4%
Taylor expanded in phi1 around 0 64.4%
cos-diff87.8%
distribute-lft-in87.8%
Applied egg-rr87.8%
distribute-lft-out87.8%
cos-neg87.8%
*-commutative87.8%
fma-define87.8%
cos-neg87.8%
Simplified87.8%
if 6.80000000000000012e-6 < phi1 Initial program 81.3%
add-log-exp81.3%
Applied egg-rr81.3%
Final simplification84.7%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (cos (- lambda1 lambda2))))
(if (<= phi1 -2.9e-6)
(* R (acos (fma (sin phi1) (sin phi2) (* (cos phi1) (* (cos phi2) t_0)))))
(if (<= phi1 4.5e-6)
(*
R
(acos
(+
(* phi1 (sin phi2))
(*
(cos phi2)
(fma
(cos lambda2)
(cos lambda1)
(* (sin lambda1) (sin lambda2)))))))
(*
R
(acos
(+
(* (* (cos phi1) (cos phi2)) t_0)
(* (sin phi2) (log (exp (sin phi1)))))))))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos((lambda1 - lambda2));
double tmp;
if (phi1 <= -2.9e-6) {
tmp = R * acos(fma(sin(phi1), sin(phi2), (cos(phi1) * (cos(phi2) * t_0))));
} else if (phi1 <= 4.5e-6) {
tmp = R * acos(((phi1 * sin(phi2)) + (cos(phi2) * fma(cos(lambda2), cos(lambda1), (sin(lambda1) * sin(lambda2))))));
} else {
tmp = R * acos((((cos(phi1) * cos(phi2)) * t_0) + (sin(phi2) * log(exp(sin(phi1))))));
}
return tmp;
}
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) t_0 = cos(Float64(lambda1 - lambda2)) tmp = 0.0 if (phi1 <= -2.9e-6) tmp = Float64(R * acos(fma(sin(phi1), sin(phi2), Float64(cos(phi1) * Float64(cos(phi2) * t_0))))); elseif (phi1 <= 4.5e-6) tmp = Float64(R * acos(Float64(Float64(phi1 * sin(phi2)) + Float64(cos(phi2) * fma(cos(lambda2), cos(lambda1), Float64(sin(lambda1) * sin(lambda2))))))); else tmp = Float64(R * acos(Float64(Float64(Float64(cos(phi1) * cos(phi2)) * t_0) + Float64(sin(phi2) * log(exp(sin(phi1))))))); end return tmp end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[phi1, -2.9e-6], N[(R * N[ArcCos[N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision] + N[(N[Cos[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 4.5e-6], N[(R * N[ArcCos[N[(N[(phi1 * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] + N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision] + N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[(N[(N[Cos[phi1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] * t$95$0), $MachinePrecision] + N[(N[Sin[phi2], $MachinePrecision] * N[Log[N[Exp[N[Sin[phi1], $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
t_0 := \cos \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_1 \leq -2.9 \cdot 10^{-6}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\sin \phi_1, \sin \phi_2, \cos \phi_1 \cdot \left(\cos \phi_2 \cdot t\_0\right)\right)\right)\\
\mathbf{elif}\;\phi_1 \leq 4.5 \cdot 10^{-6}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\phi_1 \cdot \sin \phi_2 + \cos \phi_2 \cdot \mathsf{fma}\left(\cos \lambda_2, \cos \lambda_1, \sin \lambda_1 \cdot \sin \lambda_2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\left(\cos \phi_1 \cdot \cos \phi_2\right) \cdot t\_0 + \sin \phi_2 \cdot \log \left(e^{\sin \phi_1}\right)\right)\\
\end{array}
\end{array}
if phi1 < -2.9000000000000002e-6Initial program 82.0%
Simplified82.0%
if -2.9000000000000002e-6 < phi1 < 4.50000000000000011e-6Initial program 64.4%
+-commutative64.4%
associate-*l*64.4%
fma-define64.4%
Simplified64.4%
Taylor expanded in phi1 around 0 64.4%
cos-diff87.8%
distribute-lft-in87.8%
Applied egg-rr87.8%
distribute-lft-out87.8%
cos-neg87.8%
*-commutative87.8%
fma-define87.8%
cos-neg87.8%
Simplified87.8%
if 4.50000000000000011e-6 < phi1 Initial program 81.3%
add-log-exp81.3%
Applied egg-rr81.3%
Final simplification84.7%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi2) (cos (- lambda1 lambda2)))))
(if (<= phi1 -2.2e-6)
(* R (acos (fma (sin phi1) (sin phi2) (* (cos phi1) t_0))))
(if (<= phi1 1.95e-5)
(*
R
(acos
(+
(* phi1 (sin phi2))
(*
(cos phi2)
(fma
(cos lambda2)
(cos lambda1)
(* (sin lambda1) (sin lambda2)))))))
(* R (acos (fma (cos phi1) t_0 (* (sin phi1) (sin phi2)))))))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi2) * cos((lambda1 - lambda2));
double tmp;
if (phi1 <= -2.2e-6) {
tmp = R * acos(fma(sin(phi1), sin(phi2), (cos(phi1) * t_0)));
} else if (phi1 <= 1.95e-5) {
tmp = R * acos(((phi1 * sin(phi2)) + (cos(phi2) * fma(cos(lambda2), cos(lambda1), (sin(lambda1) * sin(lambda2))))));
} else {
tmp = R * acos(fma(cos(phi1), t_0, (sin(phi1) * sin(phi2))));
}
return tmp;
}
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi2) * cos(Float64(lambda1 - lambda2))) tmp = 0.0 if (phi1 <= -2.2e-6) tmp = Float64(R * acos(fma(sin(phi1), sin(phi2), Float64(cos(phi1) * t_0)))); elseif (phi1 <= 1.95e-5) tmp = Float64(R * acos(Float64(Float64(phi1 * sin(phi2)) + Float64(cos(phi2) * fma(cos(lambda2), cos(lambda1), Float64(sin(lambda1) * sin(lambda2))))))); else tmp = Float64(R * acos(fma(cos(phi1), t_0, Float64(sin(phi1) * sin(phi2))))); end return tmp end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi2], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[phi1, -2.2e-6], N[(R * N[ArcCos[N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision] + N[(N[Cos[phi1], $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 1.95e-5], N[(R * N[ArcCos[N[(N[(phi1 * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] + N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision] + N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Cos[phi1], $MachinePrecision] * t$95$0 + N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
t_0 := \cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_1 \leq -2.2 \cdot 10^{-6}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\sin \phi_1, \sin \phi_2, \cos \phi_1 \cdot t\_0\right)\right)\\
\mathbf{elif}\;\phi_1 \leq 1.95 \cdot 10^{-5}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\phi_1 \cdot \sin \phi_2 + \cos \phi_2 \cdot \mathsf{fma}\left(\cos \lambda_2, \cos \lambda_1, \sin \lambda_1 \cdot \sin \lambda_2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\cos \phi_1, t\_0, \sin \phi_1 \cdot \sin \phi_2\right)\right)\\
\end{array}
\end{array}
if phi1 < -2.2000000000000001e-6Initial program 82.0%
Simplified82.0%
if -2.2000000000000001e-6 < phi1 < 1.95e-5Initial program 64.4%
+-commutative64.4%
associate-*l*64.4%
fma-define64.4%
Simplified64.4%
Taylor expanded in phi1 around 0 64.4%
cos-diff87.8%
distribute-lft-in87.8%
Applied egg-rr87.8%
distribute-lft-out87.8%
cos-neg87.8%
*-commutative87.8%
fma-define87.8%
cos-neg87.8%
Simplified87.8%
if 1.95e-5 < phi1 Initial program 81.3%
+-commutative81.3%
associate-*l*81.3%
fma-define81.3%
Simplified81.3%
Final simplification84.7%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi2) (cos (- lambda1 lambda2)))))
(if (<= phi1 -1.6e-6)
(* R (acos (fma (sin phi1) (sin phi2) (* (cos phi1) t_0))))
(if (<= phi1 5.8e-6)
(*
R
(acos
(+
(* phi1 (sin phi2))
(*
(cos phi2)
(+
(* (sin lambda1) (sin lambda2))
(* (cos lambda1) (cos lambda2)))))))
(* R (acos (fma (cos phi1) t_0 (* (sin phi1) (sin phi2)))))))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi2) * cos((lambda1 - lambda2));
double tmp;
if (phi1 <= -1.6e-6) {
tmp = R * acos(fma(sin(phi1), sin(phi2), (cos(phi1) * t_0)));
} else if (phi1 <= 5.8e-6) {
tmp = R * acos(((phi1 * sin(phi2)) + (cos(phi2) * ((sin(lambda1) * sin(lambda2)) + (cos(lambda1) * cos(lambda2))))));
} else {
tmp = R * acos(fma(cos(phi1), t_0, (sin(phi1) * sin(phi2))));
}
return tmp;
}
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi2) * cos(Float64(lambda1 - lambda2))) tmp = 0.0 if (phi1 <= -1.6e-6) tmp = Float64(R * acos(fma(sin(phi1), sin(phi2), Float64(cos(phi1) * t_0)))); elseif (phi1 <= 5.8e-6) tmp = Float64(R * acos(Float64(Float64(phi1 * sin(phi2)) + Float64(cos(phi2) * Float64(Float64(sin(lambda1) * sin(lambda2)) + Float64(cos(lambda1) * cos(lambda2))))))); else tmp = Float64(R * acos(fma(cos(phi1), t_0, Float64(sin(phi1) * sin(phi2))))); end return tmp end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi2], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[phi1, -1.6e-6], N[(R * N[ArcCos[N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision] + N[(N[Cos[phi1], $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 5.8e-6], N[(R * N[ArcCos[N[(N[(phi1 * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] + N[(N[Cos[phi2], $MachinePrecision] * N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision] + N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Cos[phi1], $MachinePrecision] * t$95$0 + N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
t_0 := \cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_1 \leq -1.6 \cdot 10^{-6}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\sin \phi_1, \sin \phi_2, \cos \phi_1 \cdot t\_0\right)\right)\\
\mathbf{elif}\;\phi_1 \leq 5.8 \cdot 10^{-6}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\phi_1 \cdot \sin \phi_2 + \cos \phi_2 \cdot \left(\sin \lambda_1 \cdot \sin \lambda_2 + \cos \lambda_1 \cdot \cos \lambda_2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\cos \phi_1, t\_0, \sin \phi_1 \cdot \sin \phi_2\right)\right)\\
\end{array}
\end{array}
if phi1 < -1.5999999999999999e-6Initial program 82.0%
Simplified82.0%
if -1.5999999999999999e-6 < phi1 < 5.8000000000000004e-6Initial program 64.4%
+-commutative64.4%
associate-*l*64.4%
fma-define64.4%
Simplified64.4%
Taylor expanded in phi1 around 0 64.4%
cos-diff87.9%
+-commutative87.9%
Applied egg-rr87.8%
if 5.8000000000000004e-6 < phi1 Initial program 81.3%
+-commutative81.3%
associate-*l*81.3%
fma-define81.3%
Simplified81.3%
Final simplification84.7%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi2) (cos (- lambda1 lambda2)))))
(if (<= phi1 -1.15e-6)
(* R (acos (fma (sin phi1) (sin phi2) (* (cos phi1) t_0))))
(if (<= phi1 5.3e-6)
(*
R
(acos
(*
(cos phi2)
(fma (cos lambda2) (cos lambda1) (* (sin lambda1) (sin lambda2))))))
(* R (acos (fma (cos phi1) t_0 (* (sin phi1) (sin phi2)))))))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi2) * cos((lambda1 - lambda2));
double tmp;
if (phi1 <= -1.15e-6) {
tmp = R * acos(fma(sin(phi1), sin(phi2), (cos(phi1) * t_0)));
} else if (phi1 <= 5.3e-6) {
tmp = R * acos((cos(phi2) * fma(cos(lambda2), cos(lambda1), (sin(lambda1) * sin(lambda2)))));
} else {
tmp = R * acos(fma(cos(phi1), t_0, (sin(phi1) * sin(phi2))));
}
return tmp;
}
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi2) * cos(Float64(lambda1 - lambda2))) tmp = 0.0 if (phi1 <= -1.15e-6) tmp = Float64(R * acos(fma(sin(phi1), sin(phi2), Float64(cos(phi1) * t_0)))); elseif (phi1 <= 5.3e-6) tmp = Float64(R * acos(Float64(cos(phi2) * fma(cos(lambda2), cos(lambda1), Float64(sin(lambda1) * sin(lambda2)))))); else tmp = Float64(R * acos(fma(cos(phi1), t_0, Float64(sin(phi1) * sin(phi2))))); end return tmp end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi2], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[phi1, -1.15e-6], N[(R * N[ArcCos[N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision] + N[(N[Cos[phi1], $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 5.3e-6], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision] + N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Cos[phi1], $MachinePrecision] * t$95$0 + N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
t_0 := \cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_1 \leq -1.15 \cdot 10^{-6}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\sin \phi_1, \sin \phi_2, \cos \phi_1 \cdot t\_0\right)\right)\\
\mathbf{elif}\;\phi_1 \leq 5.3 \cdot 10^{-6}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_2 \cdot \mathsf{fma}\left(\cos \lambda_2, \cos \lambda_1, \sin \lambda_1 \cdot \sin \lambda_2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\cos \phi_1, t\_0, \sin \phi_1 \cdot \sin \phi_2\right)\right)\\
\end{array}
\end{array}
if phi1 < -1.15e-6Initial program 82.0%
Simplified82.0%
if -1.15e-6 < phi1 < 5.3000000000000001e-6Initial program 64.4%
cos-diff87.9%
distribute-lft-in87.9%
Applied egg-rr87.9%
distribute-lft-out87.9%
*-commutative87.9%
fma-define88.0%
Simplified88.0%
add-cbrt-cube88.0%
pow388.0%
Applied egg-rr88.0%
Taylor expanded in phi1 around 0 87.9%
+-commutative87.9%
*-commutative87.9%
fma-define87.9%
*-commutative87.9%
*-commutative87.9%
associate-*l*87.9%
fma-define88.0%
*-commutative88.0%
Simplified88.0%
Taylor expanded in phi1 around 0 87.2%
cos-neg87.2%
*-commutative87.2%
fma-define87.2%
cos-neg87.2%
Simplified87.2%
if 5.3000000000000001e-6 < phi1 Initial program 81.3%
+-commutative81.3%
associate-*l*81.3%
fma-define81.3%
Simplified81.3%
Final simplification84.4%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (cos (- lambda1 lambda2))) (t_1 (* (sin phi1) (sin phi2))))
(if (<= phi1 -1.15e-6)
(* R (acos (+ t_1 (* (* (cos phi1) (cos phi2)) t_0))))
(if (<= phi1 4.2e-6)
(*
R
(acos
(*
(cos phi2)
(fma (cos lambda2) (cos lambda1) (* (sin lambda1) (sin lambda2))))))
(* R (acos (fma (cos phi1) (* (cos phi2) t_0) t_1)))))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos((lambda1 - lambda2));
double t_1 = sin(phi1) * sin(phi2);
double tmp;
if (phi1 <= -1.15e-6) {
tmp = R * acos((t_1 + ((cos(phi1) * cos(phi2)) * t_0)));
} else if (phi1 <= 4.2e-6) {
tmp = R * acos((cos(phi2) * fma(cos(lambda2), cos(lambda1), (sin(lambda1) * sin(lambda2)))));
} else {
tmp = R * acos(fma(cos(phi1), (cos(phi2) * t_0), t_1));
}
return tmp;
}
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) t_0 = cos(Float64(lambda1 - lambda2)) t_1 = Float64(sin(phi1) * sin(phi2)) tmp = 0.0 if (phi1 <= -1.15e-6) tmp = Float64(R * acos(Float64(t_1 + Float64(Float64(cos(phi1) * cos(phi2)) * t_0)))); elseif (phi1 <= 4.2e-6) tmp = Float64(R * acos(Float64(cos(phi2) * fma(cos(lambda2), cos(lambda1), Float64(sin(lambda1) * sin(lambda2)))))); else tmp = Float64(R * acos(fma(cos(phi1), Float64(cos(phi2) * t_0), t_1))); end return tmp end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[phi1, -1.15e-6], N[(R * N[ArcCos[N[(t$95$1 + N[(N[(N[Cos[phi1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 4.2e-6], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision] + N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Cos[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * t$95$0), $MachinePrecision] + t$95$1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
t_0 := \cos \left(\lambda_1 - \lambda_2\right)\\
t_1 := \sin \phi_1 \cdot \sin \phi_2\\
\mathbf{if}\;\phi_1 \leq -1.15 \cdot 10^{-6}:\\
\;\;\;\;R \cdot \cos^{-1} \left(t\_1 + \left(\cos \phi_1 \cdot \cos \phi_2\right) \cdot t\_0\right)\\
\mathbf{elif}\;\phi_1 \leq 4.2 \cdot 10^{-6}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_2 \cdot \mathsf{fma}\left(\cos \lambda_2, \cos \lambda_1, \sin \lambda_1 \cdot \sin \lambda_2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\cos \phi_1, \cos \phi_2 \cdot t\_0, t\_1\right)\right)\\
\end{array}
\end{array}
if phi1 < -1.15e-6Initial program 82.0%
if -1.15e-6 < phi1 < 4.1999999999999996e-6Initial program 64.4%
cos-diff87.9%
distribute-lft-in87.9%
Applied egg-rr87.9%
distribute-lft-out87.9%
*-commutative87.9%
fma-define88.0%
Simplified88.0%
add-cbrt-cube88.0%
pow388.0%
Applied egg-rr88.0%
Taylor expanded in phi1 around 0 87.9%
+-commutative87.9%
*-commutative87.9%
fma-define87.9%
*-commutative87.9%
*-commutative87.9%
associate-*l*87.9%
fma-define88.0%
*-commutative88.0%
Simplified88.0%
Taylor expanded in phi1 around 0 87.2%
cos-neg87.2%
*-commutative87.2%
fma-define87.2%
cos-neg87.2%
Simplified87.2%
if 4.1999999999999996e-6 < phi1 Initial program 81.3%
+-commutative81.3%
associate-*l*81.3%
fma-define81.3%
Simplified81.3%
Final simplification84.4%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (or (<= phi1 -1.15e-6) (not (<= phi1 4.8e-6)))
(*
R
(acos
(+
(* (sin phi1) (sin phi2))
(* (* (cos phi1) (cos phi2)) (cos (- lambda1 lambda2))))))
(*
R
(acos
(*
(cos phi2)
(fma (cos lambda2) (cos lambda1) (* (sin lambda1) (sin lambda2))))))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if ((phi1 <= -1.15e-6) || !(phi1 <= 4.8e-6)) {
tmp = R * acos(((sin(phi1) * sin(phi2)) + ((cos(phi1) * cos(phi2)) * cos((lambda1 - lambda2)))));
} else {
tmp = R * acos((cos(phi2) * fma(cos(lambda2), cos(lambda1), (sin(lambda1) * sin(lambda2)))));
}
return tmp;
}
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if ((phi1 <= -1.15e-6) || !(phi1 <= 4.8e-6)) tmp = Float64(R * acos(Float64(Float64(sin(phi1) * sin(phi2)) + Float64(Float64(cos(phi1) * cos(phi2)) * cos(Float64(lambda1 - lambda2)))))); else tmp = Float64(R * acos(Float64(cos(phi2) * fma(cos(lambda2), cos(lambda1), Float64(sin(lambda1) * sin(lambda2)))))); end return tmp end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[Or[LessEqual[phi1, -1.15e-6], N[Not[LessEqual[phi1, 4.8e-6]], $MachinePrecision]], N[(R * N[ArcCos[N[(N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] + N[(N[(N[Cos[phi1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision] + N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -1.15 \cdot 10^{-6} \lor \neg \left(\phi_1 \leq 4.8 \cdot 10^{-6}\right):\\
\;\;\;\;R \cdot \cos^{-1} \left(\sin \phi_1 \cdot \sin \phi_2 + \left(\cos \phi_1 \cdot \cos \phi_2\right) \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_2 \cdot \mathsf{fma}\left(\cos \lambda_2, \cos \lambda_1, \sin \lambda_1 \cdot \sin \lambda_2\right)\right)\\
\end{array}
\end{array}
if phi1 < -1.15e-6 or 4.7999999999999998e-6 < phi1 Initial program 81.7%
if -1.15e-6 < phi1 < 4.7999999999999998e-6Initial program 64.4%
cos-diff87.9%
distribute-lft-in87.9%
Applied egg-rr87.9%
distribute-lft-out87.9%
*-commutative87.9%
fma-define88.0%
Simplified88.0%
add-cbrt-cube88.0%
pow388.0%
Applied egg-rr88.0%
Taylor expanded in phi1 around 0 87.9%
+-commutative87.9%
*-commutative87.9%
fma-define87.9%
*-commutative87.9%
*-commutative87.9%
associate-*l*87.9%
fma-define88.0%
*-commutative88.0%
Simplified88.0%
Taylor expanded in phi1 around 0 87.2%
cos-neg87.2%
*-commutative87.2%
fma-define87.2%
cos-neg87.2%
Simplified87.2%
Final simplification84.4%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0 (* (cos phi1) (cos phi2)))
(t_1
(+ (* (sin lambda1) (sin lambda2)) (* (cos lambda1) (cos lambda2))))
(t_2 (* (sin phi1) (sin phi2))))
(if (<= phi1 -3.5e+211)
(* R (acos (+ t_2 (* t_0 (cos lambda1)))))
(if (<= phi1 -1.16e+64)
(* R (acos (+ t_2 (* t_0 (cos lambda2)))))
(if (<= phi1 -8.2e-7)
(* R (acos (* (cos phi1) t_1)))
(if (<= phi1 4.9e-5)
(* R (acos (* (cos phi2) t_1)))
(*
R
(acos (+ t_2 (* (cos phi1) (* (cos phi2) (cos lambda2))))))))))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = cos(phi1) * cos(phi2);
double t_1 = (sin(lambda1) * sin(lambda2)) + (cos(lambda1) * cos(lambda2));
double t_2 = sin(phi1) * sin(phi2);
double tmp;
if (phi1 <= -3.5e+211) {
tmp = R * acos((t_2 + (t_0 * cos(lambda1))));
} else if (phi1 <= -1.16e+64) {
tmp = R * acos((t_2 + (t_0 * cos(lambda2))));
} else if (phi1 <= -8.2e-7) {
tmp = R * acos((cos(phi1) * t_1));
} else if (phi1 <= 4.9e-5) {
tmp = R * acos((cos(phi2) * t_1));
} else {
tmp = R * acos((t_2 + (cos(phi1) * (cos(phi2) * cos(lambda2)))));
}
return tmp;
}
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = cos(phi1) * cos(phi2)
t_1 = (sin(lambda1) * sin(lambda2)) + (cos(lambda1) * cos(lambda2))
t_2 = sin(phi1) * sin(phi2)
if (phi1 <= (-3.5d+211)) then
tmp = r * acos((t_2 + (t_0 * cos(lambda1))))
else if (phi1 <= (-1.16d+64)) then
tmp = r * acos((t_2 + (t_0 * cos(lambda2))))
else if (phi1 <= (-8.2d-7)) then
tmp = r * acos((cos(phi1) * t_1))
else if (phi1 <= 4.9d-5) then
tmp = r * acos((cos(phi2) * t_1))
else
tmp = r * acos((t_2 + (cos(phi1) * (cos(phi2) * cos(lambda2)))))
end if
code = tmp
end function
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = Math.cos(phi1) * Math.cos(phi2);
double t_1 = (Math.sin(lambda1) * Math.sin(lambda2)) + (Math.cos(lambda1) * Math.cos(lambda2));
double t_2 = Math.sin(phi1) * Math.sin(phi2);
double tmp;
if (phi1 <= -3.5e+211) {
tmp = R * Math.acos((t_2 + (t_0 * Math.cos(lambda1))));
} else if (phi1 <= -1.16e+64) {
tmp = R * Math.acos((t_2 + (t_0 * Math.cos(lambda2))));
} else if (phi1 <= -8.2e-7) {
tmp = R * Math.acos((Math.cos(phi1) * t_1));
} else if (phi1 <= 4.9e-5) {
tmp = R * Math.acos((Math.cos(phi2) * t_1));
} else {
tmp = R * Math.acos((t_2 + (Math.cos(phi1) * (Math.cos(phi2) * Math.cos(lambda2)))));
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) [R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): t_0 = math.cos(phi1) * math.cos(phi2) t_1 = (math.sin(lambda1) * math.sin(lambda2)) + (math.cos(lambda1) * math.cos(lambda2)) t_2 = math.sin(phi1) * math.sin(phi2) tmp = 0 if phi1 <= -3.5e+211: tmp = R * math.acos((t_2 + (t_0 * math.cos(lambda1)))) elif phi1 <= -1.16e+64: tmp = R * math.acos((t_2 + (t_0 * math.cos(lambda2)))) elif phi1 <= -8.2e-7: tmp = R * math.acos((math.cos(phi1) * t_1)) elif phi1 <= 4.9e-5: tmp = R * math.acos((math.cos(phi2) * t_1)) else: tmp = R * math.acos((t_2 + (math.cos(phi1) * (math.cos(phi2) * math.cos(lambda2))))) return tmp
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) t_0 = Float64(cos(phi1) * cos(phi2)) t_1 = Float64(Float64(sin(lambda1) * sin(lambda2)) + Float64(cos(lambda1) * cos(lambda2))) t_2 = Float64(sin(phi1) * sin(phi2)) tmp = 0.0 if (phi1 <= -3.5e+211) tmp = Float64(R * acos(Float64(t_2 + Float64(t_0 * cos(lambda1))))); elseif (phi1 <= -1.16e+64) tmp = Float64(R * acos(Float64(t_2 + Float64(t_0 * cos(lambda2))))); elseif (phi1 <= -8.2e-7) tmp = Float64(R * acos(Float64(cos(phi1) * t_1))); elseif (phi1 <= 4.9e-5) tmp = Float64(R * acos(Float64(cos(phi2) * t_1))); else tmp = Float64(R * acos(Float64(t_2 + Float64(cos(phi1) * Float64(cos(phi2) * cos(lambda2)))))); end return tmp end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2)
t_0 = cos(phi1) * cos(phi2);
t_1 = (sin(lambda1) * sin(lambda2)) + (cos(lambda1) * cos(lambda2));
t_2 = sin(phi1) * sin(phi2);
tmp = 0.0;
if (phi1 <= -3.5e+211)
tmp = R * acos((t_2 + (t_0 * cos(lambda1))));
elseif (phi1 <= -1.16e+64)
tmp = R * acos((t_2 + (t_0 * cos(lambda2))));
elseif (phi1 <= -8.2e-7)
tmp = R * acos((cos(phi1) * t_1));
elseif (phi1 <= 4.9e-5)
tmp = R * acos((cos(phi2) * t_1));
else
tmp = R * acos((t_2 + (cos(phi1) * (cos(phi2) * cos(lambda2)))));
end
tmp_2 = tmp;
end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[Cos[phi1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision] + N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[phi1, -3.5e+211], N[(R * N[ArcCos[N[(t$95$2 + N[(t$95$0 * N[Cos[lambda1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, -1.16e+64], N[(R * N[ArcCos[N[(t$95$2 + N[(t$95$0 * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, -8.2e-7], N[(R * N[ArcCos[N[(N[Cos[phi1], $MachinePrecision] * t$95$1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 4.9e-5], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * t$95$1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(t$95$2 + N[(N[Cos[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
t_0 := \cos \phi_1 \cdot \cos \phi_2\\
t_1 := \sin \lambda_1 \cdot \sin \lambda_2 + \cos \lambda_1 \cdot \cos \lambda_2\\
t_2 := \sin \phi_1 \cdot \sin \phi_2\\
\mathbf{if}\;\phi_1 \leq -3.5 \cdot 10^{+211}:\\
\;\;\;\;R \cdot \cos^{-1} \left(t\_2 + t\_0 \cdot \cos \lambda_1\right)\\
\mathbf{elif}\;\phi_1 \leq -1.16 \cdot 10^{+64}:\\
\;\;\;\;R \cdot \cos^{-1} \left(t\_2 + t\_0 \cdot \cos \lambda_2\right)\\
\mathbf{elif}\;\phi_1 \leq -8.2 \cdot 10^{-7}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_1 \cdot t\_1\right)\\
\mathbf{elif}\;\phi_1 \leq 4.9 \cdot 10^{-5}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_2 \cdot t\_1\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(t\_2 + \cos \phi_1 \cdot \left(\cos \phi_2 \cdot \cos \lambda_2\right)\right)\\
\end{array}
\end{array}
if phi1 < -3.49999999999999996e211Initial program 86.2%
Taylor expanded in lambda2 around 0 70.3%
if -3.49999999999999996e211 < phi1 < -1.16e64Initial program 85.5%
Taylor expanded in lambda1 around 0 57.5%
cos-neg57.5%
Simplified57.5%
if -1.16e64 < phi1 < -8.1999999999999998e-7Initial program 71.0%
cos-diff99.2%
distribute-lft-in99.1%
Applied egg-rr99.1%
distribute-lft-out99.2%
*-commutative99.2%
fma-define99.2%
Simplified99.2%
add-cbrt-cube99.1%
pow399.1%
Applied egg-rr99.1%
Taylor expanded in phi1 around 0 99.2%
+-commutative99.2%
*-commutative99.2%
fma-define99.2%
*-commutative99.2%
*-commutative99.2%
associate-*l*99.2%
fma-define99.2%
*-commutative99.2%
Simplified99.2%
Taylor expanded in phi2 around 0 66.1%
if -8.1999999999999998e-7 < phi1 < 4.9e-5Initial program 64.4%
cos-diff87.9%
distribute-lft-in87.9%
Applied egg-rr87.9%
distribute-lft-out87.9%
*-commutative87.9%
fma-define88.0%
Simplified88.0%
add-cbrt-cube88.0%
pow388.0%
Applied egg-rr88.0%
Taylor expanded in phi1 around 0 87.9%
+-commutative87.9%
*-commutative87.9%
fma-define87.9%
*-commutative87.9%
*-commutative87.9%
associate-*l*87.9%
fma-define88.0%
*-commutative88.0%
Simplified88.0%
Taylor expanded in phi1 around 0 87.2%
if 4.9e-5 < phi1 Initial program 81.3%
Taylor expanded in lambda1 around 0 59.3%
cos-neg59.3%
Simplified59.3%
Final simplification74.3%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0
(+ (* (sin lambda1) (sin lambda2)) (* (cos lambda1) (cos lambda2))))
(t_1 (* (sin phi1) (sin phi2)))
(t_2 (* R (acos (+ t_1 (* (cos phi1) (* (cos phi2) (cos lambda2))))))))
(if (<= phi1 -1.65e+214)
(* R (acos (+ t_1 (* (* (cos phi1) (cos phi2)) (cos lambda1)))))
(if (<= phi1 -2.7e+65)
t_2
(if (<= phi1 -1.1e-6)
(* R (acos (* (cos phi1) t_0)))
(if (<= phi1 3.1e-5) (* R (acos (* (cos phi2) t_0))) t_2))))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = (sin(lambda1) * sin(lambda2)) + (cos(lambda1) * cos(lambda2));
double t_1 = sin(phi1) * sin(phi2);
double t_2 = R * acos((t_1 + (cos(phi1) * (cos(phi2) * cos(lambda2)))));
double tmp;
if (phi1 <= -1.65e+214) {
tmp = R * acos((t_1 + ((cos(phi1) * cos(phi2)) * cos(lambda1))));
} else if (phi1 <= -2.7e+65) {
tmp = t_2;
} else if (phi1 <= -1.1e-6) {
tmp = R * acos((cos(phi1) * t_0));
} else if (phi1 <= 3.1e-5) {
tmp = R * acos((cos(phi2) * t_0));
} else {
tmp = t_2;
}
return tmp;
}
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = (sin(lambda1) * sin(lambda2)) + (cos(lambda1) * cos(lambda2))
t_1 = sin(phi1) * sin(phi2)
t_2 = r * acos((t_1 + (cos(phi1) * (cos(phi2) * cos(lambda2)))))
if (phi1 <= (-1.65d+214)) then
tmp = r * acos((t_1 + ((cos(phi1) * cos(phi2)) * cos(lambda1))))
else if (phi1 <= (-2.7d+65)) then
tmp = t_2
else if (phi1 <= (-1.1d-6)) then
tmp = r * acos((cos(phi1) * t_0))
else if (phi1 <= 3.1d-5) then
tmp = r * acos((cos(phi2) * t_0))
else
tmp = t_2
end if
code = tmp
end function
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = (Math.sin(lambda1) * Math.sin(lambda2)) + (Math.cos(lambda1) * Math.cos(lambda2));
double t_1 = Math.sin(phi1) * Math.sin(phi2);
double t_2 = R * Math.acos((t_1 + (Math.cos(phi1) * (Math.cos(phi2) * Math.cos(lambda2)))));
double tmp;
if (phi1 <= -1.65e+214) {
tmp = R * Math.acos((t_1 + ((Math.cos(phi1) * Math.cos(phi2)) * Math.cos(lambda1))));
} else if (phi1 <= -2.7e+65) {
tmp = t_2;
} else if (phi1 <= -1.1e-6) {
tmp = R * Math.acos((Math.cos(phi1) * t_0));
} else if (phi1 <= 3.1e-5) {
tmp = R * Math.acos((Math.cos(phi2) * t_0));
} else {
tmp = t_2;
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) [R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): t_0 = (math.sin(lambda1) * math.sin(lambda2)) + (math.cos(lambda1) * math.cos(lambda2)) t_1 = math.sin(phi1) * math.sin(phi2) t_2 = R * math.acos((t_1 + (math.cos(phi1) * (math.cos(phi2) * math.cos(lambda2))))) tmp = 0 if phi1 <= -1.65e+214: tmp = R * math.acos((t_1 + ((math.cos(phi1) * math.cos(phi2)) * math.cos(lambda1)))) elif phi1 <= -2.7e+65: tmp = t_2 elif phi1 <= -1.1e-6: tmp = R * math.acos((math.cos(phi1) * t_0)) elif phi1 <= 3.1e-5: tmp = R * math.acos((math.cos(phi2) * t_0)) else: tmp = t_2 return tmp
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) t_0 = Float64(Float64(sin(lambda1) * sin(lambda2)) + Float64(cos(lambda1) * cos(lambda2))) t_1 = Float64(sin(phi1) * sin(phi2)) t_2 = Float64(R * acos(Float64(t_1 + Float64(cos(phi1) * Float64(cos(phi2) * cos(lambda2)))))) tmp = 0.0 if (phi1 <= -1.65e+214) tmp = Float64(R * acos(Float64(t_1 + Float64(Float64(cos(phi1) * cos(phi2)) * cos(lambda1))))); elseif (phi1 <= -2.7e+65) tmp = t_2; elseif (phi1 <= -1.1e-6) tmp = Float64(R * acos(Float64(cos(phi1) * t_0))); elseif (phi1 <= 3.1e-5) tmp = Float64(R * acos(Float64(cos(phi2) * t_0))); else tmp = t_2; end return tmp end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2)
t_0 = (sin(lambda1) * sin(lambda2)) + (cos(lambda1) * cos(lambda2));
t_1 = sin(phi1) * sin(phi2);
t_2 = R * acos((t_1 + (cos(phi1) * (cos(phi2) * cos(lambda2)))));
tmp = 0.0;
if (phi1 <= -1.65e+214)
tmp = R * acos((t_1 + ((cos(phi1) * cos(phi2)) * cos(lambda1))));
elseif (phi1 <= -2.7e+65)
tmp = t_2;
elseif (phi1 <= -1.1e-6)
tmp = R * acos((cos(phi1) * t_0));
elseif (phi1 <= 3.1e-5)
tmp = R * acos((cos(phi2) * t_0));
else
tmp = t_2;
end
tmp_2 = tmp;
end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision] + N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(R * N[ArcCos[N[(t$95$1 + N[(N[Cos[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[phi1, -1.65e+214], N[(R * N[ArcCos[N[(t$95$1 + N[(N[(N[Cos[phi1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] * N[Cos[lambda1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, -2.7e+65], t$95$2, If[LessEqual[phi1, -1.1e-6], N[(R * N[ArcCos[N[(N[Cos[phi1], $MachinePrecision] * t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 3.1e-5], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
t_0 := \sin \lambda_1 \cdot \sin \lambda_2 + \cos \lambda_1 \cdot \cos \lambda_2\\
t_1 := \sin \phi_1 \cdot \sin \phi_2\\
t_2 := R \cdot \cos^{-1} \left(t\_1 + \cos \phi_1 \cdot \left(\cos \phi_2 \cdot \cos \lambda_2\right)\right)\\
\mathbf{if}\;\phi_1 \leq -1.65 \cdot 10^{+214}:\\
\;\;\;\;R \cdot \cos^{-1} \left(t\_1 + \left(\cos \phi_1 \cdot \cos \phi_2\right) \cdot \cos \lambda_1\right)\\
\mathbf{elif}\;\phi_1 \leq -2.7 \cdot 10^{+65}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;\phi_1 \leq -1.1 \cdot 10^{-6}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_1 \cdot t\_0\right)\\
\mathbf{elif}\;\phi_1 \leq 3.1 \cdot 10^{-5}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_2 \cdot t\_0\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if phi1 < -1.65000000000000006e214Initial program 86.2%
Taylor expanded in lambda2 around 0 70.3%
if -1.65000000000000006e214 < phi1 < -2.70000000000000019e65 or 3.10000000000000014e-5 < phi1 Initial program 82.8%
Taylor expanded in lambda1 around 0 58.6%
cos-neg58.6%
Simplified58.6%
if -2.70000000000000019e65 < phi1 < -1.1000000000000001e-6Initial program 71.0%
cos-diff99.2%
distribute-lft-in99.1%
Applied egg-rr99.1%
distribute-lft-out99.2%
*-commutative99.2%
fma-define99.2%
Simplified99.2%
add-cbrt-cube99.1%
pow399.1%
Applied egg-rr99.1%
Taylor expanded in phi1 around 0 99.2%
+-commutative99.2%
*-commutative99.2%
fma-define99.2%
*-commutative99.2%
*-commutative99.2%
associate-*l*99.2%
fma-define99.2%
*-commutative99.2%
Simplified99.2%
Taylor expanded in phi2 around 0 66.1%
if -1.1000000000000001e-6 < phi1 < 3.10000000000000014e-5Initial program 64.4%
cos-diff87.9%
distribute-lft-in87.9%
Applied egg-rr87.9%
distribute-lft-out87.9%
*-commutative87.9%
fma-define88.0%
Simplified88.0%
add-cbrt-cube88.0%
pow388.0%
Applied egg-rr88.0%
Taylor expanded in phi1 around 0 87.9%
+-commutative87.9%
*-commutative87.9%
fma-define87.9%
*-commutative87.9%
*-commutative87.9%
associate-*l*87.9%
fma-define88.0%
*-commutative88.0%
Simplified88.0%
Taylor expanded in phi1 around 0 87.2%
Final simplification74.3%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0
(*
R
(acos
(+
(* (sin phi1) (sin phi2))
(* (cos phi1) (* (cos phi2) (cos lambda2)))))))
(t_1
(+ (* (sin lambda1) (sin lambda2)) (* (cos lambda1) (cos lambda2))))
(t_2 (* R (acos (* (cos phi1) t_1)))))
(if (<= phi1 -8e+153)
t_2
(if (<= phi1 -1.55e+65)
t_0
(if (<= phi1 -1.1e-6)
t_2
(if (<= phi1 4.1e-5) (* R (acos (* (cos phi2) t_1))) t_0))))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = R * acos(((sin(phi1) * sin(phi2)) + (cos(phi1) * (cos(phi2) * cos(lambda2)))));
double t_1 = (sin(lambda1) * sin(lambda2)) + (cos(lambda1) * cos(lambda2));
double t_2 = R * acos((cos(phi1) * t_1));
double tmp;
if (phi1 <= -8e+153) {
tmp = t_2;
} else if (phi1 <= -1.55e+65) {
tmp = t_0;
} else if (phi1 <= -1.1e-6) {
tmp = t_2;
} else if (phi1 <= 4.1e-5) {
tmp = R * acos((cos(phi2) * t_1));
} else {
tmp = t_0;
}
return tmp;
}
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = r * acos(((sin(phi1) * sin(phi2)) + (cos(phi1) * (cos(phi2) * cos(lambda2)))))
t_1 = (sin(lambda1) * sin(lambda2)) + (cos(lambda1) * cos(lambda2))
t_2 = r * acos((cos(phi1) * t_1))
if (phi1 <= (-8d+153)) then
tmp = t_2
else if (phi1 <= (-1.55d+65)) then
tmp = t_0
else if (phi1 <= (-1.1d-6)) then
tmp = t_2
else if (phi1 <= 4.1d-5) then
tmp = r * acos((cos(phi2) * t_1))
else
tmp = t_0
end if
code = tmp
end function
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = R * Math.acos(((Math.sin(phi1) * Math.sin(phi2)) + (Math.cos(phi1) * (Math.cos(phi2) * Math.cos(lambda2)))));
double t_1 = (Math.sin(lambda1) * Math.sin(lambda2)) + (Math.cos(lambda1) * Math.cos(lambda2));
double t_2 = R * Math.acos((Math.cos(phi1) * t_1));
double tmp;
if (phi1 <= -8e+153) {
tmp = t_2;
} else if (phi1 <= -1.55e+65) {
tmp = t_0;
} else if (phi1 <= -1.1e-6) {
tmp = t_2;
} else if (phi1 <= 4.1e-5) {
tmp = R * Math.acos((Math.cos(phi2) * t_1));
} else {
tmp = t_0;
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) [R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): t_0 = R * math.acos(((math.sin(phi1) * math.sin(phi2)) + (math.cos(phi1) * (math.cos(phi2) * math.cos(lambda2))))) t_1 = (math.sin(lambda1) * math.sin(lambda2)) + (math.cos(lambda1) * math.cos(lambda2)) t_2 = R * math.acos((math.cos(phi1) * t_1)) tmp = 0 if phi1 <= -8e+153: tmp = t_2 elif phi1 <= -1.55e+65: tmp = t_0 elif phi1 <= -1.1e-6: tmp = t_2 elif phi1 <= 4.1e-5: tmp = R * math.acos((math.cos(phi2) * t_1)) else: tmp = t_0 return tmp
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) t_0 = Float64(R * acos(Float64(Float64(sin(phi1) * sin(phi2)) + Float64(cos(phi1) * Float64(cos(phi2) * cos(lambda2)))))) t_1 = Float64(Float64(sin(lambda1) * sin(lambda2)) + Float64(cos(lambda1) * cos(lambda2))) t_2 = Float64(R * acos(Float64(cos(phi1) * t_1))) tmp = 0.0 if (phi1 <= -8e+153) tmp = t_2; elseif (phi1 <= -1.55e+65) tmp = t_0; elseif (phi1 <= -1.1e-6) tmp = t_2; elseif (phi1 <= 4.1e-5) tmp = Float64(R * acos(Float64(cos(phi2) * t_1))); else tmp = t_0; end return tmp end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2)
t_0 = R * acos(((sin(phi1) * sin(phi2)) + (cos(phi1) * (cos(phi2) * cos(lambda2)))));
t_1 = (sin(lambda1) * sin(lambda2)) + (cos(lambda1) * cos(lambda2));
t_2 = R * acos((cos(phi1) * t_1));
tmp = 0.0;
if (phi1 <= -8e+153)
tmp = t_2;
elseif (phi1 <= -1.55e+65)
tmp = t_0;
elseif (phi1 <= -1.1e-6)
tmp = t_2;
elseif (phi1 <= 4.1e-5)
tmp = R * acos((cos(phi2) * t_1));
else
tmp = t_0;
end
tmp_2 = tmp;
end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(R * N[ArcCos[N[(N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] + N[(N[Cos[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision] + N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(R * N[ArcCos[N[(N[Cos[phi1], $MachinePrecision] * t$95$1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[phi1, -8e+153], t$95$2, If[LessEqual[phi1, -1.55e+65], t$95$0, If[LessEqual[phi1, -1.1e-6], t$95$2, If[LessEqual[phi1, 4.1e-5], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * t$95$1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], t$95$0]]]]]]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
t_0 := R \cdot \cos^{-1} \left(\sin \phi_1 \cdot \sin \phi_2 + \cos \phi_1 \cdot \left(\cos \phi_2 \cdot \cos \lambda_2\right)\right)\\
t_1 := \sin \lambda_1 \cdot \sin \lambda_2 + \cos \lambda_1 \cdot \cos \lambda_2\\
t_2 := R \cdot \cos^{-1} \left(\cos \phi_1 \cdot t\_1\right)\\
\mathbf{if}\;\phi_1 \leq -8 \cdot 10^{+153}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;\phi_1 \leq -1.55 \cdot 10^{+65}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;\phi_1 \leq -1.1 \cdot 10^{-6}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;\phi_1 \leq 4.1 \cdot 10^{-5}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_2 \cdot t\_1\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if phi1 < -8e153 or -1.54999999999999995e65 < phi1 < -1.1000000000000001e-6Initial program 80.4%
cos-diff99.0%
distribute-lft-in99.0%
Applied egg-rr99.0%
distribute-lft-out99.0%
*-commutative99.0%
fma-define99.0%
Simplified99.0%
add-cbrt-cube99.0%
pow399.0%
Applied egg-rr99.0%
Taylor expanded in phi1 around 0 99.0%
+-commutative99.0%
*-commutative99.0%
fma-define99.1%
*-commutative99.1%
*-commutative99.1%
associate-*l*99.1%
fma-define99.1%
*-commutative99.1%
Simplified99.1%
Taylor expanded in phi2 around 0 60.4%
if -8e153 < phi1 < -1.54999999999999995e65 or 4.10000000000000005e-5 < phi1 Initial program 82.7%
Taylor expanded in lambda1 around 0 59.8%
cos-neg59.8%
Simplified59.8%
if -1.1000000000000001e-6 < phi1 < 4.10000000000000005e-5Initial program 64.4%
cos-diff87.9%
distribute-lft-in87.9%
Applied egg-rr87.9%
distribute-lft-out87.9%
*-commutative87.9%
fma-define88.0%
Simplified88.0%
add-cbrt-cube88.0%
pow388.0%
Applied egg-rr88.0%
Taylor expanded in phi1 around 0 87.9%
+-commutative87.9%
*-commutative87.9%
fma-define87.9%
*-commutative87.9%
*-commutative87.9%
associate-*l*87.9%
fma-define88.0%
*-commutative88.0%
Simplified88.0%
Taylor expanded in phi1 around 0 87.2%
Final simplification73.4%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (or (<= phi1 -1.15e-6) (not (<= phi1 4.4e-6)))
(*
R
(acos
(+
(* (sin phi1) (sin phi2))
(* (* (cos phi1) (cos phi2)) (cos (- lambda1 lambda2))))))
(*
R
(acos
(*
(cos phi2)
(+ (* (sin lambda1) (sin lambda2)) (* (cos lambda1) (cos lambda2))))))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if ((phi1 <= -1.15e-6) || !(phi1 <= 4.4e-6)) {
tmp = R * acos(((sin(phi1) * sin(phi2)) + ((cos(phi1) * cos(phi2)) * cos((lambda1 - lambda2)))));
} else {
tmp = R * acos((cos(phi2) * ((sin(lambda1) * sin(lambda2)) + (cos(lambda1) * cos(lambda2)))));
}
return tmp;
}
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if ((phi1 <= (-1.15d-6)) .or. (.not. (phi1 <= 4.4d-6))) then
tmp = r * acos(((sin(phi1) * sin(phi2)) + ((cos(phi1) * cos(phi2)) * cos((lambda1 - lambda2)))))
else
tmp = r * acos((cos(phi2) * ((sin(lambda1) * sin(lambda2)) + (cos(lambda1) * cos(lambda2)))))
end if
code = tmp
end function
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if ((phi1 <= -1.15e-6) || !(phi1 <= 4.4e-6)) {
tmp = R * Math.acos(((Math.sin(phi1) * Math.sin(phi2)) + ((Math.cos(phi1) * Math.cos(phi2)) * Math.cos((lambda1 - lambda2)))));
} else {
tmp = R * Math.acos((Math.cos(phi2) * ((Math.sin(lambda1) * Math.sin(lambda2)) + (Math.cos(lambda1) * Math.cos(lambda2)))));
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) [R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if (phi1 <= -1.15e-6) or not (phi1 <= 4.4e-6): tmp = R * math.acos(((math.sin(phi1) * math.sin(phi2)) + ((math.cos(phi1) * math.cos(phi2)) * math.cos((lambda1 - lambda2))))) else: tmp = R * math.acos((math.cos(phi2) * ((math.sin(lambda1) * math.sin(lambda2)) + (math.cos(lambda1) * math.cos(lambda2))))) return tmp
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if ((phi1 <= -1.15e-6) || !(phi1 <= 4.4e-6)) tmp = Float64(R * acos(Float64(Float64(sin(phi1) * sin(phi2)) + Float64(Float64(cos(phi1) * cos(phi2)) * cos(Float64(lambda1 - lambda2)))))); else tmp = Float64(R * acos(Float64(cos(phi2) * Float64(Float64(sin(lambda1) * sin(lambda2)) + Float64(cos(lambda1) * cos(lambda2)))))); end return tmp end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2)
tmp = 0.0;
if ((phi1 <= -1.15e-6) || ~((phi1 <= 4.4e-6)))
tmp = R * acos(((sin(phi1) * sin(phi2)) + ((cos(phi1) * cos(phi2)) * cos((lambda1 - lambda2)))));
else
tmp = R * acos((cos(phi2) * ((sin(lambda1) * sin(lambda2)) + (cos(lambda1) * cos(lambda2)))));
end
tmp_2 = tmp;
end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[Or[LessEqual[phi1, -1.15e-6], N[Not[LessEqual[phi1, 4.4e-6]], $MachinePrecision]], N[(R * N[ArcCos[N[(N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] + N[(N[(N[Cos[phi1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision] + N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -1.15 \cdot 10^{-6} \lor \neg \left(\phi_1 \leq 4.4 \cdot 10^{-6}\right):\\
\;\;\;\;R \cdot \cos^{-1} \left(\sin \phi_1 \cdot \sin \phi_2 + \left(\cos \phi_1 \cdot \cos \phi_2\right) \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_2 \cdot \left(\sin \lambda_1 \cdot \sin \lambda_2 + \cos \lambda_1 \cdot \cos \lambda_2\right)\right)\\
\end{array}
\end{array}
if phi1 < -1.15e-6 or 4.4000000000000002e-6 < phi1 Initial program 81.7%
if -1.15e-6 < phi1 < 4.4000000000000002e-6Initial program 64.4%
cos-diff87.9%
distribute-lft-in87.9%
Applied egg-rr87.9%
distribute-lft-out87.9%
*-commutative87.9%
fma-define88.0%
Simplified88.0%
add-cbrt-cube88.0%
pow388.0%
Applied egg-rr88.0%
Taylor expanded in phi1 around 0 87.9%
+-commutative87.9%
*-commutative87.9%
fma-define87.9%
*-commutative87.9%
*-commutative87.9%
associate-*l*87.9%
fma-define88.0%
*-commutative88.0%
Simplified88.0%
Taylor expanded in phi1 around 0 87.2%
Final simplification84.4%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(let* ((t_0
(+ (* (sin lambda1) (sin lambda2)) (* (cos lambda1) (cos lambda2)))))
(if (<= phi2 2.3e-18)
(* R (acos (* (cos phi1) t_0)))
(* R (acos (* (cos phi2) t_0))))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = (sin(lambda1) * sin(lambda2)) + (cos(lambda1) * cos(lambda2));
double tmp;
if (phi2 <= 2.3e-18) {
tmp = R * acos((cos(phi1) * t_0));
} else {
tmp = R * acos((cos(phi2) * t_0));
}
return tmp;
}
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: t_0
real(8) :: tmp
t_0 = (sin(lambda1) * sin(lambda2)) + (cos(lambda1) * cos(lambda2))
if (phi2 <= 2.3d-18) then
tmp = r * acos((cos(phi1) * t_0))
else
tmp = r * acos((cos(phi2) * t_0))
end if
code = tmp
end function
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double t_0 = (Math.sin(lambda1) * Math.sin(lambda2)) + (Math.cos(lambda1) * Math.cos(lambda2));
double tmp;
if (phi2 <= 2.3e-18) {
tmp = R * Math.acos((Math.cos(phi1) * t_0));
} else {
tmp = R * Math.acos((Math.cos(phi2) * t_0));
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) [R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): t_0 = (math.sin(lambda1) * math.sin(lambda2)) + (math.cos(lambda1) * math.cos(lambda2)) tmp = 0 if phi2 <= 2.3e-18: tmp = R * math.acos((math.cos(phi1) * t_0)) else: tmp = R * math.acos((math.cos(phi2) * t_0)) return tmp
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) t_0 = Float64(Float64(sin(lambda1) * sin(lambda2)) + Float64(cos(lambda1) * cos(lambda2))) tmp = 0.0 if (phi2 <= 2.3e-18) tmp = Float64(R * acos(Float64(cos(phi1) * t_0))); else tmp = Float64(R * acos(Float64(cos(phi2) * t_0))); end return tmp end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2)
t_0 = (sin(lambda1) * sin(lambda2)) + (cos(lambda1) * cos(lambda2));
tmp = 0.0;
if (phi2 <= 2.3e-18)
tmp = R * acos((cos(phi1) * t_0));
else
tmp = R * acos((cos(phi2) * t_0));
end
tmp_2 = tmp;
end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
code[R_, lambda1_, lambda2_, phi1_, phi2_] := Block[{t$95$0 = N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision] + N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[phi2, 2.3e-18], N[(R * N[ArcCos[N[(N[Cos[phi1], $MachinePrecision] * t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
t_0 := \sin \lambda_1 \cdot \sin \lambda_2 + \cos \lambda_1 \cdot \cos \lambda_2\\
\mathbf{if}\;\phi_2 \leq 2.3 \cdot 10^{-18}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_1 \cdot t\_0\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_2 \cdot t\_0\right)\\
\end{array}
\end{array}
if phi2 < 2.3000000000000001e-18Initial program 71.2%
cos-diff91.6%
distribute-lft-in91.6%
Applied egg-rr91.6%
distribute-lft-out91.6%
*-commutative91.6%
fma-define91.6%
Simplified91.6%
add-cbrt-cube91.6%
pow391.6%
Applied egg-rr91.6%
Taylor expanded in phi1 around 0 91.6%
+-commutative91.6%
*-commutative91.6%
fma-define91.6%
*-commutative91.6%
*-commutative91.6%
associate-*l*91.6%
fma-define91.6%
*-commutative91.6%
Simplified91.6%
Taylor expanded in phi2 around 0 65.0%
if 2.3000000000000001e-18 < phi2 Initial program 77.3%
cos-diff97.9%
distribute-lft-in98.0%
Applied egg-rr98.0%
distribute-lft-out97.9%
*-commutative97.9%
fma-define98.0%
Simplified98.0%
add-cbrt-cube98.1%
pow398.1%
Applied egg-rr98.1%
Taylor expanded in phi1 around 0 97.9%
+-commutative97.9%
*-commutative97.9%
fma-define97.9%
*-commutative97.9%
*-commutative97.9%
associate-*l*98.0%
fma-define98.0%
*-commutative98.0%
Simplified98.0%
Taylor expanded in phi1 around 0 61.3%
Final simplification63.8%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= phi2 0.015)
(*
R
(acos
(*
(cos phi1)
(+ (* (sin lambda1) (sin lambda2)) (* (cos lambda1) (cos lambda2))))))
(* R (acos (* (cos phi2) (cos (- lambda2 lambda1)))))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 0.015) {
tmp = R * acos((cos(phi1) * ((sin(lambda1) * sin(lambda2)) + (cos(lambda1) * cos(lambda2)))));
} else {
tmp = R * acos((cos(phi2) * cos((lambda2 - lambda1))));
}
return tmp;
}
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if (phi2 <= 0.015d0) then
tmp = r * acos((cos(phi1) * ((sin(lambda1) * sin(lambda2)) + (cos(lambda1) * cos(lambda2)))))
else
tmp = r * acos((cos(phi2) * cos((lambda2 - lambda1))))
end if
code = tmp
end function
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 0.015) {
tmp = R * Math.acos((Math.cos(phi1) * ((Math.sin(lambda1) * Math.sin(lambda2)) + (Math.cos(lambda1) * Math.cos(lambda2)))));
} else {
tmp = R * Math.acos((Math.cos(phi2) * Math.cos((lambda2 - lambda1))));
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) [R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 0.015: tmp = R * math.acos((math.cos(phi1) * ((math.sin(lambda1) * math.sin(lambda2)) + (math.cos(lambda1) * math.cos(lambda2))))) else: tmp = R * math.acos((math.cos(phi2) * math.cos((lambda2 - lambda1)))) return tmp
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 0.015) tmp = Float64(R * acos(Float64(cos(phi1) * Float64(Float64(sin(lambda1) * sin(lambda2)) + Float64(cos(lambda1) * cos(lambda2)))))); else tmp = Float64(R * acos(Float64(cos(phi2) * cos(Float64(lambda2 - lambda1))))); end return tmp end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2)
tmp = 0.0;
if (phi2 <= 0.015)
tmp = R * acos((cos(phi1) * ((sin(lambda1) * sin(lambda2)) + (cos(lambda1) * cos(lambda2)))));
else
tmp = R * acos((cos(phi2) * cos((lambda2 - lambda1))));
end
tmp_2 = tmp;
end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 0.015], N[(R * N[ArcCos[N[(N[Cos[phi1], $MachinePrecision] * N[(N[(N[Sin[lambda1], $MachinePrecision] * N[Sin[lambda2], $MachinePrecision]), $MachinePrecision] + N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 0.015:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_1 \cdot \left(\sin \lambda_1 \cdot \sin \lambda_2 + \cos \lambda_1 \cdot \cos \lambda_2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_2 \cdot \cos \left(\lambda_2 - \lambda_1\right)\right)\\
\end{array}
\end{array}
if phi2 < 0.014999999999999999Initial program 70.5%
cos-diff91.2%
distribute-lft-in91.2%
Applied egg-rr91.2%
distribute-lft-out91.2%
*-commutative91.2%
fma-define91.2%
Simplified91.2%
add-cbrt-cube91.2%
pow391.2%
Applied egg-rr91.2%
Taylor expanded in phi1 around 0 91.2%
+-commutative91.2%
*-commutative91.2%
fma-define91.2%
*-commutative91.2%
*-commutative91.2%
associate-*l*91.3%
fma-define91.3%
*-commutative91.3%
Simplified91.3%
Taylor expanded in phi2 around 0 64.6%
if 0.014999999999999999 < phi2 Initial program 79.1%
+-commutative79.1%
associate-*l*79.1%
fma-define79.1%
Simplified79.1%
Taylor expanded in phi1 around 0 40.8%
add-log-exp40.8%
Applied egg-rr40.8%
Taylor expanded in phi1 around 0 40.8%
+-commutative40.8%
fma-undefine40.8%
sub-neg40.8%
remove-double-neg40.8%
mul-1-neg40.8%
distribute-neg-in40.8%
+-commutative40.8%
cos-neg40.8%
mul-1-neg40.8%
unsub-neg40.8%
Simplified40.8%
Taylor expanded in phi1 around 0 50.2%
Final simplification60.2%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= phi1 -1e-6)
(*
R
(acos
(+ (* (sin phi1) (sin phi2)) (* (cos phi1) (cos (- lambda1 lambda2))))))
(* R (acos (* (cos phi2) (cos (- lambda2 lambda1)))))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -1e-6) {
tmp = R * acos(((sin(phi1) * sin(phi2)) + (cos(phi1) * cos((lambda1 - lambda2)))));
} else {
tmp = R * acos((cos(phi2) * cos((lambda2 - lambda1))));
}
return tmp;
}
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if (phi1 <= (-1d-6)) then
tmp = r * acos(((sin(phi1) * sin(phi2)) + (cos(phi1) * cos((lambda1 - lambda2)))))
else
tmp = r * acos((cos(phi2) * cos((lambda2 - lambda1))))
end if
code = tmp
end function
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -1e-6) {
tmp = R * Math.acos(((Math.sin(phi1) * Math.sin(phi2)) + (Math.cos(phi1) * Math.cos((lambda1 - lambda2)))));
} else {
tmp = R * Math.acos((Math.cos(phi2) * Math.cos((lambda2 - lambda1))));
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) [R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi1 <= -1e-6: tmp = R * math.acos(((math.sin(phi1) * math.sin(phi2)) + (math.cos(phi1) * math.cos((lambda1 - lambda2))))) else: tmp = R * math.acos((math.cos(phi2) * math.cos((lambda2 - lambda1)))) return tmp
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi1 <= -1e-6) tmp = Float64(R * acos(Float64(Float64(sin(phi1) * sin(phi2)) + Float64(cos(phi1) * cos(Float64(lambda1 - lambda2)))))); else tmp = Float64(R * acos(Float64(cos(phi2) * cos(Float64(lambda2 - lambda1))))); end return tmp end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2)
tmp = 0.0;
if (phi1 <= -1e-6)
tmp = R * acos(((sin(phi1) * sin(phi2)) + (cos(phi1) * cos((lambda1 - lambda2)))));
else
tmp = R * acos((cos(phi2) * cos((lambda2 - lambda1))));
end
tmp_2 = tmp;
end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi1, -1e-6], N[(R * N[ArcCos[N[(N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] + N[(N[Cos[phi1], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -1 \cdot 10^{-6}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\sin \phi_1 \cdot \sin \phi_2 + \cos \phi_1 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_2 \cdot \cos \left(\lambda_2 - \lambda_1\right)\right)\\
\end{array}
\end{array}
if phi1 < -9.99999999999999955e-7Initial program 82.0%
Taylor expanded in phi2 around 0 49.0%
*-commutative49.0%
Simplified49.0%
if -9.99999999999999955e-7 < phi1 Initial program 69.6%
+-commutative69.6%
associate-*l*69.6%
fma-define69.6%
Simplified69.6%
Taylor expanded in phi1 around 0 46.4%
add-log-exp46.3%
Applied egg-rr46.3%
Taylor expanded in phi1 around 0 46.4%
+-commutative46.4%
fma-undefine46.4%
sub-neg46.4%
remove-double-neg46.4%
mul-1-neg46.4%
distribute-neg-in46.4%
+-commutative46.4%
cos-neg46.4%
mul-1-neg46.4%
unsub-neg46.4%
Simplified46.4%
Taylor expanded in phi1 around 0 50.5%
Final simplification50.0%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= phi2 -0.00038)
(* R (acos (+ (* (sin phi1) (sin phi2)) (* (cos phi1) (cos phi2)))))
(if (<= phi2 0.015)
(*
R
(acos (+ (* (sin phi1) phi2) (* (cos phi1) (cos (- lambda1 lambda2))))))
(* R (acos (* (cos phi2) (cos (- lambda2 lambda1))))))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= -0.00038) {
tmp = R * acos(((sin(phi1) * sin(phi2)) + (cos(phi1) * cos(phi2))));
} else if (phi2 <= 0.015) {
tmp = R * acos(((sin(phi1) * phi2) + (cos(phi1) * cos((lambda1 - lambda2)))));
} else {
tmp = R * acos((cos(phi2) * cos((lambda2 - lambda1))));
}
return tmp;
}
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if (phi2 <= (-0.00038d0)) then
tmp = r * acos(((sin(phi1) * sin(phi2)) + (cos(phi1) * cos(phi2))))
else if (phi2 <= 0.015d0) then
tmp = r * acos(((sin(phi1) * phi2) + (cos(phi1) * cos((lambda1 - lambda2)))))
else
tmp = r * acos((cos(phi2) * cos((lambda2 - lambda1))))
end if
code = tmp
end function
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= -0.00038) {
tmp = R * Math.acos(((Math.sin(phi1) * Math.sin(phi2)) + (Math.cos(phi1) * Math.cos(phi2))));
} else if (phi2 <= 0.015) {
tmp = R * Math.acos(((Math.sin(phi1) * phi2) + (Math.cos(phi1) * Math.cos((lambda1 - lambda2)))));
} else {
tmp = R * Math.acos((Math.cos(phi2) * Math.cos((lambda2 - lambda1))));
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) [R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= -0.00038: tmp = R * math.acos(((math.sin(phi1) * math.sin(phi2)) + (math.cos(phi1) * math.cos(phi2)))) elif phi2 <= 0.015: tmp = R * math.acos(((math.sin(phi1) * phi2) + (math.cos(phi1) * math.cos((lambda1 - lambda2))))) else: tmp = R * math.acos((math.cos(phi2) * math.cos((lambda2 - lambda1)))) return tmp
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= -0.00038) tmp = Float64(R * acos(Float64(Float64(sin(phi1) * sin(phi2)) + Float64(cos(phi1) * cos(phi2))))); elseif (phi2 <= 0.015) tmp = Float64(R * acos(Float64(Float64(sin(phi1) * phi2) + Float64(cos(phi1) * cos(Float64(lambda1 - lambda2)))))); else tmp = Float64(R * acos(Float64(cos(phi2) * cos(Float64(lambda2 - lambda1))))); end return tmp end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2)
tmp = 0.0;
if (phi2 <= -0.00038)
tmp = R * acos(((sin(phi1) * sin(phi2)) + (cos(phi1) * cos(phi2))));
elseif (phi2 <= 0.015)
tmp = R * acos(((sin(phi1) * phi2) + (cos(phi1) * cos((lambda1 - lambda2)))));
else
tmp = R * acos((cos(phi2) * cos((lambda2 - lambda1))));
end
tmp_2 = tmp;
end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, -0.00038], N[(R * N[ArcCos[N[(N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] + N[(N[Cos[phi1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[phi2, 0.015], N[(R * N[ArcCos[N[(N[(N[Sin[phi1], $MachinePrecision] * phi2), $MachinePrecision] + N[(N[Cos[phi1], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq -0.00038:\\
\;\;\;\;R \cdot \cos^{-1} \left(\sin \phi_1 \cdot \sin \phi_2 + \cos \phi_1 \cdot \cos \phi_2\right)\\
\mathbf{elif}\;\phi_2 \leq 0.015:\\
\;\;\;\;R \cdot \cos^{-1} \left(\sin \phi_1 \cdot \phi_2 + \cos \phi_1 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_2 \cdot \cos \left(\lambda_2 - \lambda_1\right)\right)\\
\end{array}
\end{array}
if phi2 < -3.8000000000000002e-4Initial program 80.5%
+-commutative80.5%
associate-*l*80.5%
fma-define80.5%
Simplified80.5%
Taylor expanded in lambda2 around 0 62.6%
associate-*r*62.6%
fma-define62.6%
*-commutative62.6%
*-commutative62.6%
Simplified62.6%
Taylor expanded in lambda1 around 0 33.9%
if -3.8000000000000002e-4 < phi2 < 0.014999999999999999Initial program 65.8%
+-commutative65.8%
associate-*l*65.8%
fma-define65.8%
Simplified65.8%
Taylor expanded in phi2 around 0 65.8%
if 0.014999999999999999 < phi2 Initial program 79.1%
+-commutative79.1%
associate-*l*79.1%
fma-define79.1%
Simplified79.1%
Taylor expanded in phi1 around 0 40.8%
add-log-exp40.8%
Applied egg-rr40.8%
Taylor expanded in phi1 around 0 40.8%
+-commutative40.8%
fma-undefine40.8%
sub-neg40.8%
remove-double-neg40.8%
mul-1-neg40.8%
distribute-neg-in40.8%
+-commutative40.8%
cos-neg40.8%
mul-1-neg40.8%
unsub-neg40.8%
Simplified40.8%
Taylor expanded in phi1 around 0 50.2%
Final simplification53.9%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
(FPCore (R lambda1 lambda2 phi1 phi2)
:precision binary64
(if (<= phi2 0.028)
(*
R
(acos (+ (* (sin phi1) phi2) (* (cos phi1) (cos (- lambda1 lambda2))))))
(* R (acos (* (cos phi2) (cos (- lambda2 lambda1)))))))assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 0.028) {
tmp = R * acos(((sin(phi1) * phi2) + (cos(phi1) * cos((lambda1 - lambda2)))));
} else {
tmp = R * acos((cos(phi2) * cos((lambda2 - lambda1))));
}
return tmp;
}
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if (phi2 <= 0.028d0) then
tmp = r * acos(((sin(phi1) * phi2) + (cos(phi1) * cos((lambda1 - lambda2)))))
else
tmp = r * acos((cos(phi2) * cos((lambda2 - lambda1))))
end if
code = tmp
end function
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 0.028) {
tmp = R * Math.acos(((Math.sin(phi1) * phi2) + (Math.cos(phi1) * Math.cos((lambda1 - lambda2)))));
} else {
tmp = R * Math.acos((Math.cos(phi2) * Math.cos((lambda2 - lambda1))));
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) [R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 0.028: tmp = R * math.acos(((math.sin(phi1) * phi2) + (math.cos(phi1) * math.cos((lambda1 - lambda2))))) else: tmp = R * math.acos((math.cos(phi2) * math.cos((lambda2 - lambda1)))) return tmp
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 0.028) tmp = Float64(R * acos(Float64(Float64(sin(phi1) * phi2) + Float64(cos(phi1) * cos(Float64(lambda1 - lambda2)))))); else tmp = Float64(R * acos(Float64(cos(phi2) * cos(Float64(lambda2 - lambda1))))); end return tmp end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2)
tmp = 0.0;
if (phi2 <= 0.028)
tmp = R * acos(((sin(phi1) * phi2) + (cos(phi1) * cos((lambda1 - lambda2)))));
else
tmp = R * acos((cos(phi2) * cos((lambda2 - lambda1))));
end
tmp_2 = tmp;
end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 0.028], N[(R * N[ArcCos[N[(N[(N[Sin[phi1], $MachinePrecision] * phi2), $MachinePrecision] + N[(N[Cos[phi1], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 0.028:\\
\;\;\;\;R \cdot \cos^{-1} \left(\sin \phi_1 \cdot \phi_2 + \cos \phi_1 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_2 \cdot \cos \left(\lambda_2 - \lambda_1\right)\right)\\
\end{array}
\end{array}
if phi2 < 0.0280000000000000006Initial program 70.5%
+-commutative70.5%
associate-*l*70.5%
fma-define70.5%
Simplified70.5%
Taylor expanded in phi2 around 0 45.8%
if 0.0280000000000000006 < phi2 Initial program 79.1%
+-commutative79.1%
associate-*l*79.1%
fma-define79.1%
Simplified79.1%
Taylor expanded in phi1 around 0 40.8%
add-log-exp40.8%
Applied egg-rr40.8%
Taylor expanded in phi1 around 0 40.8%
+-commutative40.8%
fma-undefine40.8%
sub-neg40.8%
remove-double-neg40.8%
mul-1-neg40.8%
distribute-neg-in40.8%
+-commutative40.8%
cos-neg40.8%
mul-1-neg40.8%
unsub-neg40.8%
Simplified40.8%
Taylor expanded in phi1 around 0 50.2%
Final simplification47.2%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. (FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi1 -1.1e-6) (* R (acos (* (cos phi1) (cos lambda1)))) (* R (acos (* (cos phi2) (cos (- lambda2 lambda1)))))))
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -1.1e-6) {
tmp = R * acos((cos(phi1) * cos(lambda1)));
} else {
tmp = R * acos((cos(phi2) * cos((lambda2 - lambda1))));
}
return tmp;
}
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if (phi1 <= (-1.1d-6)) then
tmp = r * acos((cos(phi1) * cos(lambda1)))
else
tmp = r * acos((cos(phi2) * cos((lambda2 - lambda1))))
end if
code = tmp
end function
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi1 <= -1.1e-6) {
tmp = R * Math.acos((Math.cos(phi1) * Math.cos(lambda1)));
} else {
tmp = R * Math.acos((Math.cos(phi2) * Math.cos((lambda2 - lambda1))));
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) [R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi1 <= -1.1e-6: tmp = R * math.acos((math.cos(phi1) * math.cos(lambda1))) else: tmp = R * math.acos((math.cos(phi2) * math.cos((lambda2 - lambda1)))) return tmp
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi1 <= -1.1e-6) tmp = Float64(R * acos(Float64(cos(phi1) * cos(lambda1)))); else tmp = Float64(R * acos(Float64(cos(phi2) * cos(Float64(lambda2 - lambda1))))); end return tmp end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2)
tmp = 0.0;
if (phi1 <= -1.1e-6)
tmp = R * acos((cos(phi1) * cos(lambda1)));
else
tmp = R * acos((cos(phi2) * cos((lambda2 - lambda1))));
end
tmp_2 = tmp;
end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi1, -1.1e-6], N[(R * N[ArcCos[N[(N[Cos[phi1], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -1.1 \cdot 10^{-6}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_1 \cdot \cos \lambda_1\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_2 \cdot \cos \left(\lambda_2 - \lambda_1\right)\right)\\
\end{array}
\end{array}
if phi1 < -1.1000000000000001e-6Initial program 82.0%
+-commutative82.0%
associate-*l*82.0%
fma-define82.0%
Simplified82.0%
Taylor expanded in lambda2 around 0 69.2%
associate-*r*69.1%
fma-define69.2%
*-commutative69.2%
*-commutative69.2%
Simplified69.2%
Taylor expanded in phi2 around 0 43.6%
*-commutative43.6%
Simplified43.6%
if -1.1000000000000001e-6 < phi1 Initial program 69.6%
+-commutative69.6%
associate-*l*69.6%
fma-define69.6%
Simplified69.6%
Taylor expanded in phi1 around 0 46.4%
add-log-exp46.3%
Applied egg-rr46.3%
Taylor expanded in phi1 around 0 46.4%
+-commutative46.4%
fma-undefine46.4%
sub-neg46.4%
remove-double-neg46.4%
mul-1-neg46.4%
distribute-neg-in46.4%
+-commutative46.4%
cos-neg46.4%
mul-1-neg46.4%
unsub-neg46.4%
Simplified46.4%
Taylor expanded in phi1 around 0 50.5%
Final simplification48.5%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. (FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi2 0.015) (* R (acos (* (cos phi1) (cos lambda1)))) (* R (acos (* (cos phi2) (cos lambda1))))))
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 0.015) {
tmp = R * acos((cos(phi1) * cos(lambda1)));
} else {
tmp = R * acos((cos(phi2) * cos(lambda1)));
}
return tmp;
}
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if (phi2 <= 0.015d0) then
tmp = r * acos((cos(phi1) * cos(lambda1)))
else
tmp = r * acos((cos(phi2) * cos(lambda1)))
end if
code = tmp
end function
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 0.015) {
tmp = R * Math.acos((Math.cos(phi1) * Math.cos(lambda1)));
} else {
tmp = R * Math.acos((Math.cos(phi2) * Math.cos(lambda1)));
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) [R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 0.015: tmp = R * math.acos((math.cos(phi1) * math.cos(lambda1))) else: tmp = R * math.acos((math.cos(phi2) * math.cos(lambda1))) return tmp
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 0.015) tmp = Float64(R * acos(Float64(cos(phi1) * cos(lambda1)))); else tmp = Float64(R * acos(Float64(cos(phi2) * cos(lambda1)))); end return tmp end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2)
tmp = 0.0;
if (phi2 <= 0.015)
tmp = R * acos((cos(phi1) * cos(lambda1)));
else
tmp = R * acos((cos(phi2) * cos(lambda1)));
end
tmp_2 = tmp;
end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 0.015], N[(R * N[ArcCos[N[(N[Cos[phi1], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 0.015:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_1 \cdot \cos \lambda_1\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_2 \cdot \cos \lambda_1\right)\\
\end{array}
\end{array}
if phi2 < 0.014999999999999999Initial program 70.5%
+-commutative70.5%
associate-*l*70.5%
fma-define70.5%
Simplified70.5%
Taylor expanded in lambda2 around 0 52.7%
associate-*r*52.6%
fma-define52.7%
*-commutative52.7%
*-commutative52.7%
Simplified52.7%
Taylor expanded in phi2 around 0 37.7%
*-commutative37.7%
Simplified37.7%
if 0.014999999999999999 < phi2 Initial program 79.1%
+-commutative79.1%
associate-*l*79.1%
fma-define79.1%
Simplified79.1%
Taylor expanded in lambda2 around 0 61.4%
associate-*r*61.4%
fma-define61.4%
*-commutative61.4%
*-commutative61.4%
Simplified61.4%
Taylor expanded in phi1 around 0 42.1%
Final simplification39.1%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. (FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= lambda2 0.56) (* R (acos (* (cos phi2) (cos lambda1)))) (* R (acos (cos (- lambda2 lambda1))))))
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda2 <= 0.56) {
tmp = R * acos((cos(phi2) * cos(lambda1)));
} else {
tmp = R * acos(cos((lambda2 - lambda1)));
}
return tmp;
}
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if (lambda2 <= 0.56d0) then
tmp = r * acos((cos(phi2) * cos(lambda1)))
else
tmp = r * acos(cos((lambda2 - lambda1)))
end if
code = tmp
end function
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (lambda2 <= 0.56) {
tmp = R * Math.acos((Math.cos(phi2) * Math.cos(lambda1)));
} else {
tmp = R * Math.acos(Math.cos((lambda2 - lambda1)));
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) [R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if lambda2 <= 0.56: tmp = R * math.acos((math.cos(phi2) * math.cos(lambda1))) else: tmp = R * math.acos(math.cos((lambda2 - lambda1))) return tmp
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (lambda2 <= 0.56) tmp = Float64(R * acos(Float64(cos(phi2) * cos(lambda1)))); else tmp = Float64(R * acos(cos(Float64(lambda2 - lambda1)))); end return tmp end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2)
tmp = 0.0;
if (lambda2 <= 0.56)
tmp = R * acos((cos(phi2) * cos(lambda1)));
else
tmp = R * acos(cos((lambda2 - lambda1)));
end
tmp_2 = tmp;
end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[lambda2, 0.56], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\lambda_2 \leq 0.56:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_2 \cdot \cos \lambda_1\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \cos \left(\lambda_2 - \lambda_1\right)\\
\end{array}
\end{array}
if lambda2 < 0.56000000000000005Initial program 77.6%
+-commutative77.6%
associate-*l*77.6%
fma-define77.6%
Simplified77.6%
Taylor expanded in lambda2 around 0 65.2%
associate-*r*65.2%
fma-define65.2%
*-commutative65.2%
*-commutative65.2%
Simplified65.2%
Taylor expanded in phi1 around 0 35.3%
if 0.56000000000000005 < lambda2 Initial program 57.1%
+-commutative57.1%
associate-*l*57.1%
fma-define57.1%
Simplified57.1%
Taylor expanded in phi1 around 0 31.3%
add-log-exp31.3%
Applied egg-rr31.3%
Taylor expanded in phi1 around 0 31.3%
+-commutative31.3%
fma-undefine31.3%
sub-neg31.3%
remove-double-neg31.3%
mul-1-neg31.3%
distribute-neg-in31.3%
+-commutative31.3%
cos-neg31.3%
mul-1-neg31.3%
unsub-neg31.3%
Simplified31.3%
Taylor expanded in phi2 around 0 28.3%
Final simplification33.8%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. (FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi2 6.6e+40) (* R (acos (cos (- lambda2 lambda1)))) (* R (acos (cos phi2)))))
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 6.6e+40) {
tmp = R * acos(cos((lambda2 - lambda1)));
} else {
tmp = R * acos(cos(phi2));
}
return tmp;
}
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if (phi2 <= 6.6d+40) then
tmp = r * acos(cos((lambda2 - lambda1)))
else
tmp = r * acos(cos(phi2))
end if
code = tmp
end function
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 6.6e+40) {
tmp = R * Math.acos(Math.cos((lambda2 - lambda1)));
} else {
tmp = R * Math.acos(Math.cos(phi2));
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) [R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 6.6e+40: tmp = R * math.acos(math.cos((lambda2 - lambda1))) else: tmp = R * math.acos(math.cos(phi2)) return tmp
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 6.6e+40) tmp = Float64(R * acos(cos(Float64(lambda2 - lambda1)))); else tmp = Float64(R * acos(cos(phi2))); end return tmp end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2)
tmp = 0.0;
if (phi2 <= 6.6e+40)
tmp = R * acos(cos((lambda2 - lambda1)));
else
tmp = R * acos(cos(phi2));
end
tmp_2 = tmp;
end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 6.6e+40], N[(R * N[ArcCos[N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[Cos[phi2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 6.6 \cdot 10^{+40}:\\
\;\;\;\;R \cdot \cos^{-1} \cos \left(\lambda_2 - \lambda_1\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \cos \phi_2\\
\end{array}
\end{array}
if phi2 < 6.5999999999999997e40Initial program 70.8%
+-commutative70.8%
associate-*l*70.8%
fma-define70.8%
Simplified70.8%
Taylor expanded in phi1 around 0 31.5%
add-log-exp31.3%
Applied egg-rr31.3%
Taylor expanded in phi1 around 0 31.5%
+-commutative31.5%
fma-undefine31.5%
sub-neg31.5%
remove-double-neg31.5%
mul-1-neg31.5%
distribute-neg-in31.5%
+-commutative31.5%
cos-neg31.5%
mul-1-neg31.5%
unsub-neg31.5%
Simplified31.5%
Taylor expanded in phi2 around 0 26.6%
if 6.5999999999999997e40 < phi2 Initial program 79.4%
+-commutative79.4%
associate-*l*79.4%
fma-define79.4%
Simplified79.4%
Taylor expanded in lambda2 around 0 61.7%
associate-*r*61.6%
fma-define61.6%
*-commutative61.6%
*-commutative61.6%
Simplified61.6%
Taylor expanded in phi1 around 0 43.4%
Taylor expanded in lambda1 around 0 31.2%
Final simplification27.9%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. (FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (if (<= phi2 0.021) (* R (acos (cos lambda1))) (* R (acos (cos phi2)))))
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 0.021) {
tmp = R * acos(cos(lambda1));
} else {
tmp = R * acos(cos(phi2));
}
return tmp;
}
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8) :: tmp
if (phi2 <= 0.021d0) then
tmp = r * acos(cos(lambda1))
else
tmp = r * acos(cos(phi2))
end if
code = tmp
end function
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
double tmp;
if (phi2 <= 0.021) {
tmp = R * Math.acos(Math.cos(lambda1));
} else {
tmp = R * Math.acos(Math.cos(phi2));
}
return tmp;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) [R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): tmp = 0 if phi2 <= 0.021: tmp = R * math.acos(math.cos(lambda1)) else: tmp = R * math.acos(math.cos(phi2)) return tmp
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) tmp = 0.0 if (phi2 <= 0.021) tmp = Float64(R * acos(cos(lambda1))); else tmp = Float64(R * acos(cos(phi2))); end return tmp end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp_2 = code(R, lambda1, lambda2, phi1, phi2)
tmp = 0.0;
if (phi2 <= 0.021)
tmp = R * acos(cos(lambda1));
else
tmp = R * acos(cos(phi2));
end
tmp_2 = tmp;
end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := If[LessEqual[phi2, 0.021], N[(R * N[ArcCos[N[Cos[lambda1], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[Cos[phi2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\begin{array}{l}
\mathbf{if}\;\phi_2 \leq 0.021:\\
\;\;\;\;R \cdot \cos^{-1} \cos \lambda_1\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \cos \phi_2\\
\end{array}
\end{array}
if phi2 < 0.0210000000000000013Initial program 70.5%
+-commutative70.5%
associate-*l*70.5%
fma-define70.5%
Simplified70.5%
Taylor expanded in lambda2 around 0 52.7%
associate-*r*52.6%
fma-define52.7%
*-commutative52.7%
*-commutative52.7%
Simplified52.7%
Taylor expanded in phi1 around 0 26.1%
Taylor expanded in phi2 around 0 18.4%
if 0.0210000000000000013 < phi2 Initial program 79.1%
+-commutative79.1%
associate-*l*79.1%
fma-define79.1%
Simplified79.1%
Taylor expanded in lambda2 around 0 61.4%
associate-*r*61.4%
fma-define61.4%
*-commutative61.4%
*-commutative61.4%
Simplified61.4%
Taylor expanded in phi1 around 0 42.1%
Taylor expanded in lambda1 around 0 29.6%
Final simplification21.8%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. (FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (* R (acos (cos lambda1))))
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * acos(cos(lambda1));
}
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
code = r * acos(cos(lambda1))
end function
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * Math.acos(Math.cos(lambda1));
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) [R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): return R * math.acos(math.cos(lambda1))
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * acos(cos(lambda1))) end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp = code(R, lambda1, lambda2, phi1, phi2)
tmp = R * acos(cos(lambda1));
end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(R * N[ArcCos[N[Cos[lambda1], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
R \cdot \cos^{-1} \cos \lambda_1
\end{array}
Initial program 73.2%
+-commutative73.2%
associate-*l*73.2%
fma-define73.2%
Simplified73.2%
Taylor expanded in lambda2 around 0 55.4%
associate-*r*55.3%
fma-define55.3%
*-commutative55.3%
*-commutative55.3%
Simplified55.3%
Taylor expanded in phi1 around 0 31.0%
Taylor expanded in phi2 around 0 16.5%
Final simplification16.5%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. (FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (* R (acos 1.0)))
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * acos(1.0);
}
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
code = r * acos(1.0d0)
end function
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return R * Math.acos(1.0);
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) [R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): return R * math.acos(1.0)
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) return Float64(R * acos(1.0)) end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp = code(R, lambda1, lambda2, phi1, phi2)
tmp = R * acos(1.0);
end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(R * N[ArcCos[1.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
R \cdot \cos^{-1} 1
\end{array}
Initial program 73.2%
+-commutative73.2%
associate-*l*73.2%
fma-define73.2%
Simplified73.2%
Taylor expanded in lambda2 around 0 55.4%
associate-*r*55.3%
fma-define55.3%
*-commutative55.3%
*-commutative55.3%
Simplified55.3%
Taylor expanded in phi1 around 0 31.0%
Taylor expanded in phi2 around 0 16.5%
Taylor expanded in lambda1 around 0 4.2%
Final simplification4.2%
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. (FPCore (R lambda1 lambda2 phi1 phi2) :precision binary64 (* lambda1 R))
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
assert(R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2);
double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return lambda1 * R;
}
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function.
real(8) function code(r, lambda1, lambda2, phi1, phi2)
real(8), intent (in) :: r
real(8), intent (in) :: lambda1
real(8), intent (in) :: lambda2
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
code = lambda1 * r
end function
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
assert R < lambda1 && lambda1 < lambda2 && lambda2 < phi1 && phi1 < phi2;
public static double code(double R, double lambda1, double lambda2, double phi1, double phi2) {
return lambda1 * R;
}
[R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) [R, lambda1, lambda2, phi1, phi2] = sort([R, lambda1, lambda2, phi1, phi2]) def code(R, lambda1, lambda2, phi1, phi2): return lambda1 * R
R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) R, lambda1, lambda2, phi1, phi2 = sort([R, lambda1, lambda2, phi1, phi2]) function code(R, lambda1, lambda2, phi1, phi2) return Float64(lambda1 * R) end
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
R, lambda1, lambda2, phi1, phi2 = num2cell(sort([R, lambda1, lambda2, phi1, phi2])){:}
function tmp = code(R, lambda1, lambda2, phi1, phi2)
tmp = lambda1 * R;
end
NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. NOTE: R, lambda1, lambda2, phi1, and phi2 should be sorted in increasing order before calling this function. code[R_, lambda1_, lambda2_, phi1_, phi2_] := N[(lambda1 * R), $MachinePrecision]
\begin{array}{l}
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\\\
[R, lambda1, lambda2, phi1, phi2] = \mathsf{sort}([R, lambda1, lambda2, phi1, phi2])\\
\\
\lambda_1 \cdot R
\end{array}
Initial program 73.2%
+-commutative73.2%
associate-*l*73.2%
fma-define73.2%
Simplified73.2%
Taylor expanded in lambda2 around 0 55.4%
associate-*r*55.3%
fma-define55.3%
*-commutative55.3%
*-commutative55.3%
Simplified55.3%
Taylor expanded in phi1 around 0 31.0%
Taylor expanded in phi2 around 0 16.5%
Taylor expanded in lambda1 around 0 5.0%
herbie shell --seed 2024188
(FPCore (R lambda1 lambda2 phi1 phi2)
:name "Spherical law of cosines"
:precision binary64
(* (acos (+ (* (sin phi1) (sin phi2)) (* (* (cos phi1) (cos phi2)) (cos (- lambda1 lambda2))))) R))