What is the average angular distance between the Sun and the Moon?

Question

Naturally we would expect the average angular distance(*), to be exactly 90°, for although the Moon is not running in uniform speed (or rather, to be more precise, the relative angular speed of the Sun versus the Moon is not uniform), it is expected to average to 90° after some months.

But I'm not quite convinced on this, since the Moon's orbit has many irregularities that are due to the Sun, so maybe those irregularities and different precessions cause it to be somehow to have angular distance less than 90° on average (say, in a time frame of 100 years to allow some cycles of the precessions)? For those precessions are not just random and arbitrary but are affected also by the Sun.

(*) By the term angular distance, I actually mean the elongation - the longitudinal distance on the plane on the ecliptic. i.e., let's assume the Moon is always on the ecliptic. Also to avoid other complications, like parallax, lets assume the viewing point is Earth's center.

---

(**) This question was heavily edited and originally was about the average distance of Moon-Sun and Earth-Sun: are they equal. It was triggered by another question about which of Mars and its moon is closer to Earth.. In his answer to that question, Conor Garcia established that the Earth-Sun distance is shorter.

Answer 1

For lack of other means, I had to resort to empirical evidence. I am not a statistician to draw conclusions from the data, but as far as astropy is to be trusted (and together with Greg Miller answer), we can comfortably say that the average elongation between the Sun and the Moon is indeed less than 90 and about 89.9773. Not less than 1 minute 20 seconds of arc below 90.

using astropy, I was probing the elongation every 100 minutes for a period of 20 Metonic cycles from 1971 (about 380 years).(*). Hopefully I have no errors in the procedure.

 from datetime import datetime, timedelta
import numpy
from astropy.coordinates import get_sun, get_moon
from astropy.time import Time

SYNODIC_MONTH = 29.530588

def arc_angle_to_decimal_angle(x):
    sign, d, m, s = x.signed_dms
    return sign*(((s+60*m) / 3600.0) + d)

def get_mean_elongation(start_time, duration_years, resulation_minutes=60):

    full_synodic_months_in_period = int((duration_years * 365.25) / SYNODIC_MONTH)
    total_seconds_in_period = full_synodic_months_in_period * SYNODIC_MONTH * 24 * 3600
    start_timestamp = (start_time - datetime(1970, 1, 1)).total_seconds()
    measurement_dates = numpy.arange(start_timestamp,
                                    int(start_timestamp + total_seconds_in_period),
                                    resulation_minutes*60)
    times = Time(measurement_dates, format='unix')
    sun_locations = get_sun(times)
    sun_longitudes = sun_locations.geocentrictrueecliptic.lon
    moon_locations = get_moon(times)
    moon_longitudes = moon_locations.geocentrictrueecliptic.lon

    raw_elongations = sun_longitudes - moon_longitudes
    elongations = [abs((arc_angle_to_decimal_angle(x) + 180) % 360 - 180) for x in raw_elongations]
    return numpy.average(elongations)


initial_time = datetime(year=1971, month=1, day=1)
# randomly using Metonic cycle as our time unit. duration for each run.
start_times = [initial_time + i*timedelta(days=SYNODIC_MONTH*235.0) for i in range(20)]
for start_time in start_times:
    mean_elongation_in_cycle = get_mean_elongation(start_time, 19.01, 100)
    print (mean_elongation_in_cycle)

Overall the mean elongation was only 89.977126428844, with std dev of 0.03 degrees between the cycles. However, every cycle is an average itself of 235 synodic months. the averages of the 20 cycles:

89.97744855312953
90.01179735070117
90.01836246533315
89.99176354305985
89.95290382517166
89.93281176564325
89.94788912156328
89.98591069190877
90.01617408458138
90.0151869775336
89.98352750715169
89.9462668251323
89.93312895961259
89.95502282200147
89.99385230344161
90.01881961553114
90.01046162644384
89.97523018635377
89.94093677031842
89.93503358226833

It is interesting to see that the average of each cycle never suppresses 90.02 degrees, but can go down as far 89.93 (three times out of 20). So maybe there is indeed some asymmetry here.

Edit: I later ran the same, again with 20 cycles, but this time of 4 Metonic cycles (~76 years) [though with somewhat decreased resolution but this seems to be insignificant]. In every single one, the mean elongation turned up to be below 90 degrees. with an average of 89.977365350276. here are the numbers:

89.99987609559011,89.9548360909815,89.990273514188,89.9751752933985,89.96544012311175,89.9970793510278,89.95314878049196,89.9960915736152,89.9671592424419,89.97324912730615,89.99181211176018,89.95429311395692,89.99950710672812,89.96022791221479,89.98158012374506,89.98453596002506,89.95833062247787,89.99993331713853,89.9553753312884,89.98938221403375

For fun, I ran it again, this time using start-date 4000 years ahead. the results were about the same. (again, all the cycles below 90, avg: 89.97755)

Now, we are left with the question of why this happens. very far from being sure, I still prefer to stick to my original hunch: that this deviation from 90 degrees is due to the precessions, with their irregular speeds, which are ultimately related to the Sun- so it will somehow, with a complex mechanism, cause it to be so. For I can't find any other reason. (1) When one looks at the inequalities of the Moon and their principal terms, which I believe should be accurate within 1 minute of arc, he can see (unless I'm mistaken) that there is symmetry there (trying to have $D = 180 + D$); though there is asymmetry between the sides of the Full and New Moons (Parallactic inequality) this is still a mirror between them. [the reader should not however that all values there are mean values] (2) the main precession cycles are relatively fast. The most important for our sake here, the apsidal precession, is only 8.85 years; hence I expect that if the precessions and irregularities were really independent, their effect would cancel quite fast.

---

(*) This is the first time I was using astropy, and had some odd warnings when I run the programs. Besides, for some reason, when I was testing the function I noticed the latitude components of the Sun do not return 0, but can be several (up to 6 seconds of arc). Not sure why is that, and what does it mean about the reliability and accuracy of the longitude component that was used in this software.

Answer 2

I took a slightly different approach than D_E did. I used VSOP87 and, rather than using a fixed interval, computed the angle for 1,000,000 random days between the year 1000 and 3000. The result is similar to what he got: 89.97707654083075.

function sub(a,b){
    const t=new Array();
    t[0]=a[0]-b[0];
    t[1]=a[1]-b[1];
    t[2]=a[2]-b[2];
    return t;
}

function length(v){
    return Math.sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
}

function norm(v){
    const t=new Array();
    const l=length(v);
    t[0]=v[0]/l;
    t[1]=v[1]/l;
    t[2]=v[2]/l;
    return t;
}

function getAngle(day){
    const t = day / 365250.0;
    const earth=vsop87a_full.getEarth(t);
    const emb=vsop87a_full.getEmb(t);
    let moon=vsop87a_full.getMoon(earth,emb);
    let sun=[0,0,0];

    //Convert to geocentric coordinates
    sun=norm(sub(sun,earth));
    moon=norm(sub(moon,earth));

    //Computes the dot product using only x,y components
    dot=sun[0]*moon[0] + sun[1]*moon[1];

    angle=Math.acos(dot)*180/Math.PI;
    return angle;
}

function computeAverage(){
    const max=365250;
    const min=-max;

    const itterations=1000000;
    let accumulator=0;
    for(let i=0;i<itterations;i++){
        const r=Math.random()*(max-min)-max;
        accumulator+=getAngle(r);
    }
    console.log(accumulator/itterations);
}

computeAverage();