Midpoint on a great circle

Percentage Accurate: 98.6% → 98.6%

Time: 16.5s

Alternatives: 4

Speedup: 1.0×

Specification

Math

\[\begin{array}{l} \\ \lambda_1 + \tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (+
  lambda1
  (atan2
   (* (cos phi2) (sin (- lambda1 lambda2)))
   (+ (cos phi1) (* (cos phi2) (cos (- lambda1 lambda2)))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	return lambda1 + atan2((cos(phi2) * sin((lambda1 - lambda2))), (cos(phi1) + (cos(phi2) * cos((lambda1 - lambda2)))));
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    code = lambda1 + atan2((cos(phi2) * sin((lambda1 - lambda2))), (cos(phi1) + (cos(phi2) * cos((lambda1 - lambda2)))))
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	return lambda1 + Math.atan2((Math.cos(phi2) * Math.sin((lambda1 - lambda2))), (Math.cos(phi1) + (Math.cos(phi2) * Math.cos((lambda1 - lambda2)))));
}

Python

def code(lambda1, lambda2, phi1, phi2):
	return lambda1 + math.atan2((math.cos(phi2) * math.sin((lambda1 - lambda2))), (math.cos(phi1) + (math.cos(phi2) * math.cos((lambda1 - lambda2)))))

Julia

function code(lambda1, lambda2, phi1, phi2)
	return Float64(lambda1 + atan(Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))), Float64(cos(phi1) + Float64(cos(phi2) * cos(Float64(lambda1 - lambda2))))))
end

MATLAB

function tmp = code(lambda1, lambda2, phi1, phi2)
	tmp = lambda1 + atan2((cos(phi2) * sin((lambda1 - lambda2))), (cos(phi1) + (cos(phi2) * cos((lambda1 - lambda2)))));
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := N[(lambda1 + N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[phi1], $MachinePrecision] + N[(N[Cos[phi2], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Initial Program: 98.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \lambda_1 + \tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (+
  lambda1
  (atan2
   (* (cos phi2) (sin (- lambda1 lambda2)))
   (+ (cos phi1) (* (cos phi2) (cos (- lambda1 lambda2)))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	return lambda1 + atan2((cos(phi2) * sin((lambda1 - lambda2))), (cos(phi1) + (cos(phi2) * cos((lambda1 - lambda2)))));
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    code = lambda1 + atan2((cos(phi2) * sin((lambda1 - lambda2))), (cos(phi1) + (cos(phi2) * cos((lambda1 - lambda2)))))
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	return lambda1 + Math.atan2((Math.cos(phi2) * Math.sin((lambda1 - lambda2))), (Math.cos(phi1) + (Math.cos(phi2) * Math.cos((lambda1 - lambda2)))));
}

Python

def code(lambda1, lambda2, phi1, phi2):
	return lambda1 + math.atan2((math.cos(phi2) * math.sin((lambda1 - lambda2))), (math.cos(phi1) + (math.cos(phi2) * math.cos((lambda1 - lambda2)))))

Julia

function code(lambda1, lambda2, phi1, phi2)
	return Float64(lambda1 + atan(Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))), Float64(cos(phi1) + Float64(cos(phi2) * cos(Float64(lambda1 - lambda2))))))
end

MATLAB

function tmp = code(lambda1, lambda2, phi1, phi2)
	tmp = lambda1 + atan2((cos(phi2) * sin((lambda1 - lambda2))), (cos(phi1) + (cos(phi2) * cos((lambda1 - lambda2)))));
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := N[(lambda1 + N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[phi1], $MachinePrecision] + N[(N[Cos[phi2], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Alternative 1: 98.6% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \lambda_1 + \tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \left(e^{\mathsf{log1p}\left(\cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)} + -1\right)} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (+
  lambda1
  (atan2
   (* (cos phi2) (sin (- lambda1 lambda2)))
   (+
    (cos phi1)
    (+ (exp (log1p (* (cos phi2) (cos (- lambda1 lambda2))))) -1.0)))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	return lambda1 + atan2((cos(phi2) * sin((lambda1 - lambda2))), (cos(phi1) + (exp(log1p((cos(phi2) * cos((lambda1 - lambda2))))) + -1.0)));
}

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	return lambda1 + Math.atan2((Math.cos(phi2) * Math.sin((lambda1 - lambda2))), (Math.cos(phi1) + (Math.exp(Math.log1p((Math.cos(phi2) * Math.cos((lambda1 - lambda2))))) + -1.0)));
}

Python

def code(lambda1, lambda2, phi1, phi2):
	return lambda1 + math.atan2((math.cos(phi2) * math.sin((lambda1 - lambda2))), (math.cos(phi1) + (math.exp(math.log1p((math.cos(phi2) * math.cos((lambda1 - lambda2))))) + -1.0)))

Julia

function code(lambda1, lambda2, phi1, phi2)
	return Float64(lambda1 + atan(Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))), Float64(cos(phi1) + Float64(exp(log1p(Float64(cos(phi2) * cos(Float64(lambda1 - lambda2))))) + -1.0))))
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := N[(lambda1 + N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[phi1], $MachinePrecision] + N[(N[Exp[N[Log[1 + N[(N[Cos[phi2], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 98.4%

   \[\lambda_1 + \tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)} \]
2. Add Preprocessing
3. Step-by-step derivation

   1. expm1-log1p-u 98.4%

      \[\leadsto \lambda_1 + \tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \color{blue}{\mathsf{expm1}\left(\mathsf{log1p}\left(\cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)\right)}} \]

   2. expm1-undefine 98.4%

      \[\leadsto \lambda_1 + \tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \color{blue}{\left(e^{\mathsf{log1p}\left(\cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)} - 1\right)}} \]

4. Applied egg-rr 98.4%

   \[\leadsto \lambda_1 + \tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \color{blue}{\left(e^{\mathsf{log1p}\left(\cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)} - 1\right)}} \]

5. Final simplification 98.4%

   \[\leadsto \lambda_1 + \tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \left(e^{\mathsf{log1p}\left(\cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)} + -1\right)} \]
6. Add Preprocessing

Alternative 2: 98.6% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \lambda_1 + \tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \mathsf{expm1}\left(\mathsf{log1p}\left(\cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)\right)} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (+
  lambda1
  (atan2
   (* (cos phi2) (sin (- lambda1 lambda2)))
   (+ (cos phi1) (expm1 (log1p (* (cos phi2) (cos (- lambda1 lambda2)))))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	return lambda1 + atan2((cos(phi2) * sin((lambda1 - lambda2))), (cos(phi1) + expm1(log1p((cos(phi2) * cos((lambda1 - lambda2)))))));
}

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	return lambda1 + Math.atan2((Math.cos(phi2) * Math.sin((lambda1 - lambda2))), (Math.cos(phi1) + Math.expm1(Math.log1p((Math.cos(phi2) * Math.cos((lambda1 - lambda2)))))));
}

Python

def code(lambda1, lambda2, phi1, phi2):
	return lambda1 + math.atan2((math.cos(phi2) * math.sin((lambda1 - lambda2))), (math.cos(phi1) + math.expm1(math.log1p((math.cos(phi2) * math.cos((lambda1 - lambda2)))))))

Julia

function code(lambda1, lambda2, phi1, phi2)
	return Float64(lambda1 + atan(Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))), Float64(cos(phi1) + expm1(log1p(Float64(cos(phi2) * cos(Float64(lambda1 - lambda2))))))))
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := N[(lambda1 + N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[phi1], $MachinePrecision] + N[(Exp[N[Log[1 + N[(N[Cos[phi2], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]] - 1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 98.4%

   \[\lambda_1 + \tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)} \]
2. Add Preprocessing
3. Step-by-step derivation

   1. expm1-log1p-u 98.4%

      \[\leadsto \lambda_1 + \tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \color{blue}{\mathsf{expm1}\left(\mathsf{log1p}\left(\cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)\right)}} \]

   2. expm1-undefine 98.4%

      \[\leadsto \lambda_1 + \tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \color{blue}{\left(e^{\mathsf{log1p}\left(\cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)} - 1\right)}} \]

4. Applied egg-rr 98.4%

   \[\leadsto \lambda_1 + \tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \color{blue}{\left(e^{\mathsf{log1p}\left(\cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)} - 1\right)}} \]
5. Step-by-step derivation

   1. expm1-define 98.4%

      \[\leadsto \lambda_1 + \tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \color{blue}{\mathsf{expm1}\left(\mathsf{log1p}\left(\cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)\right)}} \]

6. Simplified 98.4%

   \[\leadsto \lambda_1 + \tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \color{blue}{\mathsf{expm1}\left(\mathsf{log1p}\left(\cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)\right)\right)}} \]
7. Add Preprocessing

Alternative 3: 98.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \lambda_1 + \tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)} \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (+
  lambda1
  (atan2
   (* (cos phi2) (sin (- lambda1 lambda2)))
   (+ (cos phi1) (* (cos phi2) (cos (- lambda1 lambda2)))))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	return lambda1 + atan2((cos(phi2) * sin((lambda1 - lambda2))), (cos(phi1) + (cos(phi2) * cos((lambda1 - lambda2)))));
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    code = lambda1 + atan2((cos(phi2) * sin((lambda1 - lambda2))), (cos(phi1) + (cos(phi2) * cos((lambda1 - lambda2)))))
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	return lambda1 + Math.atan2((Math.cos(phi2) * Math.sin((lambda1 - lambda2))), (Math.cos(phi1) + (Math.cos(phi2) * Math.cos((lambda1 - lambda2)))));
}

Python

def code(lambda1, lambda2, phi1, phi2):
	return lambda1 + math.atan2((math.cos(phi2) * math.sin((lambda1 - lambda2))), (math.cos(phi1) + (math.cos(phi2) * math.cos((lambda1 - lambda2)))))

Julia

function code(lambda1, lambda2, phi1, phi2)
	return Float64(lambda1 + atan(Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))), Float64(cos(phi1) + Float64(cos(phi2) * cos(Float64(lambda1 - lambda2))))))
end

MATLAB

function tmp = code(lambda1, lambda2, phi1, phi2)
	tmp = lambda1 + atan2((cos(phi2) * sin((lambda1 - lambda2))), (cos(phi1) + (cos(phi2) * cos((lambda1 - lambda2)))));
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := N[(lambda1 + N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[phi1], $MachinePrecision] + N[(N[Cos[phi2], $MachinePrecision] * N[Cos[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 98.4%

   \[\lambda_1 + \tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)} \]
2. Add Preprocessing
3. Add Preprocessing

Alternative 4: 77.2% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \lambda_1 \cdot \left(1 + \frac{\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \cos \phi_2 \cdot \left(1 + \lambda_1 \cdot \lambda_2\right)}}{\lambda_1}\right) \end{array} \]

FPCore

(FPCore (lambda1 lambda2 phi1 phi2)
 :precision binary64
 (*
  lambda1
  (+
   1.0
   (/
    (atan2
     (* (cos phi2) (sin (- lambda1 lambda2)))
     (+ (cos phi1) (* (cos phi2) (+ 1.0 (* lambda1 lambda2)))))
    lambda1))))

C

double code(double lambda1, double lambda2, double phi1, double phi2) {
	return lambda1 * (1.0 + (atan2((cos(phi2) * sin((lambda1 - lambda2))), (cos(phi1) + (cos(phi2) * (1.0 + (lambda1 * lambda2))))) / lambda1));
}

Fortran

real(8) function code(lambda1, lambda2, phi1, phi2)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: lambda2
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    code = lambda1 * (1.0d0 + (atan2((cos(phi2) * sin((lambda1 - lambda2))), (cos(phi1) + (cos(phi2) * (1.0d0 + (lambda1 * lambda2))))) / lambda1))
end function

Java

public static double code(double lambda1, double lambda2, double phi1, double phi2) {
	return lambda1 * (1.0 + (Math.atan2((Math.cos(phi2) * Math.sin((lambda1 - lambda2))), (Math.cos(phi1) + (Math.cos(phi2) * (1.0 + (lambda1 * lambda2))))) / lambda1));
}

Python

def code(lambda1, lambda2, phi1, phi2):
	return lambda1 * (1.0 + (math.atan2((math.cos(phi2) * math.sin((lambda1 - lambda2))), (math.cos(phi1) + (math.cos(phi2) * (1.0 + (lambda1 * lambda2))))) / lambda1))

Julia

function code(lambda1, lambda2, phi1, phi2)
	return Float64(lambda1 * Float64(1.0 + Float64(atan(Float64(cos(phi2) * sin(Float64(lambda1 - lambda2))), Float64(cos(phi1) + Float64(cos(phi2) * Float64(1.0 + Float64(lambda1 * lambda2))))) / lambda1)))
end

MATLAB

function tmp = code(lambda1, lambda2, phi1, phi2)
	tmp = lambda1 * (1.0 + (atan2((cos(phi2) * sin((lambda1 - lambda2))), (cos(phi1) + (cos(phi2) * (1.0 + (lambda1 * lambda2))))) / lambda1));
end

Wolfram

code[lambda1_, lambda2_, phi1_, phi2_] := N[(lambda1 * N[(1.0 + N[(N[ArcTan[N[(N[Cos[phi2], $MachinePrecision] * N[Sin[N[(lambda1 - lambda2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[phi1], $MachinePrecision] + N[(N[Cos[phi2], $MachinePrecision] * N[(1.0 + N[(lambda1 * lambda2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / lambda1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 98.4%

   \[\lambda_1 + \tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)} \]
2. Step-by-step derivation

   1. +-commutative 98.4%

      \[\leadsto \lambda_1 + \tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\color{blue}{\cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right) + \cos \phi_1}} \]

   2. fma-define 98.3%

      \[\leadsto \lambda_1 + \tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\color{blue}{\mathsf{fma}\left(\cos \phi_2, \cos \left(\lambda_1 - \lambda_2\right), \cos \phi_1\right)}} \]

3. Simplified 98.3%

   \[\leadsto \color{blue}{\lambda_1 + \tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\mathsf{fma}\left(\cos \phi_2, \cos \left(\lambda_1 - \lambda_2\right), \cos \phi_1\right)}} \]
4. Add Preprocessing

5. Taylor expanded in lambda1 around inf 98.3%

   \[\leadsto \color{blue}{\lambda_1 \cdot \left(1 + \frac{\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \cos \phi_2 \cdot \cos \left(\lambda_1 - \lambda_2\right)}}{\lambda_1}\right)} \]

6. Taylor expanded in lambda1 around 0 97.1%

   \[\leadsto \lambda_1 \cdot \left(1 + \frac{\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \cos \phi_2 \cdot \color{blue}{\left(\cos \left(-\lambda_2\right) + -1 \cdot \left(\lambda_1 \cdot \sin \left(-\lambda_2\right)\right)\right)}}}{\lambda_1}\right) \]
7. Step-by-step derivation

   1. cos-neg 97.1%

      \[\leadsto \lambda_1 \cdot \left(1 + \frac{\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \cos \phi_2 \cdot \left(\color{blue}{\cos \lambda_2} + -1 \cdot \left(\lambda_1 \cdot \sin \left(-\lambda_2\right)\right)\right)}}{\lambda_1}\right) \]

   2. mul-1-neg 97.1%

      \[\leadsto \lambda_1 \cdot \left(1 + \frac{\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \cos \phi_2 \cdot \left(\cos \lambda_2 + \color{blue}{\left(-\lambda_1 \cdot \sin \left(-\lambda_2\right)\right)}\right)}}{\lambda_1}\right) \]

   3. distribute-rgt-neg-in 97.1%

      \[\leadsto \lambda_1 \cdot \left(1 + \frac{\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \cos \phi_2 \cdot \left(\cos \lambda_2 + \color{blue}{\lambda_1 \cdot \left(-\sin \left(-\lambda_2\right)\right)}\right)}}{\lambda_1}\right) \]

   4. sin-neg 97.1%

      \[\leadsto \lambda_1 \cdot \left(1 + \frac{\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \cos \phi_2 \cdot \left(\cos \lambda_2 + \lambda_1 \cdot \left(-\color{blue}{\left(-\sin \lambda_2\right)}\right)\right)}}{\lambda_1}\right) \]

   5. remove-double-neg 97.1%

      \[\leadsto \lambda_1 \cdot \left(1 + \frac{\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \cos \phi_2 \cdot \left(\cos \lambda_2 + \lambda_1 \cdot \color{blue}{\sin \lambda_2}\right)}}{\lambda_1}\right) \]

8. Simplified 97.1%

   \[\leadsto \lambda_1 \cdot \left(1 + \frac{\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \cos \phi_2 \cdot \color{blue}{\left(\cos \lambda_2 + \lambda_1 \cdot \sin \lambda_2\right)}}}{\lambda_1}\right) \]

9. Taylor expanded in lambda2 around 0 78.5%

   \[\leadsto \lambda_1 \cdot \left(1 + \frac{\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\color{blue}{\cos \phi_1 + \left(\cos \phi_2 + \lambda_1 \cdot \left(\lambda_2 \cdot \cos \phi_2\right)\right)}}}{\lambda_1}\right) \]
10. Step-by-step derivation

    1. associate-*r* 78.5%

       \[\leadsto \lambda_1 \cdot \left(1 + \frac{\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \left(\cos \phi_2 + \color{blue}{\left(\lambda_1 \cdot \lambda_2\right) \cdot \cos \phi_2}\right)}}{\lambda_1}\right) \]

    2. distribute-rgt1-in 78.5%

       \[\leadsto \lambda_1 \cdot \left(1 + \frac{\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \color{blue}{\left(\lambda_1 \cdot \lambda_2 + 1\right) \cdot \cos \phi_2}}}{\lambda_1}\right) \]

11. Simplified 78.5%

    \[\leadsto \lambda_1 \cdot \left(1 + \frac{\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\color{blue}{\cos \phi_1 + \left(\lambda_1 \cdot \lambda_2 + 1\right) \cdot \cos \phi_2}}}{\lambda_1}\right) \]

12. Final simplification 78.5%

    \[\leadsto \lambda_1 \cdot \left(1 + \frac{\tan^{-1}_* \frac{\cos \phi_2 \cdot \sin \left(\lambda_1 - \lambda_2\right)}{\cos \phi_1 + \cos \phi_2 \cdot \left(1 + \lambda_1 \cdot \lambda_2\right)}}{\lambda_1}\right) \]
13. Add Preprocessing

Reproduce

herbie shell --seed 2024179 
(FPCore (lambda1 lambda2 phi1 phi2)
  :name "Midpoint on a great circle"
  :precision binary64
  (+ lambda1 (atan2 (* (cos phi2) (sin (- lambda1 lambda2))) (+ (cos phi1) (* (cos phi2) (cos (- lambda1 lambda2)))))))