tests/lib/libm/t_sin.c

   1 /* $NetBSD: t_sin.c,v 1.3 2011/09/14 13:29:58 jruoho Exp $ */
   2
   3 /*-
   4  * Copyright (c) 2011 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Jukka Ruohonen.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <atf-c.h>
  33 #include <math.h>
  34
  35 static const struct {
  36         int             angle;
  37         double          x;
  38         double          y;
  39 } angles[] = {
  40         { -180, -3.141592653589793,  0.0000000000000000 },
  41         { -135, -2.356194490192345, -0.7071067811865476 },
  42         {  -90, -1.570796326794897, -1.0000000000000000 },
  43         {  -45, -0.785398163397448, -0.7071067811865476 },
  44         {    0,  0.000000000000000,  0.0000000000000000 },
  45         {   30,  0.523598775598299,  0.5000000000000000 },
  46         {   45,  0.785398163397448,  0.7071067811865476 },
  47         {   60,  1.047197551196598,  0.8660254037844386 },
  48         {   90,  1.570796326794897,  1.0000000000000000 },
  49         {  120,  2.094395102393195,  0.8660254037844386 },
  50         {  135,  2.356194490192345,  0.7071067811865476 },
  51         {  150,  2.617993877991494,  0.5000000000000000 },
  52         {  180,  3.141592653589793,  0.0000000000000000 },
  53         {  270,  4.712388980384690, -1.0000000000000000 },
  54         {  360,  6.283185307179586,  0.0000000000000000 }
  55 };
  56
  57 /*
  58  * sin(3)
  59  */
  60 ATF_TC(sin_angles);
  61 ATF_TC_HEAD(sin_angles, tc)
  62 {
  63         atf_tc_set_md_var(tc, "descr", "Test some selected angles");
  64 }
  65
  66 ATF_TC_BODY(sin_angles, tc)
  67 {
  68         const double eps = 1.0e-15;
  69         size_t i;
  70
  71         for (i = 0; i < __arraycount(angles); i++) {
  72
  73                 if (fabs(sin(angles[i].x) - angles[i].y) > eps)
  74                         atf_tc_fail_nonfatal("sin(%d deg) != %0.01f",
  75                             angles[i].angle, angles[i].y);
  76         }
  77 }
  78
  79 ATF_TC(sin_nan);
  80 ATF_TC_HEAD(sin_nan, tc)
  81 {
  82         atf_tc_set_md_var(tc, "descr", "Test sin(NaN) == NaN");
  83 }
  84
  85 ATF_TC_BODY(sin_nan, tc)
  86 {
  87 #ifndef __vax__
  88         const double x = 0.0L / 0.0L;
  89
  90         ATF_CHECK(isnan(x) != 0);
  91         ATF_CHECK(isnan(sin(x)) != 0);
  92 #endif
  93 }
  94
  95 ATF_TC(sin_inf_neg);
  96 ATF_TC_HEAD(sin_inf_neg, tc)
  97 {
  98         atf_tc_set_md_var(tc, "descr", "Test sin(-Inf) == NaN");
  99 }
 100
 101 ATF_TC_BODY(sin_inf_neg, tc)
 102 {
 103 #ifndef __vax__
 104         const double x = -1.0L / 0.0L;
 105
 106         ATF_CHECK(isnan(sin(x)) != 0);
 107 #endif
 108 }
 109
 110 ATF_TC(sin_inf_pos);
 111 ATF_TC_HEAD(sin_inf_pos, tc)
 112 {
 113         atf_tc_set_md_var(tc, "descr", "Test sin(+Inf) == NaN");
 114 }
 115
 116 ATF_TC_BODY(sin_inf_pos, tc)
 117 {
 118 #ifndef __vax__
 119         const double x = 1.0L / 0.0L;
 120
 121         ATF_CHECK(isnan(sin(x)) != 0);
 122 #endif
 123 }
 124
 125
 126 ATF_TC(sin_zero_neg);
 127 ATF_TC_HEAD(sin_zero_neg, tc)
 128 {
 129         atf_tc_set_md_var(tc, "descr", "Test sin(-0.0) == -0.0");
 130 }
 131
 132 ATF_TC_BODY(sin_zero_neg, tc)
 133 {
 134 #ifndef __vax__
 135         const double x = -0.0L;
 136
 137         ATF_CHECK(sin(x) == x);
 138 #endif
 139 }
 140
 141 ATF_TC(sin_zero_pos);
 142 ATF_TC_HEAD(sin_zero_pos, tc)
 143 {
 144         atf_tc_set_md_var(tc, "descr", "Test sin(+0.0) == +0.0");
 145 }
 146
 147 ATF_TC_BODY(sin_zero_pos, tc)
 148 {
 149 #ifndef __vax__
 150         const double x = 0.0L;
 151
 152         ATF_CHECK(sin(x) == x);
 153 #endif
 154 }
 155
 156 /*
 157  * sinf(3)
 158  */
 159 ATF_TC(sinf_angles);
 160 ATF_TC_HEAD(sinf_angles, tc)
 161 {
 162         atf_tc_set_md_var(tc, "descr", "Test some selected angles");
 163 }
 164
 165 ATF_TC_BODY(sinf_angles, tc)
 166 {
 167         const float eps = 1.0e-6;
 168         float x, y;
 169         size_t i;
 170
 171         for (i = 0; i < __arraycount(angles); i++) {
 172
 173                 x = angles[i].x;
 174                 y = angles[i].y;
 175
 176                 if (fabsf(sinf(x) - y) > eps)
 177                         atf_tc_fail_nonfatal("sinf(%d deg) != %0.01f",
 178                             angles[i].angle, angles[i].y);
 179         }
 180 }
 181
 182 ATF_TC(sinf_nan);
 183 ATF_TC_HEAD(sinf_nan, tc)
 184 {
 185         atf_tc_set_md_var(tc, "descr", "Test sinf(NaN) == NaN");
 186 }
 187
 188 ATF_TC_BODY(sinf_nan, tc)
 189 {
 190 #ifndef __vax__
 191         const float x = 0.0L / 0.0L;
 192
 193         ATF_CHECK(isnan(x) != 0);
 194         ATF_CHECK(isnan(sinf(x)) != 0);
 195 #endif
 196 }
 197
 198 ATF_TC(sinf_inf_neg);
 199 ATF_TC_HEAD(sinf_inf_neg, tc)
 200 {
 201         atf_tc_set_md_var(tc, "descr", "Test sinf(-Inf) == NaN");
 202 }
 203
 204 ATF_TC_BODY(sinf_inf_neg, tc)
 205 {
 206 #ifndef __vax__
 207         const float x = -1.0L / 0.0L;
 208
 209         if (isnan(sinf(x)) == 0) {
 210                 atf_tc_expect_fail("PR lib/45362");
 211                 atf_tc_fail("sinf(-Inf) != NaN");
 212         }
 213 #endif
 214 }
 215
 216 ATF_TC(sinf_inf_pos);
 217 ATF_TC_HEAD(sinf_inf_pos, tc)
 218 {
 219         atf_tc_set_md_var(tc, "descr", "Test sinf(+Inf) == NaN");
 220 }
 221
 222 ATF_TC_BODY(sinf_inf_pos, tc)
 223 {
 224 #ifndef __vax__
 225         const float x = 1.0L / 0.0L;
 226
 227         if (isnan(sinf(x)) == 0) {
 228                 atf_tc_expect_fail("PR lib/45362");
 229                 atf_tc_fail("sinf(+Inf) != NaN");
 230         }
 231 #endif
 232 }
 233
 234
 235 ATF_TC(sinf_zero_neg);
 236 ATF_TC_HEAD(sinf_zero_neg, tc)
 237 {
 238         atf_tc_set_md_var(tc, "descr", "Test sinf(-0.0) == -0.0");
 239 }
 240
 241 ATF_TC_BODY(sinf_zero_neg, tc)
 242 {
 243 #ifndef __vax__
 244         const float x = -0.0L;
 245
 246         ATF_CHECK(sinf(x) == x);
 247 #endif
 248 }
 249
 250 ATF_TC(sinf_zero_pos);
 251 ATF_TC_HEAD(sinf_zero_pos, tc)
 252 {
 253         atf_tc_set_md_var(tc, "descr", "Test sinf(+0.0) == +0.0");
 254 }
 255
 256 ATF_TC_BODY(sinf_zero_pos, tc)
 257 {
 258 #ifndef __vax__
 259         const float x = 0.0L;
 260
 261         ATF_CHECK(sinf(x) == x);
 262 #endif
 263 }
 264
 265 ATF_TP_ADD_TCS(tp)
 266 {
 267
 268         ATF_TP_ADD_TC(tp, sin_angles);
 269         ATF_TP_ADD_TC(tp, sin_nan);
 270         ATF_TP_ADD_TC(tp, sin_inf_neg);
 271         ATF_TP_ADD_TC(tp, sin_inf_pos);
 272         ATF_TP_ADD_TC(tp, sin_zero_neg);
 273         ATF_TP_ADD_TC(tp, sin_zero_pos);
 274
 275         ATF_TP_ADD_TC(tp, sinf_angles);
 276         ATF_TP_ADD_TC(tp, sinf_nan);
 277         ATF_TP_ADD_TC(tp, sinf_inf_neg);
 278         ATF_TP_ADD_TC(tp, sinf_inf_pos);
 279         ATF_TP_ADD_TC(tp, sinf_zero_neg);
 280         ATF_TP_ADD_TC(tp, sinf_zero_pos);
 281
 282         return atf_no_error();
 283 }