Destination given bearing on a great circle

Percentage Accurate: 99.7% → 99.7%

Time: 14.1s

Alternatives: 9

Speedup: 1.2×

Specification

Math

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

FPCore

(FPCore (lambda1 phi1 phi2 delta theta)
 :precision binary64
 (+
  lambda1
  (atan2
   (* (* (sin theta) (sin delta)) (cos phi1))
   (-
    (cos delta)
    (*
     (sin phi1)
     (sin
      (asin
       (+
        (* (sin phi1) (cos delta))
        (* (* (cos phi1) (sin delta)) (cos theta))))))))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 + N[ArcTan[N[(N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[Sin[N[ArcSin[N[(N[(N[Sin[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision]), $MachinePrecision] + N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Initial Program: 99.7% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (lambda1 phi1 phi2 delta theta)
 :precision binary64
 (+
  lambda1
  (atan2
   (* (* (sin theta) (sin delta)) (cos phi1))
   (-
    (cos delta)
    (*
     (sin phi1)
     (sin
      (asin
       (+
        (* (sin phi1) (cos delta))
        (* (* (cos phi1) (sin delta)) (cos theta))))))))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 + N[ArcTan[N[(N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[Sin[N[ArcSin[N[(N[(N[Sin[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision]), $MachinePrecision] + N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Alternative 1: 99.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \sin delta \cdot \cos \phi_1\\ \lambda_1 + \tan^{-1}_* \frac{\sin theta \cdot t\_1}{\mathsf{fma}\left(-\sin \phi_1, \mathsf{fma}\left(\sin \phi_1, \cos delta, \cos theta \cdot t\_1\right), \cos delta\right)} \end{array} \end{array} \]

FPCore

(FPCore (lambda1 phi1 phi2 delta theta)
 :precision binary64
 (let* ((t_1 (* (sin delta) (cos phi1))))
   (+
    lambda1
    (atan2
     (* (sin theta) t_1)
     (fma
      (- (sin phi1))
      (fma (sin phi1) (cos delta) (* (cos theta) t_1))
      (cos delta))))))

C

double code(double lambda1, double phi1, double phi2, double delta, double theta) {
	double t_1 = sin(delta) * cos(phi1);
	return lambda1 + atan2((sin(theta) * t_1), fma(-sin(phi1), fma(sin(phi1), cos(delta), (cos(theta) * t_1)), cos(delta)));
}

Julia

function code(lambda1, phi1, phi2, delta, theta)
	t_1 = Float64(sin(delta) * cos(phi1))
	return Float64(lambda1 + atan(Float64(sin(theta) * t_1), fma(Float64(-sin(phi1)), fma(sin(phi1), cos(delta), Float64(cos(theta) * t_1)), cos(delta))))
end

Wolfram

code[lambda1_, phi1_, phi2_, delta_, theta_] := Block[{t$95$1 = N[(N[Sin[delta], $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision]}, N[(lambda1 + N[ArcTan[N[(N[Sin[theta], $MachinePrecision] * t$95$1), $MachinePrecision] / N[((-N[Sin[phi1], $MachinePrecision]) * N[(N[Sin[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision] + N[(N[Cos[theta], $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision] + N[Cos[delta], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]

Derivation

1. Initial program 99.7%

   \[\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1}{\cos delta - \sin \phi_1 \cdot \sin \sin^{-1} \left(\sin \phi_1 \cdot \cos delta + \left(\cos \phi_1 \cdot \sin delta\right) \cdot \cos theta\right)} \]

3. Simplified 99.7%

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

5. Taylor expanded in delta around inf 99.7%

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

   1. +-commutative 99.7%

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

   2. associate-*r* 99.7%

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

   3. +-commutative 99.7%

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

   4. associate-*r* 99.7%

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

   5. *-commutative 99.7%

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

   6. fma-undefine 99.7%

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

   7. fma-define 99.7%

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

   8. neg-mul-1 99.7%

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

7. Simplified 99.7%

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

8. Final simplification 99.7%

   \[\leadsto \lambda_1 + \tan^{-1}_* \frac{\sin theta \cdot \left(\sin delta \cdot \cos \phi_1\right)}{\mathsf{fma}\left(-\sin \phi_1, \mathsf{fma}\left(\sin \phi_1, \cos delta, \cos theta \cdot \left(\sin delta \cdot \cos \phi_1\right)\right), \cos delta\right)} \]
9. Add Preprocessing

Alternative 2: 99.7% accurate, 1.2× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 + N[ArcTan[N[(N[Cos[phi1], $MachinePrecision] * N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[(N[(N[Sin[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision]), $MachinePrecision] + N[(N[Cos[phi1], $MachinePrecision] * N[(N[Sin[delta], $MachinePrecision] * N[Cos[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 99.7%

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

3. Taylor expanded in delta around inf 99.7%

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

4. Final simplification 99.7%

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

Alternative 3: 94.7% accurate, 1.3× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 + N[ArcTan[N[(N[Cos[phi1], $MachinePrecision] * N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[(N[(N[Sin[delta], $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] + N[(N[Sin[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 99.7%

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

3. Taylor expanded in theta around 0 96.1%

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

4. Final simplification 96.1%

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

Alternative 4: 92.4% accurate, 1.9× speedup

Math

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

FPCore

(FPCore (lambda1 phi1 phi2 delta theta)
 :precision binary64
 (+
  lambda1
  (atan2
   (* (cos phi1) (* (sin theta) (sin delta)))
   (- (cos delta) (pow (sin phi1) 2.0)))))

C

double code(double lambda1, double phi1, double phi2, double delta, double theta) {
	return lambda1 + atan2((cos(phi1) * (sin(theta) * sin(delta))), (cos(delta) - pow(sin(phi1), 2.0)));
}

Fortran

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

Java

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

Python

def code(lambda1, phi1, phi2, delta, theta):
	return lambda1 + math.atan2((math.cos(phi1) * (math.sin(theta) * math.sin(delta))), (math.cos(delta) - math.pow(math.sin(phi1), 2.0)))

Julia

function code(lambda1, phi1, phi2, delta, theta)
	return Float64(lambda1 + atan(Float64(cos(phi1) * Float64(sin(theta) * sin(delta))), Float64(cos(delta) - (sin(phi1) ^ 2.0))))
end

MATLAB

function tmp = code(lambda1, phi1, phi2, delta, theta)
	tmp = lambda1 + atan2((cos(phi1) * (sin(theta) * sin(delta))), (cos(delta) - (sin(phi1) ^ 2.0)));
end

Wolfram

code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 + N[ArcTan[N[(N[Cos[phi1], $MachinePrecision] * N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[Cos[delta], $MachinePrecision] - N[Power[N[Sin[phi1], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 99.7%

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

3. Taylor expanded in delta around 0 93.0%

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

4. Final simplification 93.0%

   \[\leadsto \lambda_1 + \tan^{-1}_* \frac{\cos \phi_1 \cdot \left(\sin theta \cdot \sin delta\right)}{\cos delta - {\sin \phi_1}^{2}} \]
5. Add Preprocessing

Alternative 5: 92.0% accurate, 2.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \sin theta \cdot \left(\sin delta \cdot \cos \phi_1\right)\\ \mathbf{if}\;delta \leq -1.76 \lor \neg \left(delta \leq 500000\right):\\ \;\;\;\;\lambda_1 + \tan^{-1}_* \frac{t\_1}{\cos delta}\\ \mathbf{else}:\\ \;\;\;\;\lambda_1 + \tan^{-1}_* \frac{t\_1}{1 - {\sin \phi_1}^{2}}\\ \end{array} \end{array} \]

FPCore

(FPCore (lambda1 phi1 phi2 delta theta)
 :precision binary64
 (let* ((t_1 (* (sin theta) (* (sin delta) (cos phi1)))))
   (if (or (<= delta -1.76) (not (<= delta 500000.0)))
     (+ lambda1 (atan2 t_1 (cos delta)))
     (+ lambda1 (atan2 t_1 (- 1.0 (pow (sin phi1) 2.0)))))))

C

double code(double lambda1, double phi1, double phi2, double delta, double theta) {
	double t_1 = sin(theta) * (sin(delta) * cos(phi1));
	double tmp;
	if ((delta <= -1.76) || !(delta <= 500000.0)) {
		tmp = lambda1 + atan2(t_1, cos(delta));
	} else {
		tmp = lambda1 + atan2(t_1, (1.0 - pow(sin(phi1), 2.0)));
	}
	return tmp;
}

Fortran

real(8) function code(lambda1, phi1, phi2, delta, theta)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    real(8), intent (in) :: delta
    real(8), intent (in) :: theta
    real(8) :: t_1
    real(8) :: tmp
    t_1 = sin(theta) * (sin(delta) * cos(phi1))
    if ((delta <= (-1.76d0)) .or. (.not. (delta <= 500000.0d0))) then
        tmp = lambda1 + atan2(t_1, cos(delta))
    else
        tmp = lambda1 + atan2(t_1, (1.0d0 - (sin(phi1) ** 2.0d0)))
    end if
    code = tmp
end function

Java

public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
	double t_1 = Math.sin(theta) * (Math.sin(delta) * Math.cos(phi1));
	double tmp;
	if ((delta <= -1.76) || !(delta <= 500000.0)) {
		tmp = lambda1 + Math.atan2(t_1, Math.cos(delta));
	} else {
		tmp = lambda1 + Math.atan2(t_1, (1.0 - Math.pow(Math.sin(phi1), 2.0)));
	}
	return tmp;
}

Python

def code(lambda1, phi1, phi2, delta, theta):
	t_1 = math.sin(theta) * (math.sin(delta) * math.cos(phi1))
	tmp = 0
	if (delta <= -1.76) or not (delta <= 500000.0):
		tmp = lambda1 + math.atan2(t_1, math.cos(delta))
	else:
		tmp = lambda1 + math.atan2(t_1, (1.0 - math.pow(math.sin(phi1), 2.0)))
	return tmp

Julia

function code(lambda1, phi1, phi2, delta, theta)
	t_1 = Float64(sin(theta) * Float64(sin(delta) * cos(phi1)))
	tmp = 0.0
	if ((delta <= -1.76) || !(delta <= 500000.0))
		tmp = Float64(lambda1 + atan(t_1, cos(delta)));
	else
		tmp = Float64(lambda1 + atan(t_1, Float64(1.0 - (sin(phi1) ^ 2.0))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(lambda1, phi1, phi2, delta, theta)
	t_1 = sin(theta) * (sin(delta) * cos(phi1));
	tmp = 0.0;
	if ((delta <= -1.76) || ~((delta <= 500000.0)))
		tmp = lambda1 + atan2(t_1, cos(delta));
	else
		tmp = lambda1 + atan2(t_1, (1.0 - (sin(phi1) ^ 2.0)));
	end
	tmp_2 = tmp;
end

Wolfram

code[lambda1_, phi1_, phi2_, delta_, theta_] := Block[{t$95$1 = N[(N[Sin[theta], $MachinePrecision] * N[(N[Sin[delta], $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[delta, -1.76], N[Not[LessEqual[delta, 500000.0]], $MachinePrecision]], N[(lambda1 + N[ArcTan[t$95$1 / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(lambda1 + N[ArcTan[t$95$1 / N[(1.0 - N[Power[N[Sin[phi1], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if delta < -1.76000000000000001 or 5e5 < delta

   1. Initial program 99.8%

      \[\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1}{\cos delta - \sin \phi_1 \cdot \sin \sin^{-1} \left(\sin \phi_1 \cdot \cos delta + \left(\cos \phi_1 \cdot \sin delta\right) \cdot \cos theta\right)} \]

   3. Simplified 99.7%

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

   5. Taylor expanded in phi1 around 0 87.0%

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

   if -1.76000000000000001 < delta < 5e5

   1. Initial program 99.7%

      \[\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1}{\cos delta - \sin \phi_1 \cdot \sin \sin^{-1} \left(\sin \phi_1 \cdot \cos delta + \left(\cos \phi_1 \cdot \sin delta\right) \cdot \cos theta\right)} \]

   3. Simplified 99.7%

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

   5. Taylor expanded in delta around 0 98.5%

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

      1. mul-1-neg 98.5%

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

      2. sub-neg 98.5%

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

   7. Simplified 98.5%

      \[\leadsto \lambda_1 + \tan^{-1}_* \frac{\sin theta \cdot \left(\sin delta \cdot \cos \phi_1\right)}{\color{blue}{1 - {\sin \phi_1}^{2}}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 93.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;delta \leq -1.76 \lor \neg \left(delta \leq 500000\right):\\ \;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\sin theta \cdot \left(\sin delta \cdot \cos \phi_1\right)}{\cos delta}\\ \mathbf{else}:\\ \;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\sin theta \cdot \left(\sin delta \cdot \cos \phi_1\right)}{1 - {\sin \phi_1}^{2}}\\ \end{array} \]
5. Add Preprocessing

Alternative 6: 91.9% accurate, 2.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;delta \leq -1.76 \lor \neg \left(delta \leq 2.4 \cdot 10^{-29}\right):\\ \;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\sin theta \cdot \left(\sin delta \cdot \cos \phi_1\right)}{\cos delta}\\ \mathbf{else}:\\ \;\;\;\;\lambda_1 + \tan^{-1}_* \frac{delta \cdot \left(\sin theta \cdot \cos \phi_1\right)}{1 - {\sin \phi_1}^{2}}\\ \end{array} \end{array} \]

FPCore

(FPCore (lambda1 phi1 phi2 delta theta)
 :precision binary64
 (if (or (<= delta -1.76) (not (<= delta 2.4e-29)))
   (+ lambda1 (atan2 (* (sin theta) (* (sin delta) (cos phi1))) (cos delta)))
   (+
    lambda1
    (atan2
     (* delta (* (sin theta) (cos phi1)))
     (- 1.0 (pow (sin phi1) 2.0))))))

C

double code(double lambda1, double phi1, double phi2, double delta, double theta) {
	double tmp;
	if ((delta <= -1.76) || !(delta <= 2.4e-29)) {
		tmp = lambda1 + atan2((sin(theta) * (sin(delta) * cos(phi1))), cos(delta));
	} else {
		tmp = lambda1 + atan2((delta * (sin(theta) * cos(phi1))), (1.0 - pow(sin(phi1), 2.0)));
	}
	return tmp;
}

Fortran

real(8) function code(lambda1, phi1, phi2, delta, theta)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    real(8), intent (in) :: delta
    real(8), intent (in) :: theta
    real(8) :: tmp
    if ((delta <= (-1.76d0)) .or. (.not. (delta <= 2.4d-29))) then
        tmp = lambda1 + atan2((sin(theta) * (sin(delta) * cos(phi1))), cos(delta))
    else
        tmp = lambda1 + atan2((delta * (sin(theta) * cos(phi1))), (1.0d0 - (sin(phi1) ** 2.0d0)))
    end if
    code = tmp
end function

Java

public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
	double tmp;
	if ((delta <= -1.76) || !(delta <= 2.4e-29)) {
		tmp = lambda1 + Math.atan2((Math.sin(theta) * (Math.sin(delta) * Math.cos(phi1))), Math.cos(delta));
	} else {
		tmp = lambda1 + Math.atan2((delta * (Math.sin(theta) * Math.cos(phi1))), (1.0 - Math.pow(Math.sin(phi1), 2.0)));
	}
	return tmp;
}

Python

def code(lambda1, phi1, phi2, delta, theta):
	tmp = 0
	if (delta <= -1.76) or not (delta <= 2.4e-29):
		tmp = lambda1 + math.atan2((math.sin(theta) * (math.sin(delta) * math.cos(phi1))), math.cos(delta))
	else:
		tmp = lambda1 + math.atan2((delta * (math.sin(theta) * math.cos(phi1))), (1.0 - math.pow(math.sin(phi1), 2.0)))
	return tmp

Julia

function code(lambda1, phi1, phi2, delta, theta)
	tmp = 0.0
	if ((delta <= -1.76) || !(delta <= 2.4e-29))
		tmp = Float64(lambda1 + atan(Float64(sin(theta) * Float64(sin(delta) * cos(phi1))), cos(delta)));
	else
		tmp = Float64(lambda1 + atan(Float64(delta * Float64(sin(theta) * cos(phi1))), Float64(1.0 - (sin(phi1) ^ 2.0))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(lambda1, phi1, phi2, delta, theta)
	tmp = 0.0;
	if ((delta <= -1.76) || ~((delta <= 2.4e-29)))
		tmp = lambda1 + atan2((sin(theta) * (sin(delta) * cos(phi1))), cos(delta));
	else
		tmp = lambda1 + atan2((delta * (sin(theta) * cos(phi1))), (1.0 - (sin(phi1) ^ 2.0)));
	end
	tmp_2 = tmp;
end

Wolfram

code[lambda1_, phi1_, phi2_, delta_, theta_] := If[Or[LessEqual[delta, -1.76], N[Not[LessEqual[delta, 2.4e-29]], $MachinePrecision]], N[(lambda1 + N[ArcTan[N[(N[Sin[theta], $MachinePrecision] * N[(N[Sin[delta], $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(lambda1 + N[ArcTan[N[(delta * N[(N[Sin[theta], $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(1.0 - N[Power[N[Sin[phi1], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if delta < -1.76000000000000001 or 2.39999999999999992e-29 < delta

   1. Initial program 99.7%

      \[\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1}{\cos delta - \sin \phi_1 \cdot \sin \sin^{-1} \left(\sin \phi_1 \cdot \cos delta + \left(\cos \phi_1 \cdot \sin delta\right) \cdot \cos theta\right)} \]

   3. Simplified 99.7%

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

   5. Taylor expanded in phi1 around 0 86.5%

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

   if -1.76000000000000001 < delta < 2.39999999999999992e-29

   1. Initial program 99.7%

      \[\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1}{\cos delta - \sin \phi_1 \cdot \sin \sin^{-1} \left(\sin \phi_1 \cdot \cos delta + \left(\cos \phi_1 \cdot \sin delta\right) \cdot \cos theta\right)} \]

   3. Simplified 99.8%

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

   5. Taylor expanded in delta around 0 99.8%

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

   6. Taylor expanded in delta around 0 99.8%

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

      1. mul-1-neg 99.7%

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

      2. sub-neg 99.7%

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

   8. Simplified 99.8%

      \[\leadsto \lambda_1 + \tan^{-1}_* \frac{delta \cdot \left(\cos \phi_1 \cdot \sin theta\right)}{\color{blue}{1 - {\sin \phi_1}^{2}}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 93.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;delta \leq -1.76 \lor \neg \left(delta \leq 2.4 \cdot 10^{-29}\right):\\ \;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\sin theta \cdot \left(\sin delta \cdot \cos \phi_1\right)}{\cos delta}\\ \mathbf{else}:\\ \;\;\;\;\lambda_1 + \tan^{-1}_* \frac{delta \cdot \left(\sin theta \cdot \cos \phi_1\right)}{1 - {\sin \phi_1}^{2}}\\ \end{array} \]
5. Add Preprocessing

Alternative 7: 89.1% accurate, 2.6× speedup

Math

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

FPCore

(FPCore (lambda1 phi1 phi2 delta theta)
 :precision binary64
 (+ lambda1 (atan2 (* (sin theta) (* (sin delta) (cos phi1))) (cos delta))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 + N[ArcTan[N[(N[Sin[theta], $MachinePrecision] * N[(N[Sin[delta], $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 99.7%

   \[\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1}{\cos delta - \sin \phi_1 \cdot \sin \sin^{-1} \left(\sin \phi_1 \cdot \cos delta + \left(\cos \phi_1 \cdot \sin delta\right) \cdot \cos theta\right)} \]

3. Simplified 99.7%

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

5. Taylor expanded in phi1 around 0 89.4%

   \[\leadsto \lambda_1 + \tan^{-1}_* \frac{\sin theta \cdot \left(\sin delta \cdot \cos \phi_1\right)}{\color{blue}{\cos delta}} \]
6. Add Preprocessing

Alternative 8: 74.9% accurate, 3.2× speedup

Math

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

FPCore

(FPCore (lambda1 phi1 phi2 delta theta)
 :precision binary64
 (+ lambda1 (atan2 (* delta (* (sin theta) (cos phi1))) (cos delta))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 + N[ArcTan[N[(delta * N[(N[Sin[theta], $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 99.7%

   \[\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1}{\cos delta - \sin \phi_1 \cdot \sin \sin^{-1} \left(\sin \phi_1 \cdot \cos delta + \left(\cos \phi_1 \cdot \sin delta\right) \cdot \cos theta\right)} \]

3. Simplified 99.7%

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

5. Taylor expanded in delta around 0 80.2%

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

6. Taylor expanded in phi1 around 0 76.1%

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

7. Final simplification 76.1%

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

Alternative 9: 69.9% accurate, 1320.0× speedup

Math

\[\begin{array}{l} \\ \lambda_1 \end{array} \]

FPCore

(FPCore (lambda1 phi1 phi2 delta theta) :precision binary64 lambda1)

C

double code(double lambda1, double phi1, double phi2, double delta, double theta) {
	return lambda1;
}

Fortran

real(8) function code(lambda1, phi1, phi2, delta, theta)
    real(8), intent (in) :: lambda1
    real(8), intent (in) :: phi1
    real(8), intent (in) :: phi2
    real(8), intent (in) :: delta
    real(8), intent (in) :: theta
    code = lambda1
end function

Java

public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
	return lambda1;
}

Python

def code(lambda1, phi1, phi2, delta, theta):
	return lambda1

Julia

function code(lambda1, phi1, phi2, delta, theta)
	return lambda1
end

MATLAB

function tmp = code(lambda1, phi1, phi2, delta, theta)
	tmp = lambda1;
end

Wolfram

code[lambda1_, phi1_, phi2_, delta_, theta_] := lambda1

Derivation

1. Initial program 99.7%

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

   1. sin-asin 99.7%

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

   2. add-cbrt-cube 99.7%

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

   3. pow3 99.7%

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

   4. *-commutative 99.7%

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

4. Applied egg-rr 99.7%

   \[\leadsto \lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1}{\cos delta - \color{blue}{\sqrt[3]{{\left(\sin \phi_1 \cdot \mathsf{fma}\left(\sin delta, \cos \phi_1 \cdot \cos theta, \cos delta \cdot \sin \phi_1\right)\right)}^{3}}}} \]
5. Step-by-step derivation

   1. rem-cbrt-cube 99.7%

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

   2. add-sqr-sqrt 45.6%

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

   3. sqrt-unprod 94.1%

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

   4. sqr-neg 94.1%

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

   5. sqrt-unprod 48.5%

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

   6. add-sqr-sqrt 89.3%

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

   7. distribute-lft-neg-in 89.3%

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

   8. expm1-log1p-u 89.3%

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

   9. distribute-lft-neg-in 89.3%

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

   10. fma-undefine 89.3%

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

6. Applied egg-rr 99.7%

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

7. Taylor expanded in lambda1 around inf 68.6%

   \[\leadsto \color{blue}{\lambda_1} \]
8. Add Preprocessing

Reproduce

herbie shell --seed 2024111 
(FPCore (lambda1 phi1 phi2 delta theta)
  :name "Destination given bearing on a great circle"
  :precision binary64
  (+ lambda1 (atan2 (* (* (sin theta) (sin delta)) (cos phi1)) (- (cos delta) (* (sin phi1) (sin (asin (+ (* (sin phi1) (cos delta)) (* (* (cos phi1) (sin delta)) (cos theta))))))))))