```11210 libm should be cstyle(1ONBLD) clean
```

 Split Close Expand all Collapse all
```          --- old/usr/src/lib/libm/common/R/__cosf.c
+++ new/usr/src/lib/libm/common/R/__cosf.c
```
 ↓ open down ↓ 14 lines elided ↑ open up ↑
```  15   15   * If applicable, add the following below this CDDL HEADER, with the
16   16   * fields enclosed by brackets "[]" replaced with your own identifying
18   18   *
19   19   * CDDL HEADER END
20   20   */
21   21
22   22  /*
24   24   */
25 +
25   26  /*
27   28   * Use is subject to license terms.
28   29   */
29   30
30   31  #include "libm.h"
31   32
32      -/* INDENT OFF */
33 +
33   34  /*
34   35   * float __k_cos(double x);
35   36   * kernel (float) cos function on [-pi/4, pi/4], pi/4 ~ 0.785398164
36   37   * Input x is in double and assumed to be bounded by ~pi/4 in magnitude.
37   38   *
38   39   * Method: Let z = x * x, then
39   40   *      C(x) = (C0 + C1*z + C2*z*z) * (C3 + C4*z + z*z)
40   41   * where
41   42   *      C0 =   1.09349482127188401868272000389539985058873853699e-0003
42   43   *      C1 =  -5.03324285989964979398034700054920226866107675091e-0004
```
 ↓ open down ↓ 2 lines elided ↑ open up ↑
```  45   46   *      C4 =  -3.63151270591815439197122504991683846785293207730e+0001
46   47   *
47   48   * The remez error is bound by  |cos(x) - C(x)| < 2**(-34.2)
48   49   *
49   50   * Constants:
50   51   * The hexadecimal values are the intended ones for the following constants.
51   52   * The decimal values may be used, provided that the compiler will convert
52   53   * from decimal to binary accurately enough to produce the hexadecimal values
53   54   * shown.
54   55   */
55      -/* INDENT ON */
56   56
57   57  static const double q[] = {
58      -/* C0 = */   1.09349482127188401868272000389539985058873853699e-0003,
59      -/* C1 = */  -5.03324285989964979398034700054920226866107675091e-0004,
60      -/* C2 = */   2.43792880266971107750418061559602239831538067410e-0005,
61      -/* C3 = */   9.14499072605666582228127405245558035523741471271e+0002,
62      -/* C4 = */  -3.63151270591815439197122504991683846785293207730e+0001,
63      -};
64      -
65      -#define C0      q[0]
66      -#define C1      q[1]
67      -#define C2      q[2]
68      -#define C3      q[3]
69      -#define C4      q[4]
58 +/* C0 = */
59 +        1.09349482127188401868272000389539985058873853699e-0003,
60 +/* C1 = */ -5.03324285989964979398034700054920226866107675091e-0004,
61 +/* C2 = */ 2.43792880266971107750418061559602239831538067410e-0005,
62 +/* C3 = */ 9.14499072605666582228127405245558035523741471271e+0002,
63 +/* C4 = */ -3.63151270591815439197122504991683846785293207730e+0001, };
64 +
65 +#define C0              q[0]
66 +#define C1              q[1]
67 +#define C2              q[2]
68 +#define C3              q[3]
69 +#define C4              q[4]
70   70
71   71  float
72      -__k_cosf(double x) {
72 +__k_cosf(double x)
73 +{
73   74          float ft;
74   75          double z;
75   76          int hx;
76   77
77      -        hx = ((int *) &x)[HIWORD];      /* hx = leading x  */
78 +        hx = ((int *)&x)[HIWORD];               /* hx = leading x  */
79 +
78   80          if ((hx & ~0x80000000) < 0x3f100000) {  /* |x| < 2**-14 */
79      -                ft = (float) 1;
80      -                if (((int) x) == 0)     /* raise inexact if x != 0 */
81 +                ft = (float)1;
82 +
83 +                if (((int)x) == 0)              /* raise inexact if x != 0 */
81   84                          return (ft);
82   85          }
86 +
83   87          z = x * x;
84      -        ft = (float) (((C0 + z * C1) + (z * z) * C2) * (C3 + z * (C4 + z)));
88 +        ft = (float)(((C0 + z * C1) + (z * z) * C2) * (C3 + z * (C4 + z)));
85   89          return (ft);
86   90  }
```
`XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX`