use strict;
use warnings;

our $ABSTOL = 0.0000000001;
our $PI2    = 6.28318530717958648;

#
# evaluates the taylor expansion of sin(x) by
# first performing range reduction, and then
# updating the numerator, denominator, and 
# partial sum at each iteration.
#
sub taylor_sine
{  
  my $x = shift;
  
  # sine is periodic, so map domain to [-x, x]
  $x -= int($x / $PI2) * $PI2;

  # local vars  
  my ($s, $t, $n, $d, $k) = 
     ($x,  0, $x,  1,  1);
    
  do
  {
    # save previous term
    $t = $s;
    
    # update numerator and denominator
    $n *= $x * $x;
    $d *= ++$k;
    $d *= ++$k;
    
    # divide (odd) iterator by 2 and check if odd
    if (($k >> 1) & 1) { $s -= $n / $d }
                  else { $s += $n / $d }
    
  }  
  until abs($t - $s) <= $ABSTOL;
  
  return $s;
}

#
# iteratively calculates sin(x) through the triple
# angle formula, first performing range reduction
#
# MUCH faster than the recursive implementation
#
sub triple_sine
{
  my $x = shift;  
  
  # sine is periodic, so map domain to [-x, x]
  $x -= int($x / $PI2) * $PI2;
  
  # recursion depth counter
  my $n = 0;
  
  # find our base case
  while (abs($x) > $ABSTOL and ++$n)
  {
    $x /= 3;    
  }
  
  # evaluate back up our expression tree
  while ($n--)
  {
    $x = 3 * $x - 4 * $x * $x * $x;
  }
  
  return $x;
}

die "\nusage:\n\t\tperl $0 <degrees>\n"
  unless scalar @ARGV and $ARGV[0] =~ /^[-0-9.]+$/;

printf("\ntaylor_sine(%f) = %4.12f\n", $ARGV[0], 
  taylor_sine($ARGV[0]));
  
printf("\ntriple_sine(%f) = %4.12f\n", $ARGV[0], 
  triple_sine($ARGV[0]));

#!/usr/bin/env python

from __future__ import division
from itertools import count, takewhile
from operator import mul

def factorial(n):
    return reduce(mul, xrange(2, n + 1), 1)

def sin_taylor(x, eps):
    a = lambda k: pow(x, 2 * k + 1) / factorial(2 * k + 1)
    return sum(pow(-1, k) * a(k) for k in takewhile(lambda k: a(k) > eps,
        count()))

def sin_limit(x, eps):
    #Loses accuracy if eps < 1e-6...
    if x < eps:
        return eps
    else:
        return 3 * sin_limit(x / 3, eps) - 4 * pow(sin_limit(x / 3, eps), 3)

USING: kernel math math.constants math.libm locals
       arrays sequences lists lists.lazy ;
IN: sines

CONSTANT: epsilon 1e-7

: normalize-theta  ( x -- x )
    [let 1 :> sign!
      dup 0 <
        [ -1 *  -1 sign! ]  when

      pi 2 *  fmod

      dup pi >
        [ 2 pi * - ] when

      sign *
    ] ;


! create the lazy list of taylor terms (not so simple :)

: numerators  ( x -- lazy-list )
    dup 2array  [ first2
                  over *
                  over *
                  -1 *
                  2array
                ] lfrom-by  [ second ] lazy-map ;

: denominators  ( -- lazy-list )
    { 1 1 }  [ first2
               [ 1 + ] dip over *
               [ 1 + ] dip over *
               2array
             ] lfrom-by  [ second ] lazy-map ;

: taylor-terms ( x -- lazy-list )
    numerators denominators lzip [ first2 / ] lazy-map ;

: taylor-sine ( x -- x )
   >float normalize-theta taylor-terms  [ abs epsilon < ] luntil  0 [ + ] foldl ;


! sin x = 3 sin (x/3) - 4 sin^3 (x/3)

: sine  ( x -- x )
    dup abs epsilon >
      [ 3.0 / sine [ 3 * ] [ dup sq * 4 * ] bi - ]          
    when ;

Session:

( scratchpad ) pi 4 / sin .
0.7071067811865475
( scratchpad ) pi 4 / sine .
0.7071067811865475
( scratchpad ) pi 4 / taylor-sine .
0.7071067811796195
( scratchpad ) 1 sin .
0.8414709848078965
( scratchpad ) 1 sine .
0.8414709848078971
( scratchpad ) 1 taylor-sine .
0.841470984648068
( scratchpad ) 100 sin .
-0.5063656411097588
( scratchpad ) 100 sine .
-0.5063656411096491
( scratchpad ) 100 taylor-sine .
-0.5063656411334029
( scratchpad ) pi 1.5 * sin .
-1.0
( scratchpad ) pi 1.5 * sine .
-1.0
( scratchpad ) pi 1.5 * taylor-sine .
-1.00000000066278
( scratchpad ) 

def reduce_range( x ):
    sign,x = (1, x) if x >= 0 else (-1, -x)
    
    if x >= 2*pi: x -= int(x/2/pi) * pi
    if x > pi: x = x - 2*pi
    
    return x if sign>0 else -x


def sin_taylor( x, eps=1.0e-7 ):
    x = reduce_range( x )        
    x2 = x*x
    sinx = 0
    num, den, k, sign = ( float( x ), 1.0, 3.0, 1 )
    
    while True:
        delta = num / den
        sinx += sign * delta

        if delta < eps: break

        num, den, k, sign = ( num * x2, den*k*(k-1), k+2, -sign )

    return sinx

def sin_3angle( x, eps=1e-7 ):

    def _3angle( x ):
        if x < eps:
            return x
        else:
            f = _3angle( x/3.0 )
            return f * ( 3 - 4*f*f )

    return _3angle( reduce_range( x ) )

http://pastie.org/777280

let epsilon = 1e-7
let pi = 3.141592654

let sin (x:float) =
let rec series sum f d v k2 =
let next = f * d / float v
if abs(next) < epsilon then
sum + next
else
series (sum + next) (-f) (d * x * x) (v * (k2 + 1) * (k2 + 2)) (k2 + 2)
series 0.0 1.0 1.0 1 1

let rec sin' x =
if abs(x) float
val sin’ : float -> float

> sin 1.0;;
val it : float = 0.8414709846
> sin’ 1.0;;
val it : float = 0.8414709848