Commit | Line | Data |
---|---|---|

b34b60bc JS |
1 | /* k_tanf.c -- float version of k_tan.c |

2 | * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com. | |

1a3b704c | 3 | * Optimized by Bruce D. Evans. |

b34b60bc JS |
4 | */ |

5 | ||

6 | /* | |

7 | * ==================================================== | |

1a3b704c | 8 | * Copyright 2004 Sun Microsystems, Inc. All Rights Reserved. |

b34b60bc | 9 | * |

b34b60bc JS |
10 | * Permission to use, copy, modify, and distribute this |

11 | * software is freely granted, provided that this notice | |

12 | * is preserved. | |

13 | * ==================================================== | |

6ff43c94 PA |
14 | * |

15 | * $FreeBSD: head/lib/msun/src/k_tanf.c 239192 2012-08-11 11:13:48Z dim $ | |

b34b60bc JS |
16 | */ |

17 | ||

6ff43c94 | 18 | #include "math.h" |

b34b60bc | 19 | #include "math_private.h" |

1a3b704c JM |
20 | |

21 | /* |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]). */ | |

22 | static const double | |

b34b60bc | 23 | T[] = { |

1a3b704c JM |
24 | 0x15554d3418c99f.0p-54, /* 0.333331395030791399758 */ |

25 | 0x1112fd38999f72.0p-55, /* 0.133392002712976742718 */ | |

26 | 0x1b54c91d865afe.0p-57, /* 0.0533812378445670393523 */ | |

27 | 0x191df3908c33ce.0p-58, /* 0.0245283181166547278873 */ | |

28 | 0x185dadfcecf44e.0p-61, /* 0.00297435743359967304927 */ | |

29 | 0x1362b9bf971bcd.0p-59, /* 0.00946564784943673166728 */ | |

b34b60bc JS |
30 | }; |

31 | ||

6ff43c94 PA |
32 | #ifdef INLINE_KERNEL_TANDF |

33 | static __inline | |

34 | #endif | |

35 | float | |

1a3b704c | 36 | __kernel_tandf(double x, int iy) |

b34b60bc | 37 | { |

1a3b704c JM |
38 | double z,r,w,s,t,u; |

39 | ||

b34b60bc | 40 | z = x*x; |

1a3b704c JM |
41 | /* |

42 | * Split up the polynomial into small independent terms to give | |

43 | * opportunities for parallel evaluation. The chosen splitting is | |

44 | * micro-optimized for Athlons (XP, X64). It costs 2 multiplications | |

45 | * relative to Horner's method on sequential machines. | |

46 | * | |

47 | * We add the small terms from lowest degree up for efficiency on | |

48 | * non-sequential machines (the lowest degree terms tend to be ready | |

49 | * earlier). Apart from this, we don't care about order of | |

50 | * operations, and don't need to to care since we have precision to | |

51 | * spare. However, the chosen splitting is good for accuracy too, | |

52 | * and would give results as accurate as Horner's method if the | |

53 | * small terms were added from highest degree down. | |

54 | */ | |

55 | r = T[4]+z*T[5]; | |

56 | t = T[2]+z*T[3]; | |

57 | w = z*z; | |

b34b60bc | 58 | s = z*x; |

1a3b704c JM |
59 | u = T[0]+z*T[1]; |

60 | r = (x+s*u)+(s*w)*(t+w*r); | |

61 | if(iy==1) return r; | |

62 | else return -1.0/r; | |

b34b60bc | 63 | } |