ronnie
2022-10-23 c843c92e9e45fb6ff0fc60f21f9832819bec8e23
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
/*
 * Single-precision cos function.
 *
 * Copyright (c) 2018, Arm Limited.
 * SPDX-License-Identifier: MIT
 */
 
#if WANT_SINGLEPREC
#include "single/s_cosf.c"
#else
 
#include <stdint.h>
#include <math.h>
#include "math_config.h"
#include "sincosf.h"
 
/* Fast cosf implementation.  Worst-case ULP is 0.5607, maximum relative
   error is 0.5303 * 2^-23.  A single-step range reduction is used for
   small values.  Large inputs have their range reduced using fast integer
   arithmetic.  */
float
cosf (float y)
{
  double x = y;
  double s;
  int n;
  const sincos_t *p = &__sincosf_table[0];
 
  if (abstop12 (y) < abstop12 (pio4))
    {
      double x2 = x * x;
 
      if (unlikely (abstop12 (y) < abstop12 (0x1p-12f)))
   return 1.0f;
 
      return sinf_poly (x, x2, p, 1);
    }
  else if (likely (abstop12 (y) < abstop12 (120.0f)))
    {
      x = reduce_fast (x, p, &n);
 
      /* Setup the signs for sin and cos.  */
      s = p->sign[n & 3];
 
      if (n & 2)
   p = &__sincosf_table[1];
 
      return sinf_poly (x * s, x * x, p, n ^ 1);
    }
  else if (abstop12 (y) < abstop12 (INFINITY))
    {
      uint32_t xi = asuint (y);
      int sign = xi >> 31;
 
      x = reduce_large (xi, &n);
 
      /* Setup signs for sin and cos - include original sign.  */
      s = p->sign[(n + sign) & 3];
 
      if ((n + sign) & 2)
   p = &__sincosf_table[1];
 
      return sinf_poly (x * s, x * x, p, n ^ 1);
    }
  else
    return __math_invalidf (y);
}
 
#endif