Since the Apollo 11 Code is on Github, i was able to find the code that looks like an implementation of sine and cosine functions: [see here for the command module](https://github.com/chrislgarry/Apollo-11/blob/27e2acf88a6345e2b1064c8b006a154363937050/Comanche055/SINGLE_PRECISION_SUBROUTINES.agc) and [here for the lunar lander](https://github.com/chrislgarry/Apollo-11/blob/27e2acf88a6345e2b1064c8b006a154363937050/Luminary099/SINGLE_PRECISION_SUBROUTINES.agc) (it looks like it is the same code).

For convenience, here is a copy of the code:

     # Page 1102
                BLOCK   02
    
    # SINGLE PRECISION SINE AND COSINE
    
                COUNT*  $$/INTER
    SPCOS       AD      HALF            # ARGUMENTS SCALED AT PI
    SPSIN       TS      TEMK
                TCF     SPT
                CS      TEMK
    SPT         DOUBLE
                TS      TEMK
                TCF     POLLEY
                XCH     TEMK
                INDEX   TEMK
                AD      LIMITS
                COM
                AD      TEMK
                TS      TEMK
                TCF     POLLEY
                TCF     ARG90
    POLLEY      EXTEND
                MP      TEMK
                TS      SQ
                EXTEND
                MP      C5/2
                AD      C3/2
                EXTEND
                MP      SQ
                AD      C1/2
                EXTEND
                MP      TEMK
                DDOUBL
                TS      TEMK
                TC      Q
    ARG90       INDEX   A
                CS      LIMITS
                TC      Q       # RESULT SCALED AT 1.
     

The comment

    # SINGLE PRECISION SINE AND COSINE

indicates, that the following is indeed an implementation of the sine and cosine functions.
Information about the type of assembler used, can be found [on Wikipedia](https://en.wikipedia.org/wiki/Apollo_Guidance_Computer)


**Partial explanation of the code:**

The subroutine `SPSIN` actually calculates $\sin(\pi x)$, and `SPCOS` calculates $\cos(\pi x)$.
The function `SPCOS` first adds one half to the input, and then proceeds to calculate the sine
(this is valid because of $\cos(\pi x) = \sin(\pi (x+\tfrac12))$).
The argument is doubled at the begin of the `SPT` subroutine.
That is why we now have to calculate $\sin(\tfrac\pi2 y)$ for $y=2x$.

The function `POLLEY` calculates a taylor polynomial approximation of $\tfrac12\sin(\tfrac\pi2 x)$.
First, we store $x^2$ in the register SQ (where $x$ denotes the input).
This is used to calculate the polynomial
$$
  ((( C_{5/2}  x^2 ) + C_{3/2} ) x^2 + C_{1/2}) x.
$$
The values for the constants can be [found in the same github repository](https://github.com/chrislgarry/Apollo-11/blob/27e2acf88a6345e2b1064c8b006a154363937050/Comanche055/FIXED_FIXED_CONSTANT_POOL.agc) and are

$$
C_{5/2}= .0363551 \approx \big(\frac\pi2\big)^5 \cdot \frac1{2\cdot 5!}\\
C_{3/2}= -.3216147 \approx -\big(\frac\pi2\big)^3 \cdot \frac1{2\cdot 3!}\\
C_{1/2}= .7853134 \approx \frac\pi2 \cdot \frac12\\
$$

which look like the first taylor coefficients for the function
$\frac12 \sin(\tfrac\pi2 x)$.
These values are not exact, but I suspect that the error comes from the low bit resolution.

Finally, the result is doubled with the `DDOUBL` command, and the subroutine `POLLEY` returns an approximation to
$\sin(\tfrac\pi2 x)$.

As for the scaling (first halve, then double, ...), @Christopher mentioned in the comments, that the 16-Bit Floating-Point could only store values from -1 to +1. Therefore, scaling is necessary.

**How accurate is this taylor approximation?** [Here][1] you can see a plot on WolframAlpha, and it looks like a good approximation for $x$ from $-0.6$ to $+.6$.


  [1]: http://www.wolframalpha.com/input/?i=plot%20sin(pi%20x),%202*((%20(x*2)%5E2%20*%20.0363551%20-%20.3216147)%20*%20(x*2)%5E2%20%2B%20.7853134)*(2x)