
(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 29 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
(*
(acos
(fma
(* (cos phi2) (* (sin lambda2) (sin lambda1)))
(cos phi1)
(fma
(cos lambda1)
(* (cos phi2) (* (cos phi1) (cos lambda2)))
(* (sin phi1) (sin phi2)))))
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 acos(fma((cos(phi2) * (sin(lambda2) * sin(lambda1))), cos(phi1), fma(cos(lambda1), (cos(phi2) * (cos(phi1) * cos(lambda2))), (sin(phi1) * sin(phi2))))) * 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(acos(fma(Float64(cos(phi2) * Float64(sin(lambda2) * sin(lambda1))), cos(phi1), fma(cos(lambda1), Float64(cos(phi2) * Float64(cos(phi1) * cos(lambda2))), Float64(sin(phi1) * sin(phi2))))) * 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[(N[ArcCos[N[(N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[lambda2], $MachinePrecision] * N[Sin[lambda1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision] + N[(N[Cos[lambda1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * 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])\\
\\
\cos^{-1} \left(\mathsf{fma}\left(\cos \phi_2 \cdot \left(\sin \lambda_2 \cdot \sin \lambda_1\right), \cos \phi_1, \mathsf{fma}\left(\cos \lambda_1, \cos \phi_2 \cdot \left(\cos \phi_1 \cdot \cos \lambda_2\right), \sin \phi_1 \cdot \sin \phi_2\right)\right)\right) \cdot R
\end{array}
Initial program 77.4%
lift-cos.f64N/A
lift--.f64N/A
cos-diffN/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-sin.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-cos.f6494.4
Applied rewrites94.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-fma.f64N/A
distribute-rgt-inN/A
associate-+l+N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
Applied rewrites94.4%
Final simplification94.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
(*
R
(acos
(fma
(*
(cos phi2)
(fma (sin lambda2) (sin lambda1) (* (cos lambda1) (cos lambda2))))
(cos phi1)
(* (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) {
return R * acos(fma((cos(phi2) * fma(sin(lambda2), sin(lambda1), (cos(lambda1) * cos(lambda2)))), cos(phi1), (sin(phi1) * sin(phi2))));
}
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(fma(Float64(cos(phi2) * fma(sin(lambda2), sin(lambda1), Float64(cos(lambda1) * cos(lambda2)))), cos(phi1), Float64(sin(phi1) * sin(phi2))))) 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[(N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[lambda2], $MachinePrecision] * N[Sin[lambda1], $MachinePrecision] + N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision] + 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])\\
\\
R \cdot \cos^{-1} \left(\mathsf{fma}\left(\cos \phi_2 \cdot \mathsf{fma}\left(\sin \lambda_2, \sin \lambda_1, \cos \lambda_1 \cdot \cos \lambda_2\right), \cos \phi_1, \sin \phi_1 \cdot \sin \phi_2\right)\right)
\end{array}
Initial program 77.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6477.4
Applied rewrites77.4%
lift-cos.f64N/A
lift--.f64N/A
cos-diffN/A
lift-cos.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-sin.f64N/A
*-commutativeN/A
+-commutativeN/A
lift-fma.f6494.4
Applied rewrites94.4%
Final simplification94.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))))
(if (<= phi1 -2.6e-21)
(fma
(* PI 0.5)
R
(*
(asin (fma (cos phi2) (* (cos phi1) t_0) (* (sin phi1) (sin phi2))))
(- R)))
(if (<= phi1 0.057)
(*
R
(acos
(fma
(*
(cos phi2)
(fma (sin lambda2) (sin lambda1) (* (cos lambda1) (cos lambda2))))
(cos phi1)
(*
phi1
(*
(sin phi2)
(+
(fma -0.16666666666666666 (* phi1 phi1) 1.0)
(* (* phi1 phi1) (* (* phi1 phi1) 0.008333333333333333))))))))
(*
R
(acos
(fma (sin phi2) (sin phi1) (* (cos phi1) (* (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 = cos((lambda1 - lambda2));
double tmp;
if (phi1 <= -2.6e-21) {
tmp = fma((((double) M_PI) * 0.5), R, (asin(fma(cos(phi2), (cos(phi1) * t_0), (sin(phi1) * sin(phi2)))) * -R));
} else if (phi1 <= 0.057) {
tmp = R * acos(fma((cos(phi2) * fma(sin(lambda2), sin(lambda1), (cos(lambda1) * cos(lambda2)))), cos(phi1), (phi1 * (sin(phi2) * (fma(-0.16666666666666666, (phi1 * phi1), 1.0) + ((phi1 * phi1) * ((phi1 * phi1) * 0.008333333333333333)))))));
} else {
tmp = R * acos(fma(sin(phi2), sin(phi1), (cos(phi1) * (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 = cos(Float64(lambda1 - lambda2)) tmp = 0.0 if (phi1 <= -2.6e-21) tmp = fma(Float64(pi * 0.5), R, Float64(asin(fma(cos(phi2), Float64(cos(phi1) * t_0), Float64(sin(phi1) * sin(phi2)))) * Float64(-R))); elseif (phi1 <= 0.057) tmp = Float64(R * acos(fma(Float64(cos(phi2) * fma(sin(lambda2), sin(lambda1), Float64(cos(lambda1) * cos(lambda2)))), cos(phi1), Float64(phi1 * Float64(sin(phi2) * Float64(fma(-0.16666666666666666, Float64(phi1 * phi1), 1.0) + Float64(Float64(phi1 * phi1) * Float64(Float64(phi1 * phi1) * 0.008333333333333333)))))))); else tmp = Float64(R * acos(fma(sin(phi2), sin(phi1), Float64(cos(phi1) * Float64(cos(phi2) * t_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[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[phi1, -2.6e-21], N[(N[(Pi * 0.5), $MachinePrecision] * R + N[(N[ArcSin[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * t$95$0), $MachinePrecision] + N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * (-R)), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 0.057], N[(R * N[ArcCos[N[(N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[lambda2], $MachinePrecision] * N[Sin[lambda1], $MachinePrecision] + N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision] + N[(phi1 * N[(N[Sin[phi2], $MachinePrecision] * N[(N[(-0.16666666666666666 * N[(phi1 * phi1), $MachinePrecision] + 1.0), $MachinePrecision] + N[(N[(phi1 * phi1), $MachinePrecision] * N[(N[(phi1 * phi1), $MachinePrecision] * 0.008333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Sin[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision] + N[(N[Cos[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * t$95$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 := \cos \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_1 \leq -2.6 \cdot 10^{-21}:\\
\;\;\;\;\mathsf{fma}\left(\pi \cdot 0.5, R, \sin^{-1} \left(\mathsf{fma}\left(\cos \phi_2, \cos \phi_1 \cdot t\_0, \sin \phi_1 \cdot \sin \phi_2\right)\right) \cdot \left(-R\right)\right)\\
\mathbf{elif}\;\phi_1 \leq 0.057:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\cos \phi_2 \cdot \mathsf{fma}\left(\sin \lambda_2, \sin \lambda_1, \cos \lambda_1 \cdot \cos \lambda_2\right), \cos \phi_1, \phi_1 \cdot \left(\sin \phi_2 \cdot \left(\mathsf{fma}\left(-0.16666666666666666, \phi_1 \cdot \phi_1, 1\right) + \left(\phi_1 \cdot \phi_1\right) \cdot \left(\left(\phi_1 \cdot \phi_1\right) \cdot 0.008333333333333333\right)\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\sin \phi_2, \sin \phi_1, \cos \phi_1 \cdot \left(\cos \phi_2 \cdot t\_0\right)\right)\right)\\
\end{array}
\end{array}
if phi1 < -2.60000000000000017e-21Initial program 86.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6486.4
Applied rewrites86.4%
lift-cos.f64N/A
lift--.f64N/A
cos-diffN/A
lift-cos.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-sin.f64N/A
*-commutativeN/A
+-commutativeN/A
lift-fma.f6499.1
Applied rewrites99.1%
Applied rewrites86.4%
if -2.60000000000000017e-21 < phi1 < 0.0570000000000000021Initial program 69.7%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6469.7
Applied rewrites69.7%
lift-cos.f64N/A
lift--.f64N/A
cos-diffN/A
lift-cos.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-sin.f64N/A
*-commutativeN/A
+-commutativeN/A
lift-fma.f6489.2
Applied rewrites89.2%
Taylor expanded in phi1 around 0
lower-*.f64N/A
distribute-lft-inN/A
associate-+r+N/A
associate-*r*N/A
*-commutativeN/A
distribute-rgt1-inN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-outN/A
lower-*.f64N/A
lower-sin.f64N/A
lower-+.f64N/A
Applied rewrites89.2%
if 0.0570000000000000021 < phi1 Initial program 82.3%
lift-+.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6482.3
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6482.3
Applied rewrites82.3%
Final simplification86.6%
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.6e-21)
(fma
(* PI 0.5)
R
(*
(asin (fma (cos phi2) (* (cos phi1) t_0) (* (sin phi1) (sin phi2))))
(- R)))
(if (<= phi1 0.045)
(*
R
(acos
(fma
(*
(cos phi2)
(fma (sin lambda2) (sin lambda1) (* (cos lambda1) (cos lambda2))))
(cos phi1)
(*
(sin phi2)
(fma phi1 (* -0.16666666666666666 (* phi1 phi1)) phi1)))))
(*
R
(acos
(fma (sin phi2) (sin phi1) (* (cos phi1) (* (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 = cos((lambda1 - lambda2));
double tmp;
if (phi1 <= -2.6e-21) {
tmp = fma((((double) M_PI) * 0.5), R, (asin(fma(cos(phi2), (cos(phi1) * t_0), (sin(phi1) * sin(phi2)))) * -R));
} else if (phi1 <= 0.045) {
tmp = R * acos(fma((cos(phi2) * fma(sin(lambda2), sin(lambda1), (cos(lambda1) * cos(lambda2)))), cos(phi1), (sin(phi2) * fma(phi1, (-0.16666666666666666 * (phi1 * phi1)), phi1))));
} else {
tmp = R * acos(fma(sin(phi2), sin(phi1), (cos(phi1) * (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 = cos(Float64(lambda1 - lambda2)) tmp = 0.0 if (phi1 <= -2.6e-21) tmp = fma(Float64(pi * 0.5), R, Float64(asin(fma(cos(phi2), Float64(cos(phi1) * t_0), Float64(sin(phi1) * sin(phi2)))) * Float64(-R))); elseif (phi1 <= 0.045) tmp = Float64(R * acos(fma(Float64(cos(phi2) * fma(sin(lambda2), sin(lambda1), Float64(cos(lambda1) * cos(lambda2)))), cos(phi1), Float64(sin(phi2) * fma(phi1, Float64(-0.16666666666666666 * Float64(phi1 * phi1)), phi1))))); else tmp = Float64(R * acos(fma(sin(phi2), sin(phi1), Float64(cos(phi1) * Float64(cos(phi2) * t_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[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[phi1, -2.6e-21], N[(N[(Pi * 0.5), $MachinePrecision] * R + N[(N[ArcSin[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * t$95$0), $MachinePrecision] + N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * (-R)), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 0.045], N[(R * N[ArcCos[N[(N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[lambda2], $MachinePrecision] * N[Sin[lambda1], $MachinePrecision] + N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision] + N[(N[Sin[phi2], $MachinePrecision] * N[(phi1 * N[(-0.16666666666666666 * N[(phi1 * phi1), $MachinePrecision]), $MachinePrecision] + phi1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Sin[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision] + N[(N[Cos[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * t$95$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 := \cos \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_1 \leq -2.6 \cdot 10^{-21}:\\
\;\;\;\;\mathsf{fma}\left(\pi \cdot 0.5, R, \sin^{-1} \left(\mathsf{fma}\left(\cos \phi_2, \cos \phi_1 \cdot t\_0, \sin \phi_1 \cdot \sin \phi_2\right)\right) \cdot \left(-R\right)\right)\\
\mathbf{elif}\;\phi_1 \leq 0.045:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\cos \phi_2 \cdot \mathsf{fma}\left(\sin \lambda_2, \sin \lambda_1, \cos \lambda_1 \cdot \cos \lambda_2\right), \cos \phi_1, \sin \phi_2 \cdot \mathsf{fma}\left(\phi_1, -0.16666666666666666 \cdot \left(\phi_1 \cdot \phi_1\right), \phi_1\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\sin \phi_2, \sin \phi_1, \cos \phi_1 \cdot \left(\cos \phi_2 \cdot t\_0\right)\right)\right)\\
\end{array}
\end{array}
if phi1 < -2.60000000000000017e-21Initial program 86.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6486.4
Applied rewrites86.4%
lift-cos.f64N/A
lift--.f64N/A
cos-diffN/A
lift-cos.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-sin.f64N/A
*-commutativeN/A
+-commutativeN/A
lift-fma.f6499.1
Applied rewrites99.1%
Applied rewrites86.4%
if -2.60000000000000017e-21 < phi1 < 0.044999999999999998Initial program 69.7%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6469.7
Applied rewrites69.7%
lift-cos.f64N/A
lift--.f64N/A
cos-diffN/A
lift-cos.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-sin.f64N/A
*-commutativeN/A
+-commutativeN/A
lift-fma.f6489.2
Applied rewrites89.2%
Taylor expanded in phi1 around 0
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-outN/A
lower-*.f64N/A
lower-sin.f64N/A
lower-fma.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6489.2
Applied rewrites89.2%
if 0.044999999999999998 < phi1 Initial program 82.3%
lift-+.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6482.3
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6482.3
Applied rewrites82.3%
Final simplification86.6%
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 -2.6e-21)
(fma
(* PI 0.5)
R
(* (asin (fma (cos phi2) (* (cos phi1) t_0) t_1)) (- R)))
(if (<= phi1 0.0155)
(*
R
(acos
(+
t_1
(*
(fma -0.5 (* phi1 phi1) 1.0)
(*
(cos phi2)
(fma
(cos lambda1)
(cos lambda2)
(* (sin lambda2) (sin lambda1))))))))
(*
R
(acos
(fma (sin phi2) (sin phi1) (* (cos phi1) (* (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 = cos((lambda1 - lambda2));
double t_1 = sin(phi1) * sin(phi2);
double tmp;
if (phi1 <= -2.6e-21) {
tmp = fma((((double) M_PI) * 0.5), R, (asin(fma(cos(phi2), (cos(phi1) * t_0), t_1)) * -R));
} else if (phi1 <= 0.0155) {
tmp = R * acos((t_1 + (fma(-0.5, (phi1 * phi1), 1.0) * (cos(phi2) * fma(cos(lambda1), cos(lambda2), (sin(lambda2) * sin(lambda1)))))));
} else {
tmp = R * acos(fma(sin(phi2), sin(phi1), (cos(phi1) * (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 = cos(Float64(lambda1 - lambda2)) t_1 = Float64(sin(phi1) * sin(phi2)) tmp = 0.0 if (phi1 <= -2.6e-21) tmp = fma(Float64(pi * 0.5), R, Float64(asin(fma(cos(phi2), Float64(cos(phi1) * t_0), t_1)) * Float64(-R))); elseif (phi1 <= 0.0155) tmp = Float64(R * acos(Float64(t_1 + Float64(fma(-0.5, Float64(phi1 * phi1), 1.0) * Float64(cos(phi2) * fma(cos(lambda1), cos(lambda2), Float64(sin(lambda2) * sin(lambda1)))))))); else tmp = Float64(R * acos(fma(sin(phi2), sin(phi1), Float64(cos(phi1) * Float64(cos(phi2) * t_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[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[phi1, -2.6e-21], N[(N[(Pi * 0.5), $MachinePrecision] * R + N[(N[ArcSin[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * t$95$0), $MachinePrecision] + t$95$1), $MachinePrecision]], $MachinePrecision] * (-R)), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 0.0155], N[(R * N[ArcCos[N[(t$95$1 + N[(N[(-0.5 * N[(phi1 * phi1), $MachinePrecision] + 1.0), $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda2], $MachinePrecision] * N[Sin[lambda1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Sin[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision] + N[(N[Cos[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * t$95$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 := \cos \left(\lambda_1 - \lambda_2\right)\\
t_1 := \sin \phi_1 \cdot \sin \phi_2\\
\mathbf{if}\;\phi_1 \leq -2.6 \cdot 10^{-21}:\\
\;\;\;\;\mathsf{fma}\left(\pi \cdot 0.5, R, \sin^{-1} \left(\mathsf{fma}\left(\cos \phi_2, \cos \phi_1 \cdot t\_0, t\_1\right)\right) \cdot \left(-R\right)\right)\\
\mathbf{elif}\;\phi_1 \leq 0.0155:\\
\;\;\;\;R \cdot \cos^{-1} \left(t\_1 + \mathsf{fma}\left(-0.5, \phi_1 \cdot \phi_1, 1\right) \cdot \left(\cos \phi_2 \cdot \mathsf{fma}\left(\cos \lambda_1, \cos \lambda_2, \sin \lambda_2 \cdot \sin \lambda_1\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\sin \phi_2, \sin \phi_1, \cos \phi_1 \cdot \left(\cos \phi_2 \cdot t\_0\right)\right)\right)\\
\end{array}
\end{array}
if phi1 < -2.60000000000000017e-21Initial program 86.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6486.4
Applied rewrites86.4%
lift-cos.f64N/A
lift--.f64N/A
cos-diffN/A
lift-cos.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-sin.f64N/A
*-commutativeN/A
+-commutativeN/A
lift-fma.f6499.1
Applied rewrites99.1%
Applied rewrites86.4%
if -2.60000000000000017e-21 < phi1 < 0.0155Initial program 69.7%
lift-cos.f64N/A
lift--.f64N/A
cos-diffN/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-sin.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-cos.f6489.2
Applied rewrites89.2%
Taylor expanded in phi1 around 0
associate-*r*N/A
distribute-lft1-inN/A
lower-*.f64N/A
lower-fma.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-fma.f64N/A
lower-cos.f64N/A
lower-cos.f64N/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sin.f6489.2
Applied rewrites89.2%
if 0.0155 < phi1 Initial program 82.3%
lift-+.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6482.3
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6482.3
Applied rewrites82.3%
Final simplification86.6%
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.6e-21)
(fma
(* PI 0.5)
R
(*
(asin (fma (cos phi2) (* (cos phi1) t_0) (* (sin phi1) (sin phi2))))
(- R)))
(if (<= phi1 0.0155)
(*
R
(acos
(+
(* phi1 (sin phi2))
(*
(fma (sin lambda2) (sin lambda1) (* (cos lambda1) (cos lambda2)))
(* (cos phi2) (cos phi1))))))
(*
R
(acos
(fma (sin phi2) (sin phi1) (* (cos phi1) (* (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 = cos((lambda1 - lambda2));
double tmp;
if (phi1 <= -2.6e-21) {
tmp = fma((((double) M_PI) * 0.5), R, (asin(fma(cos(phi2), (cos(phi1) * t_0), (sin(phi1) * sin(phi2)))) * -R));
} else if (phi1 <= 0.0155) {
tmp = R * acos(((phi1 * sin(phi2)) + (fma(sin(lambda2), sin(lambda1), (cos(lambda1) * cos(lambda2))) * (cos(phi2) * cos(phi1)))));
} else {
tmp = R * acos(fma(sin(phi2), sin(phi1), (cos(phi1) * (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 = cos(Float64(lambda1 - lambda2)) tmp = 0.0 if (phi1 <= -2.6e-21) tmp = fma(Float64(pi * 0.5), R, Float64(asin(fma(cos(phi2), Float64(cos(phi1) * t_0), Float64(sin(phi1) * sin(phi2)))) * Float64(-R))); elseif (phi1 <= 0.0155) tmp = Float64(R * acos(Float64(Float64(phi1 * sin(phi2)) + Float64(fma(sin(lambda2), sin(lambda1), Float64(cos(lambda1) * cos(lambda2))) * Float64(cos(phi2) * cos(phi1)))))); else tmp = Float64(R * acos(fma(sin(phi2), sin(phi1), Float64(cos(phi1) * Float64(cos(phi2) * t_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[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[phi1, -2.6e-21], N[(N[(Pi * 0.5), $MachinePrecision] * R + N[(N[ArcSin[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * t$95$0), $MachinePrecision] + N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * (-R)), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 0.0155], N[(R * N[ArcCos[N[(N[(phi1 * N[Sin[phi2], $MachinePrecision]), $MachinePrecision] + N[(N[(N[Sin[lambda2], $MachinePrecision] * N[Sin[lambda1], $MachinePrecision] + N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Sin[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision] + N[(N[Cos[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * t$95$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 := \cos \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_1 \leq -2.6 \cdot 10^{-21}:\\
\;\;\;\;\mathsf{fma}\left(\pi \cdot 0.5, R, \sin^{-1} \left(\mathsf{fma}\left(\cos \phi_2, \cos \phi_1 \cdot t\_0, \sin \phi_1 \cdot \sin \phi_2\right)\right) \cdot \left(-R\right)\right)\\
\mathbf{elif}\;\phi_1 \leq 0.0155:\\
\;\;\;\;R \cdot \cos^{-1} \left(\phi_1 \cdot \sin \phi_2 + \mathsf{fma}\left(\sin \lambda_2, \sin \lambda_1, \cos \lambda_1 \cdot \cos \lambda_2\right) \cdot \left(\cos \phi_2 \cdot \cos \phi_1\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\sin \phi_2, \sin \phi_1, \cos \phi_1 \cdot \left(\cos \phi_2 \cdot t\_0\right)\right)\right)\\
\end{array}
\end{array}
if phi1 < -2.60000000000000017e-21Initial program 86.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6486.4
Applied rewrites86.4%
lift-cos.f64N/A
lift--.f64N/A
cos-diffN/A
lift-cos.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-sin.f64N/A
*-commutativeN/A
+-commutativeN/A
lift-fma.f6499.1
Applied rewrites99.1%
Applied rewrites86.4%
if -2.60000000000000017e-21 < phi1 < 0.0155Initial program 69.7%
lift-cos.f64N/A
lift--.f64N/A
cos-diffN/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-sin.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-cos.f6489.2
Applied rewrites89.2%
Taylor expanded in phi1 around 0
lower-*.f64N/A
lower-sin.f6489.2
Applied rewrites89.2%
if 0.0155 < phi1 Initial program 82.3%
lift-+.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6482.3
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6482.3
Applied rewrites82.3%
Final simplification86.6%
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.6e-21)
(fma
(* PI 0.5)
R
(*
(asin (fma (cos phi2) (* (cos phi1) t_0) (* (sin phi1) (sin phi2))))
(- R)))
(if (<= phi1 0.0155)
(*
R
(acos
(fma
(*
(cos phi2)
(fma (sin lambda2) (sin lambda1) (* (cos lambda1) (cos lambda2))))
(cos phi1)
(* phi1 (sin phi2)))))
(*
R
(acos
(fma (sin phi2) (sin phi1) (* (cos phi1) (* (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 = cos((lambda1 - lambda2));
double tmp;
if (phi1 <= -2.6e-21) {
tmp = fma((((double) M_PI) * 0.5), R, (asin(fma(cos(phi2), (cos(phi1) * t_0), (sin(phi1) * sin(phi2)))) * -R));
} else if (phi1 <= 0.0155) {
tmp = R * acos(fma((cos(phi2) * fma(sin(lambda2), sin(lambda1), (cos(lambda1) * cos(lambda2)))), cos(phi1), (phi1 * sin(phi2))));
} else {
tmp = R * acos(fma(sin(phi2), sin(phi1), (cos(phi1) * (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 = cos(Float64(lambda1 - lambda2)) tmp = 0.0 if (phi1 <= -2.6e-21) tmp = fma(Float64(pi * 0.5), R, Float64(asin(fma(cos(phi2), Float64(cos(phi1) * t_0), Float64(sin(phi1) * sin(phi2)))) * Float64(-R))); elseif (phi1 <= 0.0155) tmp = Float64(R * acos(fma(Float64(cos(phi2) * fma(sin(lambda2), sin(lambda1), Float64(cos(lambda1) * cos(lambda2)))), cos(phi1), Float64(phi1 * sin(phi2))))); else tmp = Float64(R * acos(fma(sin(phi2), sin(phi1), Float64(cos(phi1) * Float64(cos(phi2) * t_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[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[phi1, -2.6e-21], N[(N[(Pi * 0.5), $MachinePrecision] * R + N[(N[ArcSin[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * t$95$0), $MachinePrecision] + N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * (-R)), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 0.0155], N[(R * N[ArcCos[N[(N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[lambda2], $MachinePrecision] * N[Sin[lambda1], $MachinePrecision] + N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision] + N[(phi1 * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Sin[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision] + N[(N[Cos[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * t$95$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 := \cos \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_1 \leq -2.6 \cdot 10^{-21}:\\
\;\;\;\;\mathsf{fma}\left(\pi \cdot 0.5, R, \sin^{-1} \left(\mathsf{fma}\left(\cos \phi_2, \cos \phi_1 \cdot t\_0, \sin \phi_1 \cdot \sin \phi_2\right)\right) \cdot \left(-R\right)\right)\\
\mathbf{elif}\;\phi_1 \leq 0.0155:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\cos \phi_2 \cdot \mathsf{fma}\left(\sin \lambda_2, \sin \lambda_1, \cos \lambda_1 \cdot \cos \lambda_2\right), \cos \phi_1, \phi_1 \cdot \sin \phi_2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\sin \phi_2, \sin \phi_1, \cos \phi_1 \cdot \left(\cos \phi_2 \cdot t\_0\right)\right)\right)\\
\end{array}
\end{array}
if phi1 < -2.60000000000000017e-21Initial program 86.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6486.4
Applied rewrites86.4%
lift-cos.f64N/A
lift--.f64N/A
cos-diffN/A
lift-cos.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-sin.f64N/A
*-commutativeN/A
+-commutativeN/A
lift-fma.f6499.1
Applied rewrites99.1%
Applied rewrites86.4%
if -2.60000000000000017e-21 < phi1 < 0.0155Initial program 69.7%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6469.7
Applied rewrites69.7%
lift-cos.f64N/A
lift--.f64N/A
cos-diffN/A
lift-cos.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-sin.f64N/A
*-commutativeN/A
+-commutativeN/A
lift-fma.f6489.2
Applied rewrites89.2%
Taylor expanded in phi1 around 0
lower-*.f64N/A
lower-sin.f6489.2
Applied rewrites89.2%
if 0.0155 < phi1 Initial program 82.3%
lift-+.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6482.3
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6482.3
Applied rewrites82.3%
Final simplification86.6%
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.6e-21)
(fma
(* PI 0.5)
R
(*
(asin (fma (cos phi2) (* (cos phi1) t_0) (* (sin phi1) (sin phi2))))
(- R)))
(if (<= phi1 0.0155)
(*
R
(acos
(fma
phi1
(sin phi2)
(*
(fma -0.5 (* phi1 phi1) 1.0)
(*
(cos phi2)
(fma
(cos lambda2)
(cos lambda1)
(* (sin lambda2) (sin lambda1))))))))
(*
R
(acos
(fma (sin phi2) (sin phi1) (* (cos phi1) (* (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 = cos((lambda1 - lambda2));
double tmp;
if (phi1 <= -2.6e-21) {
tmp = fma((((double) M_PI) * 0.5), R, (asin(fma(cos(phi2), (cos(phi1) * t_0), (sin(phi1) * sin(phi2)))) * -R));
} else if (phi1 <= 0.0155) {
tmp = R * acos(fma(phi1, sin(phi2), (fma(-0.5, (phi1 * phi1), 1.0) * (cos(phi2) * fma(cos(lambda2), cos(lambda1), (sin(lambda2) * sin(lambda1)))))));
} else {
tmp = R * acos(fma(sin(phi2), sin(phi1), (cos(phi1) * (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 = cos(Float64(lambda1 - lambda2)) tmp = 0.0 if (phi1 <= -2.6e-21) tmp = fma(Float64(pi * 0.5), R, Float64(asin(fma(cos(phi2), Float64(cos(phi1) * t_0), Float64(sin(phi1) * sin(phi2)))) * Float64(-R))); elseif (phi1 <= 0.0155) tmp = Float64(R * acos(fma(phi1, sin(phi2), Float64(fma(-0.5, Float64(phi1 * phi1), 1.0) * Float64(cos(phi2) * fma(cos(lambda2), cos(lambda1), Float64(sin(lambda2) * sin(lambda1)))))))); else tmp = Float64(R * acos(fma(sin(phi2), sin(phi1), Float64(cos(phi1) * Float64(cos(phi2) * t_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[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[phi1, -2.6e-21], N[(N[(Pi * 0.5), $MachinePrecision] * R + N[(N[ArcSin[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * t$95$0), $MachinePrecision] + N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * (-R)), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 0.0155], N[(R * N[ArcCos[N[(phi1 * N[Sin[phi2], $MachinePrecision] + N[(N[(-0.5 * N[(phi1 * phi1), $MachinePrecision] + 1.0), $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision] + N[(N[Sin[lambda2], $MachinePrecision] * N[Sin[lambda1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Sin[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision] + N[(N[Cos[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * t$95$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 := \cos \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_1 \leq -2.6 \cdot 10^{-21}:\\
\;\;\;\;\mathsf{fma}\left(\pi \cdot 0.5, R, \sin^{-1} \left(\mathsf{fma}\left(\cos \phi_2, \cos \phi_1 \cdot t\_0, \sin \phi_1 \cdot \sin \phi_2\right)\right) \cdot \left(-R\right)\right)\\
\mathbf{elif}\;\phi_1 \leq 0.0155:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\phi_1, \sin \phi_2, \mathsf{fma}\left(-0.5, \phi_1 \cdot \phi_1, 1\right) \cdot \left(\cos \phi_2 \cdot \mathsf{fma}\left(\cos \lambda_2, \cos \lambda_1, \sin \lambda_2 \cdot \sin \lambda_1\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\sin \phi_2, \sin \phi_1, \cos \phi_1 \cdot \left(\cos \phi_2 \cdot t\_0\right)\right)\right)\\
\end{array}
\end{array}
if phi1 < -2.60000000000000017e-21Initial program 86.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6486.4
Applied rewrites86.4%
lift-cos.f64N/A
lift--.f64N/A
cos-diffN/A
lift-cos.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-sin.f64N/A
*-commutativeN/A
+-commutativeN/A
lift-fma.f6499.1
Applied rewrites99.1%
Applied rewrites86.4%
if -2.60000000000000017e-21 < phi1 < 0.0155Initial program 69.7%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6469.7
Applied rewrites69.7%
lift-cos.f64N/A
lift--.f64N/A
cos-diffN/A
lift-cos.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-sin.f64N/A
*-commutativeN/A
+-commutativeN/A
lift-fma.f6489.2
Applied rewrites89.2%
Taylor expanded in phi1 around 0
distribute-lft-inN/A
associate-+l+N/A
lower-fma.f64N/A
lower-sin.f64N/A
Applied rewrites89.2%
if 0.0155 < phi1 Initial program 82.3%
lift-+.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6482.3
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6482.3
Applied rewrites82.3%
Final simplification86.6%
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.6e-21)
(fma
(* PI 0.5)
R
(*
(asin (fma (cos phi2) (* (cos phi1) t_0) (* (sin phi1) (sin phi2))))
(- R)))
(if (<= phi1 0.0155)
(*
R
(acos
(fma
phi1
(sin phi2)
(*
(cos phi2)
(fma
(cos lambda2)
(cos lambda1)
(* (sin lambda2) (sin lambda1)))))))
(*
R
(acos
(fma (sin phi2) (sin phi1) (* (cos phi1) (* (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 = cos((lambda1 - lambda2));
double tmp;
if (phi1 <= -2.6e-21) {
tmp = fma((((double) M_PI) * 0.5), R, (asin(fma(cos(phi2), (cos(phi1) * t_0), (sin(phi1) * sin(phi2)))) * -R));
} else if (phi1 <= 0.0155) {
tmp = R * acos(fma(phi1, sin(phi2), (cos(phi2) * fma(cos(lambda2), cos(lambda1), (sin(lambda2) * sin(lambda1))))));
} else {
tmp = R * acos(fma(sin(phi2), sin(phi1), (cos(phi1) * (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 = cos(Float64(lambda1 - lambda2)) tmp = 0.0 if (phi1 <= -2.6e-21) tmp = fma(Float64(pi * 0.5), R, Float64(asin(fma(cos(phi2), Float64(cos(phi1) * t_0), Float64(sin(phi1) * sin(phi2)))) * Float64(-R))); elseif (phi1 <= 0.0155) tmp = Float64(R * acos(fma(phi1, sin(phi2), Float64(cos(phi2) * fma(cos(lambda2), cos(lambda1), Float64(sin(lambda2) * sin(lambda1))))))); else tmp = Float64(R * acos(fma(sin(phi2), sin(phi1), Float64(cos(phi1) * Float64(cos(phi2) * t_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[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[phi1, -2.6e-21], N[(N[(Pi * 0.5), $MachinePrecision] * R + N[(N[ArcSin[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * t$95$0), $MachinePrecision] + N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * (-R)), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 0.0155], N[(R * N[ArcCos[N[(phi1 * N[Sin[phi2], $MachinePrecision] + N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[lambda2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision] + N[(N[Sin[lambda2], $MachinePrecision] * N[Sin[lambda1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Sin[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision] + N[(N[Cos[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * t$95$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 := \cos \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_1 \leq -2.6 \cdot 10^{-21}:\\
\;\;\;\;\mathsf{fma}\left(\pi \cdot 0.5, R, \sin^{-1} \left(\mathsf{fma}\left(\cos \phi_2, \cos \phi_1 \cdot t\_0, \sin \phi_1 \cdot \sin \phi_2\right)\right) \cdot \left(-R\right)\right)\\
\mathbf{elif}\;\phi_1 \leq 0.0155:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\phi_1, \sin \phi_2, \cos \phi_2 \cdot \mathsf{fma}\left(\cos \lambda_2, \cos \lambda_1, \sin \lambda_2 \cdot \sin \lambda_1\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\sin \phi_2, \sin \phi_1, \cos \phi_1 \cdot \left(\cos \phi_2 \cdot t\_0\right)\right)\right)\\
\end{array}
\end{array}
if phi1 < -2.60000000000000017e-21Initial program 86.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6486.4
Applied rewrites86.4%
lift-cos.f64N/A
lift--.f64N/A
cos-diffN/A
lift-cos.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-sin.f64N/A
*-commutativeN/A
+-commutativeN/A
lift-fma.f6499.1
Applied rewrites99.1%
Applied rewrites86.4%
if -2.60000000000000017e-21 < phi1 < 0.0155Initial program 69.7%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6469.7
Applied rewrites69.7%
lift-cos.f64N/A
lift--.f64N/A
cos-diffN/A
lift-cos.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-sin.f64N/A
*-commutativeN/A
+-commutativeN/A
lift-fma.f6489.2
Applied rewrites89.2%
Taylor expanded in phi1 around 0
lower-fma.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
cos-negN/A
*-commutativeN/A
lower-fma.f64N/A
lower-cos.f64N/A
cos-negN/A
lower-cos.f64N/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sin.f6489.2
Applied rewrites89.2%
if 0.0155 < phi1 Initial program 82.3%
lift-+.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6482.3
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6482.3
Applied rewrites82.3%
Final simplification86.6%
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.6e-21)
(fma
(* PI 0.5)
R
(*
(asin (fma (cos phi2) (* (cos phi1) t_0) (* (sin phi1) (sin phi2))))
(- R)))
(if (<= phi1 0.0155)
(*
R
(acos
(fma
(cos phi2)
(fma (cos lambda1) (cos lambda2) (* (sin lambda2) (sin lambda1)))
(* phi1 (sin phi2)))))
(*
R
(acos
(fma (sin phi2) (sin phi1) (* (cos phi1) (* (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 = cos((lambda1 - lambda2));
double tmp;
if (phi1 <= -2.6e-21) {
tmp = fma((((double) M_PI) * 0.5), R, (asin(fma(cos(phi2), (cos(phi1) * t_0), (sin(phi1) * sin(phi2)))) * -R));
} else if (phi1 <= 0.0155) {
tmp = R * acos(fma(cos(phi2), fma(cos(lambda1), cos(lambda2), (sin(lambda2) * sin(lambda1))), (phi1 * sin(phi2))));
} else {
tmp = R * acos(fma(sin(phi2), sin(phi1), (cos(phi1) * (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 = cos(Float64(lambda1 - lambda2)) tmp = 0.0 if (phi1 <= -2.6e-21) tmp = fma(Float64(pi * 0.5), R, Float64(asin(fma(cos(phi2), Float64(cos(phi1) * t_0), Float64(sin(phi1) * sin(phi2)))) * Float64(-R))); elseif (phi1 <= 0.0155) tmp = Float64(R * acos(fma(cos(phi2), fma(cos(lambda1), cos(lambda2), Float64(sin(lambda2) * sin(lambda1))), Float64(phi1 * sin(phi2))))); else tmp = Float64(R * acos(fma(sin(phi2), sin(phi1), Float64(cos(phi1) * Float64(cos(phi2) * t_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[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[phi1, -2.6e-21], N[(N[(Pi * 0.5), $MachinePrecision] * R + N[(N[ArcSin[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * t$95$0), $MachinePrecision] + N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * (-R)), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 0.0155], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda2], $MachinePrecision] * N[Sin[lambda1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(phi1 * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Sin[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision] + N[(N[Cos[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * t$95$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 := \cos \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_1 \leq -2.6 \cdot 10^{-21}:\\
\;\;\;\;\mathsf{fma}\left(\pi \cdot 0.5, R, \sin^{-1} \left(\mathsf{fma}\left(\cos \phi_2, \cos \phi_1 \cdot t\_0, \sin \phi_1 \cdot \sin \phi_2\right)\right) \cdot \left(-R\right)\right)\\
\mathbf{elif}\;\phi_1 \leq 0.0155:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\cos \phi_2, \mathsf{fma}\left(\cos \lambda_1, \cos \lambda_2, \sin \lambda_2 \cdot \sin \lambda_1\right), \phi_1 \cdot \sin \phi_2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\sin \phi_2, \sin \phi_1, \cos \phi_1 \cdot \left(\cos \phi_2 \cdot t\_0\right)\right)\right)\\
\end{array}
\end{array}
if phi1 < -2.60000000000000017e-21Initial program 86.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6486.4
Applied rewrites86.4%
lift-cos.f64N/A
lift--.f64N/A
cos-diffN/A
lift-cos.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-sin.f64N/A
*-commutativeN/A
+-commutativeN/A
lift-fma.f6499.1
Applied rewrites99.1%
Applied rewrites86.4%
if -2.60000000000000017e-21 < phi1 < 0.0155Initial program 69.7%
lift-cos.f64N/A
lift--.f64N/A
cos-diffN/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-sin.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-cos.f6489.2
Applied rewrites89.2%
Taylor expanded in phi1 around 0
+-commutativeN/A
lower-fma.f64N/A
lower-cos.f64N/A
lower-fma.f64N/A
lower-cos.f64N/A
lower-cos.f64N/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-sin.f6489.2
Applied rewrites89.2%
if 0.0155 < phi1 Initial program 82.3%
lift-+.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6482.3
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6482.3
Applied rewrites82.3%
Final simplification86.6%
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.6e-21)
(fma
(* PI 0.5)
R
(*
(asin (fma (cos phi2) (* (cos phi1) t_0) (* (sin phi1) (sin phi2))))
(- R)))
(if (<= phi1 3.7e-18)
(*
R
(acos
(*
(cos phi2)
(fma (sin lambda2) (sin lambda1) (* (cos lambda1) (cos lambda2))))))
(*
R
(acos
(fma (sin phi2) (sin phi1) (* (cos phi1) (* (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 = cos((lambda1 - lambda2));
double tmp;
if (phi1 <= -2.6e-21) {
tmp = fma((((double) M_PI) * 0.5), R, (asin(fma(cos(phi2), (cos(phi1) * t_0), (sin(phi1) * sin(phi2)))) * -R));
} else if (phi1 <= 3.7e-18) {
tmp = R * acos((cos(phi2) * fma(sin(lambda2), sin(lambda1), (cos(lambda1) * cos(lambda2)))));
} else {
tmp = R * acos(fma(sin(phi2), sin(phi1), (cos(phi1) * (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 = cos(Float64(lambda1 - lambda2)) tmp = 0.0 if (phi1 <= -2.6e-21) tmp = fma(Float64(pi * 0.5), R, Float64(asin(fma(cos(phi2), Float64(cos(phi1) * t_0), Float64(sin(phi1) * sin(phi2)))) * Float64(-R))); elseif (phi1 <= 3.7e-18) tmp = Float64(R * acos(Float64(cos(phi2) * fma(sin(lambda2), sin(lambda1), Float64(cos(lambda1) * cos(lambda2)))))); else tmp = Float64(R * acos(fma(sin(phi2), sin(phi1), Float64(cos(phi1) * Float64(cos(phi2) * t_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[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[phi1, -2.6e-21], N[(N[(Pi * 0.5), $MachinePrecision] * R + N[(N[ArcSin[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * t$95$0), $MachinePrecision] + N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * (-R)), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 3.7e-18], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[lambda2], $MachinePrecision] * N[Sin[lambda1], $MachinePrecision] + N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Sin[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision] + N[(N[Cos[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * t$95$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 := \cos \left(\lambda_1 - \lambda_2\right)\\
\mathbf{if}\;\phi_1 \leq -2.6 \cdot 10^{-21}:\\
\;\;\;\;\mathsf{fma}\left(\pi \cdot 0.5, R, \sin^{-1} \left(\mathsf{fma}\left(\cos \phi_2, \cos \phi_1 \cdot t\_0, \sin \phi_1 \cdot \sin \phi_2\right)\right) \cdot \left(-R\right)\right)\\
\mathbf{elif}\;\phi_1 \leq 3.7 \cdot 10^{-18}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_2 \cdot \mathsf{fma}\left(\sin \lambda_2, \sin \lambda_1, \cos \lambda_1 \cdot \cos \lambda_2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\sin \phi_2, \sin \phi_1, \cos \phi_1 \cdot \left(\cos \phi_2 \cdot t\_0\right)\right)\right)\\
\end{array}
\end{array}
if phi1 < -2.60000000000000017e-21Initial program 86.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6486.4
Applied rewrites86.4%
lift-cos.f64N/A
lift--.f64N/A
cos-diffN/A
lift-cos.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-sin.f64N/A
*-commutativeN/A
+-commutativeN/A
lift-fma.f6499.1
Applied rewrites99.1%
Applied rewrites86.4%
if -2.60000000000000017e-21 < phi1 < 3.7000000000000003e-18Initial program 69.0%
Taylor expanded in phi1 around 0
lower-*.f64N/A
lower-cos.f64N/A
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
cos-negN/A
lower-cos.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f6469.0
Applied rewrites69.0%
Applied rewrites88.9%
if 3.7000000000000003e-18 < phi1 Initial program 83.0%
lift-+.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6483.0
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6483.0
Applied rewrites83.0%
Final simplification86.6%
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.72e-9)
(*
R
(acos
(fma
(sin phi2)
(sin phi1)
(* (cos phi2) (* (cos phi1) (cos (- lambda2 lambda1)))))))
(if (<= phi1 3.7e-18)
(*
R
(acos
(*
(cos phi2)
(fma (sin lambda2) (sin lambda1) (* (cos lambda1) (cos lambda2))))))
(*
R
(acos
(fma
(sin phi2)
(sin phi1)
(* (cos phi1) (* (cos phi2) (cos (- lambda1 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.72e-9) {
tmp = R * acos(fma(sin(phi2), sin(phi1), (cos(phi2) * (cos(phi1) * cos((lambda2 - lambda1))))));
} else if (phi1 <= 3.7e-18) {
tmp = R * acos((cos(phi2) * fma(sin(lambda2), sin(lambda1), (cos(lambda1) * cos(lambda2)))));
} else {
tmp = R * acos(fma(sin(phi2), sin(phi1), (cos(phi1) * (cos(phi2) * cos((lambda1 - 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.72e-9) tmp = Float64(R * acos(fma(sin(phi2), sin(phi1), Float64(cos(phi2) * Float64(cos(phi1) * cos(Float64(lambda2 - lambda1))))))); elseif (phi1 <= 3.7e-18) tmp = Float64(R * acos(Float64(cos(phi2) * fma(sin(lambda2), sin(lambda1), Float64(cos(lambda1) * cos(lambda2)))))); else tmp = Float64(R * acos(fma(sin(phi2), sin(phi1), Float64(cos(phi1) * Float64(cos(phi2) * cos(Float64(lambda1 - 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[LessEqual[phi1, -1.72e-9], N[(R * N[ArcCos[N[(N[Sin[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision] + N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[phi1, 3.7e-18], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[lambda2], $MachinePrecision] * N[Sin[lambda1], $MachinePrecision] + N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Sin[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision] + N[(N[Cos[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $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}
\mathbf{if}\;\phi_1 \leq -1.72 \cdot 10^{-9}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\sin \phi_2, \sin \phi_1, \cos \phi_2 \cdot \left(\cos \phi_1 \cdot \cos \left(\lambda_2 - \lambda_1\right)\right)\right)\right)\\
\mathbf{elif}\;\phi_1 \leq 3.7 \cdot 10^{-18}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_2 \cdot \mathsf{fma}\left(\sin \lambda_2, \sin \lambda_1, \cos \lambda_1 \cdot \cos \lambda_2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\sin \phi_2, \sin \phi_1, \cos \phi_1 \cdot \left(\cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)\right)\right)\\
\end{array}
\end{array}
if phi1 < -1.72000000000000006e-9Initial program 86.2%
lift-cos.f64N/A
lift--.f64N/A
cos-diffN/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-sin.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-cos.f6499.1
Applied rewrites99.1%
Applied rewrites86.2%
if -1.72000000000000006e-9 < phi1 < 3.7000000000000003e-18Initial program 69.2%
Taylor expanded in phi1 around 0
lower-*.f64N/A
lower-cos.f64N/A
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
cos-negN/A
lower-cos.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f6469.2
Applied rewrites69.2%
Applied rewrites89.0%
if 3.7000000000000003e-18 < phi1 Initial program 83.0%
lift-+.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6483.0
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6483.0
Applied rewrites83.0%
Final simplification86.6%
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
(fma
(sin phi2)
(sin phi1)
(* (cos phi1) (* (cos phi2) (cos (- lambda1 lambda2)))))))))
(if (<= phi1 -1.72e-9)
t_0
(if (<= phi1 3.7e-18)
(*
R
(acos
(*
(cos phi2)
(fma (sin lambda2) (sin lambda1) (* (cos lambda1) (cos lambda2))))))
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(fma(sin(phi2), sin(phi1), (cos(phi1) * (cos(phi2) * cos((lambda1 - lambda2))))));
double tmp;
if (phi1 <= -1.72e-9) {
tmp = t_0;
} else if (phi1 <= 3.7e-18) {
tmp = R * acos((cos(phi2) * fma(sin(lambda2), sin(lambda1), (cos(lambda1) * cos(lambda2)))));
} 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(fma(sin(phi2), sin(phi1), Float64(cos(phi1) * Float64(cos(phi2) * cos(Float64(lambda1 - lambda2))))))) tmp = 0.0 if (phi1 <= -1.72e-9) tmp = t_0; elseif (phi1 <= 3.7e-18) tmp = Float64(R * acos(Float64(cos(phi2) * fma(sin(lambda2), sin(lambda1), Float64(cos(lambda1) * cos(lambda2)))))); else tmp = t_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[(R * N[ArcCos[N[(N[Sin[phi2], $MachinePrecision] * N[Sin[phi1], $MachinePrecision] + N[(N[Cos[phi1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[phi1, -1.72e-9], t$95$0, If[LessEqual[phi1, 3.7e-18], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[lambda2], $MachinePrecision] * N[Sin[lambda1], $MachinePrecision] + N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $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(\mathsf{fma}\left(\sin \phi_2, \sin \phi_1, \cos \phi_1 \cdot \left(\cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)\right)\right)\\
\mathbf{if}\;\phi_1 \leq -1.72 \cdot 10^{-9}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;\phi_1 \leq 3.7 \cdot 10^{-18}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_2 \cdot \mathsf{fma}\left(\sin \lambda_2, \sin \lambda_1, \cos \lambda_1 \cdot \cos \lambda_2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if phi1 < -1.72000000000000006e-9 or 3.7000000000000003e-18 < phi1 Initial program 84.5%
lift-+.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6484.5
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6484.5
Applied rewrites84.5%
if -1.72000000000000006e-9 < phi1 < 3.7000000000000003e-18Initial program 69.2%
Taylor expanded in phi1 around 0
lower-*.f64N/A
lower-cos.f64N/A
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
cos-negN/A
lower-cos.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f6469.2
Applied rewrites69.2%
Applied rewrites89.0%
Final simplification86.6%
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))))
(if (<= lambda2 -6.7e-6)
(*
R
(acos
(*
(cos phi1)
(fma (cos lambda1) (cos lambda2) (* (sin lambda2) (sin lambda1))))))
(if (<= lambda2 9e-5)
(* R (acos (fma (cos lambda1) (* (cos phi2) (cos phi1)) t_0)))
(* R (acos (fma (* (cos phi2) (cos lambda2)) (cos phi1) 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(phi1) * sin(phi2);
double tmp;
if (lambda2 <= -6.7e-6) {
tmp = R * acos((cos(phi1) * fma(cos(lambda1), cos(lambda2), (sin(lambda2) * sin(lambda1)))));
} else if (lambda2 <= 9e-5) {
tmp = R * acos(fma(cos(lambda1), (cos(phi2) * cos(phi1)), t_0));
} else {
tmp = R * acos(fma((cos(phi2) * cos(lambda2)), cos(phi1), 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(sin(phi1) * sin(phi2)) tmp = 0.0 if (lambda2 <= -6.7e-6) tmp = Float64(R * acos(Float64(cos(phi1) * fma(cos(lambda1), cos(lambda2), Float64(sin(lambda2) * sin(lambda1)))))); elseif (lambda2 <= 9e-5) tmp = Float64(R * acos(fma(cos(lambda1), Float64(cos(phi2) * cos(phi1)), t_0))); else tmp = Float64(R * acos(fma(Float64(cos(phi2) * cos(lambda2)), cos(phi1), t_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[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[lambda2, -6.7e-6], N[(R * N[ArcCos[N[(N[Cos[phi1], $MachinePrecision] * N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda2], $MachinePrecision] * N[Sin[lambda1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[lambda2, 9e-5], N[(R * N[ArcCos[N[(N[Cos[lambda1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[(N[Cos[phi2], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $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 \phi_1 \cdot \sin \phi_2\\
\mathbf{if}\;\lambda_2 \leq -6.7 \cdot 10^{-6}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_1 \cdot \mathsf{fma}\left(\cos \lambda_1, \cos \lambda_2, \sin \lambda_2 \cdot \sin \lambda_1\right)\right)\\
\mathbf{elif}\;\lambda_2 \leq 9 \cdot 10^{-5}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\cos \lambda_1, \cos \phi_2 \cdot \cos \phi_1, t\_0\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\cos \phi_2 \cdot \cos \lambda_2, \cos \phi_1, t\_0\right)\right)\\
\end{array}
\end{array}
if lambda2 < -6.7e-6Initial program 62.7%
lift-cos.f64N/A
lift--.f64N/A
cos-diffN/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-sin.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-cos.f6498.7
Applied rewrites98.7%
Taylor expanded in phi2 around 0
*-commutativeN/A
lower-*.f64N/A
lower-fma.f64N/A
lower-cos.f64N/A
lower-cos.f64N/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sin.f64N/A
lower-cos.f6459.1
Applied rewrites59.1%
if -6.7e-6 < lambda2 < 9.00000000000000057e-5Initial program 90.3%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6490.3
Applied rewrites90.3%
Taylor expanded in lambda2 around 0
lower-fma.f64N/A
lower-cos.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-cos.f64N/A
lower-cos.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sin.f6490.4
Applied rewrites90.4%
if 9.00000000000000057e-5 < lambda2 Initial program 58.7%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6458.7
Applied rewrites58.7%
Taylor expanded in lambda1 around 0
cos-negN/A
lower-cos.f6459.0
Applied rewrites59.0%
Final simplification76.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))))
(if (<= lambda2 -6.7e-6)
(*
R
(acos
(*
(cos phi1)
(fma (cos lambda1) (cos lambda2) (* (sin lambda2) (sin lambda1))))))
(if (<= lambda2 9e-5)
(* R (acos (fma (cos lambda1) (* (cos phi2) (cos phi1)) t_0)))
(* R (acos (fma (cos phi2) (* (cos phi1) (cos lambda2)) 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(phi1) * sin(phi2);
double tmp;
if (lambda2 <= -6.7e-6) {
tmp = R * acos((cos(phi1) * fma(cos(lambda1), cos(lambda2), (sin(lambda2) * sin(lambda1)))));
} else if (lambda2 <= 9e-5) {
tmp = R * acos(fma(cos(lambda1), (cos(phi2) * cos(phi1)), t_0));
} else {
tmp = R * acos(fma(cos(phi2), (cos(phi1) * cos(lambda2)), 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(sin(phi1) * sin(phi2)) tmp = 0.0 if (lambda2 <= -6.7e-6) tmp = Float64(R * acos(Float64(cos(phi1) * fma(cos(lambda1), cos(lambda2), Float64(sin(lambda2) * sin(lambda1)))))); elseif (lambda2 <= 9e-5) tmp = Float64(R * acos(fma(cos(lambda1), Float64(cos(phi2) * cos(phi1)), t_0))); else tmp = Float64(R * acos(fma(cos(phi2), Float64(cos(phi1) * cos(lambda2)), t_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[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[lambda2, -6.7e-6], N[(R * N[ArcCos[N[(N[Cos[phi1], $MachinePrecision] * N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda2], $MachinePrecision] * N[Sin[lambda1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[lambda2, 9e-5], N[(R * N[ArcCos[N[(N[Cos[lambda1], $MachinePrecision] * N[(N[Cos[phi2], $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $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 \phi_1 \cdot \sin \phi_2\\
\mathbf{if}\;\lambda_2 \leq -6.7 \cdot 10^{-6}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_1 \cdot \mathsf{fma}\left(\cos \lambda_1, \cos \lambda_2, \sin \lambda_2 \cdot \sin \lambda_1\right)\right)\\
\mathbf{elif}\;\lambda_2 \leq 9 \cdot 10^{-5}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\cos \lambda_1, \cos \phi_2 \cdot \cos \phi_1, t\_0\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\cos \phi_2, \cos \phi_1 \cdot \cos \lambda_2, t\_0\right)\right)\\
\end{array}
\end{array}
if lambda2 < -6.7e-6Initial program 62.7%
lift-cos.f64N/A
lift--.f64N/A
cos-diffN/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-sin.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-cos.f6498.7
Applied rewrites98.7%
Taylor expanded in phi2 around 0
*-commutativeN/A
lower-*.f64N/A
lower-fma.f64N/A
lower-cos.f64N/A
lower-cos.f64N/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sin.f64N/A
lower-cos.f6459.1
Applied rewrites59.1%
if -6.7e-6 < lambda2 < 9.00000000000000057e-5Initial program 90.3%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6490.3
Applied rewrites90.3%
Taylor expanded in lambda2 around 0
lower-fma.f64N/A
lower-cos.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-cos.f64N/A
lower-cos.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sin.f6490.4
Applied rewrites90.4%
if 9.00000000000000057e-5 < lambda2 Initial program 58.7%
Taylor expanded in lambda1 around 0
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
lower-fma.f64N/A
lower-cos.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
cos-negN/A
lower-cos.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sin.f6459.0
Applied rewrites59.0%
Final simplification76.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))))
(if (<= lambda2 -6.7e-6)
(*
R
(acos
(*
(cos phi1)
(fma (cos lambda1) (cos lambda2) (* (sin lambda2) (sin lambda1))))))
(if (<= lambda2 9e-5)
(* R (acos (fma (cos phi2) (* (cos phi1) (cos lambda1)) t_0)))
(* R (acos (fma (cos phi2) (* (cos phi1) (cos lambda2)) 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(phi1) * sin(phi2);
double tmp;
if (lambda2 <= -6.7e-6) {
tmp = R * acos((cos(phi1) * fma(cos(lambda1), cos(lambda2), (sin(lambda2) * sin(lambda1)))));
} else if (lambda2 <= 9e-5) {
tmp = R * acos(fma(cos(phi2), (cos(phi1) * cos(lambda1)), t_0));
} else {
tmp = R * acos(fma(cos(phi2), (cos(phi1) * cos(lambda2)), 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(sin(phi1) * sin(phi2)) tmp = 0.0 if (lambda2 <= -6.7e-6) tmp = Float64(R * acos(Float64(cos(phi1) * fma(cos(lambda1), cos(lambda2), Float64(sin(lambda2) * sin(lambda1)))))); elseif (lambda2 <= 9e-5) tmp = Float64(R * acos(fma(cos(phi2), Float64(cos(phi1) * cos(lambda1)), t_0))); else tmp = Float64(R * acos(fma(cos(phi2), Float64(cos(phi1) * cos(lambda2)), t_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[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[lambda2, -6.7e-6], N[(R * N[ArcCos[N[(N[Cos[phi1], $MachinePrecision] * N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision] + N[(N[Sin[lambda2], $MachinePrecision] * N[Sin[lambda1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[lambda2, 9e-5], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $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 \phi_1 \cdot \sin \phi_2\\
\mathbf{if}\;\lambda_2 \leq -6.7 \cdot 10^{-6}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_1 \cdot \mathsf{fma}\left(\cos \lambda_1, \cos \lambda_2, \sin \lambda_2 \cdot \sin \lambda_1\right)\right)\\
\mathbf{elif}\;\lambda_2 \leq 9 \cdot 10^{-5}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\cos \phi_2, \cos \phi_1 \cdot \cos \lambda_1, t\_0\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\cos \phi_2, \cos \phi_1 \cdot \cos \lambda_2, t\_0\right)\right)\\
\end{array}
\end{array}
if lambda2 < -6.7e-6Initial program 62.7%
lift-cos.f64N/A
lift--.f64N/A
cos-diffN/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-sin.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-cos.f6498.7
Applied rewrites98.7%
Taylor expanded in phi2 around 0
*-commutativeN/A
lower-*.f64N/A
lower-fma.f64N/A
lower-cos.f64N/A
lower-cos.f64N/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sin.f64N/A
lower-cos.f6459.1
Applied rewrites59.1%
if -6.7e-6 < lambda2 < 9.00000000000000057e-5Initial program 90.3%
Taylor expanded in lambda2 around 0
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-cos.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-cos.f64N/A
lower-cos.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sin.f6490.3
Applied rewrites90.3%
if 9.00000000000000057e-5 < lambda2 Initial program 58.7%
Taylor expanded in lambda1 around 0
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
lower-fma.f64N/A
lower-cos.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
cos-negN/A
lower-cos.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sin.f6459.0
Applied rewrites59.0%
Final simplification76.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))))
(if (<= lambda2 -1.4e-5)
(*
R
(acos
(*
(cos phi2)
(fma (sin lambda2) (sin lambda1) (* (cos lambda1) (cos lambda2))))))
(if (<= lambda2 9e-5)
(* R (acos (fma (cos phi2) (* (cos phi1) (cos lambda1)) t_0)))
(* R (acos (fma (cos phi2) (* (cos phi1) (cos lambda2)) 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(phi1) * sin(phi2);
double tmp;
if (lambda2 <= -1.4e-5) {
tmp = R * acos((cos(phi2) * fma(sin(lambda2), sin(lambda1), (cos(lambda1) * cos(lambda2)))));
} else if (lambda2 <= 9e-5) {
tmp = R * acos(fma(cos(phi2), (cos(phi1) * cos(lambda1)), t_0));
} else {
tmp = R * acos(fma(cos(phi2), (cos(phi1) * cos(lambda2)), 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(sin(phi1) * sin(phi2)) tmp = 0.0 if (lambda2 <= -1.4e-5) tmp = Float64(R * acos(Float64(cos(phi2) * fma(sin(lambda2), sin(lambda1), Float64(cos(lambda1) * cos(lambda2)))))); elseif (lambda2 <= 9e-5) tmp = Float64(R * acos(fma(cos(phi2), Float64(cos(phi1) * cos(lambda1)), t_0))); else tmp = Float64(R * acos(fma(cos(phi2), Float64(cos(phi1) * cos(lambda2)), t_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[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[lambda2, -1.4e-5], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[lambda2], $MachinePrecision] * N[Sin[lambda1], $MachinePrecision] + N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[lambda2, 9e-5], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $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 \phi_1 \cdot \sin \phi_2\\
\mathbf{if}\;\lambda_2 \leq -1.4 \cdot 10^{-5}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_2 \cdot \mathsf{fma}\left(\sin \lambda_2, \sin \lambda_1, \cos \lambda_1 \cdot \cos \lambda_2\right)\right)\\
\mathbf{elif}\;\lambda_2 \leq 9 \cdot 10^{-5}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\cos \phi_2, \cos \phi_1 \cdot \cos \lambda_1, t\_0\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\cos \phi_2, \cos \phi_1 \cdot \cos \lambda_2, t\_0\right)\right)\\
\end{array}
\end{array}
if lambda2 < -1.39999999999999998e-5Initial program 62.7%
Taylor expanded in phi1 around 0
lower-*.f64N/A
lower-cos.f64N/A
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
cos-negN/A
lower-cos.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f6441.6
Applied rewrites41.6%
Applied rewrites64.9%
if -1.39999999999999998e-5 < lambda2 < 9.00000000000000057e-5Initial program 90.3%
Taylor expanded in lambda2 around 0
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-cos.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-cos.f64N/A
lower-cos.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sin.f6490.3
Applied rewrites90.3%
if 9.00000000000000057e-5 < lambda2 Initial program 58.7%
Taylor expanded in lambda1 around 0
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
lower-fma.f64N/A
lower-cos.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
cos-negN/A
lower-cos.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sin.f6459.0
Applied rewrites59.0%
Final simplification78.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
(*
R
(acos
(fma
(cos phi2)
(* (cos phi1) (cos lambda1))
(* (sin phi1) (sin phi2)))))))
(if (<= phi1 -4.6e-5)
t_0
(if (<= phi1 3.7e-18)
(*
R
(acos
(*
(cos phi2)
(fma (sin lambda2) (sin lambda1) (* (cos lambda1) (cos lambda2))))))
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(fma(cos(phi2), (cos(phi1) * cos(lambda1)), (sin(phi1) * sin(phi2))));
double tmp;
if (phi1 <= -4.6e-5) {
tmp = t_0;
} else if (phi1 <= 3.7e-18) {
tmp = R * acos((cos(phi2) * fma(sin(lambda2), sin(lambda1), (cos(lambda1) * cos(lambda2)))));
} 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(fma(cos(phi2), Float64(cos(phi1) * cos(lambda1)), Float64(sin(phi1) * sin(phi2))))) tmp = 0.0 if (phi1 <= -4.6e-5) tmp = t_0; elseif (phi1 <= 3.7e-18) tmp = Float64(R * acos(Float64(cos(phi2) * fma(sin(lambda2), sin(lambda1), Float64(cos(lambda1) * cos(lambda2)))))); else tmp = t_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[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision]), $MachinePrecision] + N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[phi1, -4.6e-5], t$95$0, If[LessEqual[phi1, 3.7e-18], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[lambda2], $MachinePrecision] * N[Sin[lambda1], $MachinePrecision] + N[(N[Cos[lambda1], $MachinePrecision] * N[Cos[lambda2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $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(\mathsf{fma}\left(\cos \phi_2, \cos \phi_1 \cdot \cos \lambda_1, \sin \phi_1 \cdot \sin \phi_2\right)\right)\\
\mathbf{if}\;\phi_1 \leq -4.6 \cdot 10^{-5}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;\phi_1 \leq 3.7 \cdot 10^{-18}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_2 \cdot \mathsf{fma}\left(\sin \lambda_2, \sin \lambda_1, \cos \lambda_1 \cdot \cos \lambda_2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if phi1 < -4.6e-5 or 3.7000000000000003e-18 < phi1 Initial program 84.3%
Taylor expanded in lambda2 around 0
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-cos.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-cos.f64N/A
lower-cos.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sin.f6466.4
Applied rewrites66.4%
if -4.6e-5 < phi1 < 3.7000000000000003e-18Initial program 69.7%
Taylor expanded in phi1 around 0
lower-*.f64N/A
lower-cos.f64N/A
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
cos-negN/A
lower-cos.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f6469.2
Applied rewrites69.2%
Applied rewrites88.6%
Final simplification76.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 (<= phi1 -1.4e-5)
(* R (acos (* (cos phi1) (cos (- lambda2 lambda1)))))
(*
R
(acos
(*
(cos phi2)
(fma (sin lambda2) (sin lambda1) (* (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.4e-5) {
tmp = R * acos((cos(phi1) * cos((lambda2 - lambda1))));
} else {
tmp = R * acos((cos(phi2) * fma(sin(lambda2), sin(lambda1), (cos(lambda1) * 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.4e-5) tmp = Float64(R * acos(Float64(cos(phi1) * cos(Float64(lambda2 - lambda1))))); else tmp = Float64(R * acos(Float64(cos(phi2) * fma(sin(lambda2), sin(lambda1), Float64(cos(lambda1) * cos(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[LessEqual[phi1, -1.4e-5], N[(R * N[ArcCos[N[(N[Cos[phi1], $MachinePrecision] * N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[(N[Sin[lambda2], $MachinePrecision] * N[Sin[lambda1], $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.4 \cdot 10^{-5}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_1 \cdot \cos \left(\lambda_2 - \lambda_1\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_2 \cdot \mathsf{fma}\left(\sin \lambda_2, \sin \lambda_1, \cos \lambda_1 \cdot \cos \lambda_2\right)\right)\\
\end{array}
\end{array}
if phi1 < -1.39999999999999998e-5Initial program 85.7%
Taylor expanded in phi2 around 0
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
cos-negN/A
lower-cos.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-cos.f6447.5
Applied rewrites47.5%
if -1.39999999999999998e-5 < phi1 Initial program 74.7%
Taylor expanded in phi1 around 0
lower-*.f64N/A
lower-cos.f64N/A
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
cos-negN/A
lower-cos.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f6450.6
Applied rewrites50.6%
Applied rewrites62.8%
Final simplification59.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
(let* ((t_0 (* (sin phi1) (sin phi2))) (t_1 (cos (- lambda2 lambda1))))
(if (<= phi2 -5.6e-5)
(* R (fma PI 0.5 (- (asin (fma (cos phi1) (cos phi2) t_0)))))
(if (<= phi2 0.002)
(* R (acos (fma (cos phi1) t_1 (* phi2 (sin phi1)))))
(if (<= phi2 2.8e+68)
(* R (acos (fma (cos phi2) (cos phi1) t_0)))
(* R (acos (* (cos phi2) 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 = sin(phi1) * sin(phi2);
double t_1 = cos((lambda2 - lambda1));
double tmp;
if (phi2 <= -5.6e-5) {
tmp = R * fma(((double) M_PI), 0.5, -asin(fma(cos(phi1), cos(phi2), t_0)));
} else if (phi2 <= 0.002) {
tmp = R * acos(fma(cos(phi1), t_1, (phi2 * sin(phi1))));
} else if (phi2 <= 2.8e+68) {
tmp = R * acos(fma(cos(phi2), cos(phi1), t_0));
} else {
tmp = R * acos((cos(phi2) * 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 = Float64(sin(phi1) * sin(phi2)) t_1 = cos(Float64(lambda2 - lambda1)) tmp = 0.0 if (phi2 <= -5.6e-5) tmp = Float64(R * fma(pi, 0.5, Float64(-asin(fma(cos(phi1), cos(phi2), t_0))))); elseif (phi2 <= 0.002) tmp = Float64(R * acos(fma(cos(phi1), t_1, Float64(phi2 * sin(phi1))))); elseif (phi2 <= 2.8e+68) tmp = Float64(R * acos(fma(cos(phi2), cos(phi1), t_0))); else tmp = Float64(R * acos(Float64(cos(phi2) * 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[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[phi2, -5.6e-5], N[(R * N[(Pi * 0.5 + (-N[ArcSin[N[(N[Cos[phi1], $MachinePrecision] * N[Cos[phi2], $MachinePrecision] + t$95$0), $MachinePrecision]], $MachinePrecision])), $MachinePrecision]), $MachinePrecision], If[LessEqual[phi2, 0.002], N[(R * N[ArcCos[N[(N[Cos[phi1], $MachinePrecision] * t$95$1 + N[(phi2 * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[phi2, 2.8e+68], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[Cos[phi1], $MachinePrecision] + t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Cos[phi2], $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 := \sin \phi_1 \cdot \sin \phi_2\\
t_1 := \cos \left(\lambda_2 - \lambda_1\right)\\
\mathbf{if}\;\phi_2 \leq -5.6 \cdot 10^{-5}:\\
\;\;\;\;R \cdot \mathsf{fma}\left(\pi, 0.5, -\sin^{-1} \left(\mathsf{fma}\left(\cos \phi_1, \cos \phi_2, t\_0\right)\right)\right)\\
\mathbf{elif}\;\phi_2 \leq 0.002:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\cos \phi_1, t\_1, \phi_2 \cdot \sin \phi_1\right)\right)\\
\mathbf{elif}\;\phi_2 \leq 2.8 \cdot 10^{+68}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\cos \phi_2, \cos \phi_1, t\_0\right)\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_2 \cdot t\_1\right)\\
\end{array}
\end{array}
if phi2 < -5.59999999999999992e-5Initial program 86.6%
Taylor expanded in lambda1 around 0
associate-+r+N/A
Applied rewrites61.2%
Taylor expanded in lambda1 around -inf
Applied rewrites61.1%
Applied rewrites61.2%
Taylor expanded in lambda2 around 0
Applied rewrites47.5%
if -5.59999999999999992e-5 < phi2 < 2e-3Initial program 71.9%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-sin.f64N/A
lift-sin.f64N/A
sin-multN/A
div-subN/A
associate-+r-N/A
lower--.f64N/A
Applied rewrites71.3%
Taylor expanded in phi2 around 0
+-commutativeN/A
sub-negN/A
neg-mul-1N/A
cos-negN/A
neg-mul-1N/A
+-commutativeN/A
distribute-neg-inN/A
remove-double-negN/A
sub-negN/A
distribute-rgt-out--N/A
metadata-evalN/A
*-rgt-identityN/A
lower-fma.f64N/A
Applied rewrites71.9%
if 2e-3 < phi2 < 2.8e68Initial program 78.3%
Taylor expanded in lambda1 around 0
associate-+r+N/A
Applied rewrites70.2%
Taylor expanded in lambda2 around 0
Applied rewrites48.8%
if 2.8e68 < phi2 Initial program 76.7%
Taylor expanded in phi1 around 0
lower-*.f64N/A
lower-cos.f64N/A
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
cos-negN/A
lower-cos.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f6450.4
Applied rewrites50.4%
Final simplification59.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
(* R (acos (fma (cos phi2) (cos phi1) (* (sin phi1) (sin phi2))))))
(t_1 (cos (- lambda2 lambda1))))
(if (<= phi2 -5.6e-5)
t_0
(if (<= phi2 0.002)
(* R (acos (fma (cos phi1) t_1 (* phi2 (sin phi1)))))
(if (<= phi2 2.8e+68) t_0 (* R (acos (* (cos phi2) 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 = R * acos(fma(cos(phi2), cos(phi1), (sin(phi1) * sin(phi2))));
double t_1 = cos((lambda2 - lambda1));
double tmp;
if (phi2 <= -5.6e-5) {
tmp = t_0;
} else if (phi2 <= 0.002) {
tmp = R * acos(fma(cos(phi1), t_1, (phi2 * sin(phi1))));
} else if (phi2 <= 2.8e+68) {
tmp = t_0;
} else {
tmp = R * acos((cos(phi2) * 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 = Float64(R * acos(fma(cos(phi2), cos(phi1), Float64(sin(phi1) * sin(phi2))))) t_1 = cos(Float64(lambda2 - lambda1)) tmp = 0.0 if (phi2 <= -5.6e-5) tmp = t_0; elseif (phi2 <= 0.002) tmp = Float64(R * acos(fma(cos(phi1), t_1, Float64(phi2 * sin(phi1))))); elseif (phi2 <= 2.8e+68) tmp = t_0; else tmp = Float64(R * acos(Float64(cos(phi2) * 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[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[Cos[phi1], $MachinePrecision] + N[(N[Sin[phi1], $MachinePrecision] * N[Sin[phi2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[phi2, -5.6e-5], t$95$0, If[LessEqual[phi2, 0.002], N[(R * N[ArcCos[N[(N[Cos[phi1], $MachinePrecision] * t$95$1 + N[(phi2 * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[phi2, 2.8e+68], t$95$0, N[(R * N[ArcCos[N[(N[Cos[phi2], $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 := R \cdot \cos^{-1} \left(\mathsf{fma}\left(\cos \phi_2, \cos \phi_1, \sin \phi_1 \cdot \sin \phi_2\right)\right)\\
t_1 := \cos \left(\lambda_2 - \lambda_1\right)\\
\mathbf{if}\;\phi_2 \leq -5.6 \cdot 10^{-5}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;\phi_2 \leq 0.002:\\
\;\;\;\;R \cdot \cos^{-1} \left(\mathsf{fma}\left(\cos \phi_1, t\_1, \phi_2 \cdot \sin \phi_1\right)\right)\\
\mathbf{elif}\;\phi_2 \leq 2.8 \cdot 10^{+68}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_2 \cdot t\_1\right)\\
\end{array}
\end{array}
if phi2 < -5.59999999999999992e-5 or 2e-3 < phi2 < 2.8e68Initial program 85.3%
Taylor expanded in lambda1 around 0
associate-+r+N/A
Applied rewrites62.7%
Taylor expanded in lambda2 around 0
Applied rewrites47.7%
if -5.59999999999999992e-5 < phi2 < 2e-3Initial program 71.9%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-sin.f64N/A
lift-sin.f64N/A
sin-multN/A
div-subN/A
associate-+r-N/A
lower--.f64N/A
Applied rewrites71.3%
Taylor expanded in phi2 around 0
+-commutativeN/A
sub-negN/A
neg-mul-1N/A
cos-negN/A
neg-mul-1N/A
+-commutativeN/A
distribute-neg-inN/A
remove-double-negN/A
sub-negN/A
distribute-rgt-out--N/A
metadata-evalN/A
*-rgt-identityN/A
lower-fma.f64N/A
Applied rewrites71.9%
if 2.8e68 < phi2 Initial program 76.7%
Taylor expanded in phi1 around 0
lower-*.f64N/A
lower-cos.f64N/A
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
cos-negN/A
lower-cos.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f6450.4
Applied rewrites50.4%
Final simplification59.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 (- lambda2 lambda1))))
(if (<= phi2 2.5e-5)
(* 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 = cos((lambda2 - lambda1));
double tmp;
if (phi2 <= 2.5e-5) {
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 = cos((lambda2 - lambda1))
if (phi2 <= 2.5d-5) 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.cos((lambda2 - lambda1));
double tmp;
if (phi2 <= 2.5e-5) {
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.cos((lambda2 - lambda1)) tmp = 0 if phi2 <= 2.5e-5: 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 = cos(Float64(lambda2 - lambda1)) tmp = 0.0 if (phi2 <= 2.5e-5) 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 = cos((lambda2 - lambda1));
tmp = 0.0;
if (phi2 <= 2.5e-5)
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[Cos[N[(lambda2 - lambda1), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[phi2, 2.5e-5], 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 := \cos \left(\lambda_2 - \lambda_1\right)\\
\mathbf{if}\;\phi_2 \leq 2.5 \cdot 10^{-5}:\\
\;\;\;\;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.50000000000000012e-5Initial program 77.5%
Taylor expanded in phi2 around 0
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
cos-negN/A
lower-cos.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-cos.f6451.2
Applied rewrites51.2%
if 2.50000000000000012e-5 < phi2 Initial program 77.0%
Taylor expanded in phi1 around 0
lower-*.f64N/A
lower-cos.f64N/A
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
cos-negN/A
lower-cos.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f6446.1
Applied rewrites46.1%
Final simplification49.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 (<= (cos (- lambda1 lambda2)) 0.999999) (* 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 (cos((lambda1 - lambda2)) <= 0.999999) {
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 (cos((lambda1 - lambda2)) <= 0.999999d0) 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 (Math.cos((lambda1 - lambda2)) <= 0.999999) {
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 math.cos((lambda1 - lambda2)) <= 0.999999: 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 (cos(Float64(lambda1 - lambda2)) <= 0.999999) 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 (cos((lambda1 - lambda2)) <= 0.999999)
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[N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision], 0.999999], 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}\;\cos \left(\lambda_1 - \lambda_2\right) \leq 0.999999:\\
\;\;\;\;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 (cos.f64 (-.f64 lambda1 lambda2)) < 0.999998999999999971Initial program 74.9%
Taylor expanded in phi1 around 0
lower-*.f64N/A
lower-cos.f64N/A
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
cos-negN/A
lower-cos.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f6447.2
Applied rewrites47.2%
Taylor expanded in phi2 around 0
Applied rewrites32.8%
if 0.999998999999999971 < (cos.f64 (-.f64 lambda1 lambda2)) Initial program 83.5%
Taylor expanded in phi1 around 0
lower-*.f64N/A
lower-cos.f64N/A
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
cos-negN/A
lower-cos.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f6431.9
Applied rewrites31.9%
Taylor expanded in lambda2 around 0
Applied rewrites31.9%
Taylor expanded in lambda1 around 0
Applied rewrites31.8%
Final simplification32.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 (<= lambda2 9e-5) (* R (acos (* (cos phi2) (cos lambda1)))) (* R (acos (* (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 tmp;
if (lambda2 <= 9e-5) {
tmp = R * acos((cos(phi2) * cos(lambda1)));
} else {
tmp = R * acos((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) :: tmp
if (lambda2 <= 9d-5) then
tmp = r * acos((cos(phi2) * cos(lambda1)))
else
tmp = r * acos((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 tmp;
if (lambda2 <= 9e-5) {
tmp = R * Math.acos((Math.cos(phi2) * Math.cos(lambda1)));
} else {
tmp = R * Math.acos((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): tmp = 0 if lambda2 <= 9e-5: tmp = R * math.acos((math.cos(phi2) * math.cos(lambda1))) else: tmp = R * math.acos((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) tmp = 0.0 if (lambda2 <= 9e-5) tmp = Float64(R * acos(Float64(cos(phi2) * cos(lambda1)))); else tmp = Float64(R * acos(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)
tmp = 0.0;
if (lambda2 <= 9e-5)
tmp = R * acos((cos(phi2) * cos(lambda1)));
else
tmp = R * acos((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_] := If[LessEqual[lambda2, 9e-5], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[Cos[lambda1], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[(N[Cos[phi2], $MachinePrecision] * N[Cos[lambda2], $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 9 \cdot 10^{-5}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_2 \cdot \cos \lambda_1\right)\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \left(\cos \phi_2 \cdot \cos \lambda_2\right)\\
\end{array}
\end{array}
if lambda2 < 9.00000000000000057e-5Initial program 81.7%
Taylor expanded in phi1 around 0
lower-*.f64N/A
lower-cos.f64N/A
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
cos-negN/A
lower-cos.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f6444.5
Applied rewrites44.5%
Taylor expanded in lambda2 around 0
Applied rewrites36.4%
if 9.00000000000000057e-5 < lambda2 Initial program 58.7%
Taylor expanded in phi1 around 0
lower-*.f64N/A
lower-cos.f64N/A
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
cos-negN/A
lower-cos.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f6435.2
Applied rewrites35.2%
Taylor expanded in lambda1 around 0
Applied rewrites35.4%
Final simplification36.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 (<= lambda2 3.2e-5) (* 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 <= 3.2e-5) {
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 <= 3.2d-5) 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 <= 3.2e-5) {
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 <= 3.2e-5: 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 <= 3.2e-5) 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 <= 3.2e-5)
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, 3.2e-5], 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 3.2 \cdot 10^{-5}:\\
\;\;\;\;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 < 3.19999999999999986e-5Initial program 81.7%
Taylor expanded in phi1 around 0
lower-*.f64N/A
lower-cos.f64N/A
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
cos-negN/A
lower-cos.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f6444.5
Applied rewrites44.5%
Taylor expanded in lambda2 around 0
Applied rewrites36.4%
if 3.19999999999999986e-5 < lambda2 Initial program 58.7%
Taylor expanded in phi1 around 0
lower-*.f64N/A
lower-cos.f64N/A
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
cos-negN/A
lower-cos.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f6435.2
Applied rewrites35.2%
Taylor expanded in phi2 around 0
Applied rewrites24.9%
Final simplification34.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 (* 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) {
return R * acos((cos(phi2) * cos((lambda2 - 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(phi2) * cos((lambda2 - 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(phi2) * Math.cos((lambda2 - 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(phi2) * math.cos((lambda2 - 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(Float64(cos(phi2) * cos(Float64(lambda2 - 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(phi2) * cos((lambda2 - 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[(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])\\
\\
R \cdot \cos^{-1} \left(\cos \phi_2 \cdot \cos \left(\lambda_2 - \lambda_1\right)\right)
\end{array}
Initial program 77.4%
Taylor expanded in phi1 around 0
lower-*.f64N/A
lower-cos.f64N/A
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
cos-negN/A
lower-cos.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f6442.7
Applied rewrites42.7%
Final simplification42.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
(if (<= lambda2 4.2e-271)
(* R (acos (cos lambda1)))
(if (<= lambda2 3.1e-5)
(* R (acos (cos phi2)))
(* R (acos (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 (lambda2 <= 4.2e-271) {
tmp = R * acos(cos(lambda1));
} else if (lambda2 <= 3.1e-5) {
tmp = R * acos(cos(phi2));
} else {
tmp = R * acos(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 (lambda2 <= 4.2d-271) then
tmp = r * acos(cos(lambda1))
else if (lambda2 <= 3.1d-5) then
tmp = r * acos(cos(phi2))
else
tmp = r * acos(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 (lambda2 <= 4.2e-271) {
tmp = R * Math.acos(Math.cos(lambda1));
} else if (lambda2 <= 3.1e-5) {
tmp = R * Math.acos(Math.cos(phi2));
} else {
tmp = R * Math.acos(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 lambda2 <= 4.2e-271: tmp = R * math.acos(math.cos(lambda1)) elif lambda2 <= 3.1e-5: tmp = R * math.acos(math.cos(phi2)) else: tmp = R * math.acos(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 (lambda2 <= 4.2e-271) tmp = Float64(R * acos(cos(lambda1))); elseif (lambda2 <= 3.1e-5) tmp = Float64(R * acos(cos(phi2))); else tmp = Float64(R * acos(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 (lambda2 <= 4.2e-271)
tmp = R * acos(cos(lambda1));
elseif (lambda2 <= 3.1e-5)
tmp = R * acos(cos(phi2));
else
tmp = R * acos(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[LessEqual[lambda2, 4.2e-271], N[(R * N[ArcCos[N[Cos[lambda1], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[lambda2, 3.1e-5], N[(R * N[ArcCos[N[Cos[phi2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[Cos[lambda2], $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 4.2 \cdot 10^{-271}:\\
\;\;\;\;R \cdot \cos^{-1} \cos \lambda_1\\
\mathbf{elif}\;\lambda_2 \leq 3.1 \cdot 10^{-5}:\\
\;\;\;\;R \cdot \cos^{-1} \cos \phi_2\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \cos \lambda_2\\
\end{array}
\end{array}
if lambda2 < 4.2000000000000001e-271Initial program 77.5%
Taylor expanded in phi1 around 0
lower-*.f64N/A
lower-cos.f64N/A
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
cos-negN/A
lower-cos.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f6446.1
Applied rewrites46.1%
Taylor expanded in phi2 around 0
Applied rewrites27.5%
Taylor expanded in lambda2 around 0
Applied rewrites19.0%
if 4.2000000000000001e-271 < lambda2 < 3.10000000000000014e-5Initial program 91.6%
Taylor expanded in phi1 around 0
lower-*.f64N/A
lower-cos.f64N/A
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
cos-negN/A
lower-cos.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f6440.6
Applied rewrites40.6%
Taylor expanded in lambda2 around 0
Applied rewrites40.6%
Taylor expanded in lambda1 around 0
Applied rewrites24.4%
if 3.10000000000000014e-5 < lambda2 Initial program 58.7%
Taylor expanded in phi1 around 0
lower-*.f64N/A
lower-cos.f64N/A
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
cos-negN/A
lower-cos.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f6435.2
Applied rewrites35.2%
Taylor expanded in phi2 around 0
Applied rewrites24.9%
Taylor expanded in lambda1 around 0
Applied rewrites24.7%
Final simplification21.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 (<= lambda2 9e-5) (* R (acos (cos lambda1))) (* R (acos (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 (lambda2 <= 9e-5) {
tmp = R * acos(cos(lambda1));
} else {
tmp = R * acos(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 (lambda2 <= 9d-5) then
tmp = r * acos(cos(lambda1))
else
tmp = r * acos(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 (lambda2 <= 9e-5) {
tmp = R * Math.acos(Math.cos(lambda1));
} else {
tmp = R * Math.acos(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 lambda2 <= 9e-5: tmp = R * math.acos(math.cos(lambda1)) else: tmp = R * math.acos(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 (lambda2 <= 9e-5) tmp = Float64(R * acos(cos(lambda1))); else tmp = Float64(R * acos(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 (lambda2 <= 9e-5)
tmp = R * acos(cos(lambda1));
else
tmp = R * acos(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[LessEqual[lambda2, 9e-5], N[(R * N[ArcCos[N[Cos[lambda1], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(R * N[ArcCos[N[Cos[lambda2], $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 9 \cdot 10^{-5}:\\
\;\;\;\;R \cdot \cos^{-1} \cos \lambda_1\\
\mathbf{else}:\\
\;\;\;\;R \cdot \cos^{-1} \cos \lambda_2\\
\end{array}
\end{array}
if lambda2 < 9.00000000000000057e-5Initial program 81.7%
Taylor expanded in phi1 around 0
lower-*.f64N/A
lower-cos.f64N/A
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
cos-negN/A
lower-cos.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f6444.5
Applied rewrites44.5%
Taylor expanded in phi2 around 0
Applied rewrites24.8%
Taylor expanded in lambda2 around 0
Applied rewrites18.8%
if 9.00000000000000057e-5 < lambda2 Initial program 58.7%
Taylor expanded in phi1 around 0
lower-*.f64N/A
lower-cos.f64N/A
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
cos-negN/A
lower-cos.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f6435.2
Applied rewrites35.2%
Taylor expanded in phi2 around 0
Applied rewrites24.9%
Taylor expanded in lambda1 around 0
Applied rewrites24.7%
Final simplification19.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 (* 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 77.4%
Taylor expanded in phi1 around 0
lower-*.f64N/A
lower-cos.f64N/A
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
cos-negN/A
lower-cos.f64N/A
mul-1-negN/A
unsub-negN/A
lower--.f6442.7
Applied rewrites42.7%
Taylor expanded in phi2 around 0
Applied rewrites24.8%
Taylor expanded in lambda2 around 0
Applied rewrites17.5%
Final simplification17.5%
herbie shell --seed 2024221
(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))