contrib/netbsd-tests/lib/libm/t_cbrt.c

   1 /* $NetBSD: t_cbrt.c,v 1.3 2014/03/03 10:39:08 martin 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 #include <sys/cdefs.h>
  32 __RCSID("$NetBSD: t_cbrt.c,v 1.3 2014/03/03 10:39:08 martin Exp $");
  33
  34 #include <atf-c.h>
  35 #include <math.h>
  36 #include <stdio.h>
  37
  38 /*
  39  * cbrt(3)
  40  */
  41 ATF_TC(cbrt_nan);
  42 ATF_TC_HEAD(cbrt_nan, tc)
  43 {
  44         atf_tc_set_md_var(tc, "descr", "Test cbrt(NaN) == NaN");
  45 }
  46
  47 ATF_TC_BODY(cbrt_nan, tc)
  48 {
  49         const double x = 0.0L / 0.0L;
  50
  51         ATF_CHECK(isnan(x) != 0);
  52         ATF_CHECK(isnan(cbrt(x)) != 0);
  53 }
  54
  55 ATF_TC(cbrt_pow);
  56 ATF_TC_HEAD(cbrt_pow, tc)
  57 {
  58         atf_tc_set_md_var(tc, "descr", "Test cbrt(3) vs. pow(3)");
  59 }
  60
  61 ATF_TC_BODY(cbrt_pow, tc)
  62 {
  63         const double x[] = { 0.0, 0.005, 1.0, 99.0, 123.123, 9999.0 };
  64         const double eps = 1.0e-14;
  65         double y, z;
  66         size_t i;
  67
  68         for (i = 0; i < __arraycount(x); i++) {
  69
  70                 y = cbrt(x[i]);
  71                 z = pow(x[i], 1.0 / 3.0);
  72
  73                 if (fabs(y - z) > eps)
  74                         atf_tc_fail_nonfatal("cbrt(%0.03f) != "
  75                             "pow(%0.03f, 1/3)\n", x[i], x[i]);
  76         }
  77 }
  78
  79 ATF_TC(cbrt_inf_neg);
  80 ATF_TC_HEAD(cbrt_inf_neg, tc)
  81 {
  82         atf_tc_set_md_var(tc, "descr", "Test cbrt(-Inf) == -Inf");
  83 }
  84
  85 ATF_TC_BODY(cbrt_inf_neg, tc)
  86 {
  87         const double x = -1.0L / 0.0L;
  88         double y = cbrt(x);
  89
  90         ATF_CHECK(isinf(y) != 0);
  91         ATF_CHECK(signbit(y) != 0);
  92 }
  93
  94 ATF_TC(cbrt_inf_pos);
  95 ATF_TC_HEAD(cbrt_inf_pos, tc)
  96 {
  97         atf_tc_set_md_var(tc, "descr", "Test cbrt(+Inf) == +Inf");
  98 }
  99
 100 ATF_TC_BODY(cbrt_inf_pos, tc)
 101 {
 102         const double x = 1.0L / 0.0L;
 103         double y = cbrt(x);
 104
 105         ATF_CHECK(isinf(y) != 0);
 106         ATF_CHECK(signbit(y) == 0);
 107 }
 108
 109 ATF_TC(cbrt_zero_neg);
 110 ATF_TC_HEAD(cbrt_zero_neg, tc)
 111 {
 112         atf_tc_set_md_var(tc, "descr", "Test cbrt(-0.0) == -0.0");
 113 }
 114
 115 ATF_TC_BODY(cbrt_zero_neg, tc)
 116 {
 117         const double x = -0.0L;
 118         double y = cbrt(x);
 119
 120         if (fabs(y) > 0.0 || signbit(y) == 0)
 121                 atf_tc_fail_nonfatal("cbrt(-0.0) != -0.0");
 122 }
 123
 124 ATF_TC(cbrt_zero_pos);
 125 ATF_TC_HEAD(cbrt_zero_pos, tc)
 126 {
 127         atf_tc_set_md_var(tc, "descr", "Test cbrt(+0.0) == +0.0");
 128 }
 129
 130 ATF_TC_BODY(cbrt_zero_pos, tc)
 131 {
 132         const double x = 0.0L;
 133         double y = cbrt(x);
 134
 135         if (fabs(y) > 0.0 || signbit(y) != 0)
 136                 atf_tc_fail_nonfatal("cbrt(+0.0) != +0.0");
 137 }
 138
 139 /*
 140  * cbrtf(3)
 141  */
 142 ATF_TC(cbrtf_nan);
 143 ATF_TC_HEAD(cbrtf_nan, tc)
 144 {
 145         atf_tc_set_md_var(tc, "descr", "Test cbrtf(NaN) == NaN");
 146 }
 147
 148 ATF_TC_BODY(cbrtf_nan, tc)
 149 {
 150         const float x = 0.0L / 0.0L;
 151
 152         ATF_CHECK(isnan(x) != 0);
 153         ATF_CHECK(isnan(cbrtf(x)) != 0);
 154 }
 155
 156 ATF_TC(cbrtf_powf);
 157 ATF_TC_HEAD(cbrtf_powf, tc)
 158 {
 159         atf_tc_set_md_var(tc, "descr", "Test cbrtf(3) vs. powf(3)");
 160 }
 161
 162 ATF_TC_BODY(cbrtf_powf, tc)
 163 {
 164         const float x[] = { 0.0, 0.005, 1.0, 99.0, 123.123, 9999.0 };
 165         const float eps = 1.0e-5;
 166         float y, z;
 167         size_t i;
 168
 169         for (i = 0; i < __arraycount(x); i++) {
 170
 171                 y = cbrtf(x[i]);
 172                 z = powf(x[i], 1.0 / 3.0);
 173
 174                 if (fabsf(y - z) > eps)
 175                         atf_tc_fail_nonfatal("cbrtf(%0.03f) != "
 176                             "powf(%0.03f, 1/3)\n", x[i], x[i]);
 177         }
 178 }
 179
 180 ATF_TC(cbrtf_inf_neg);
 181 ATF_TC_HEAD(cbrtf_inf_neg, tc)
 182 {
 183         atf_tc_set_md_var(tc, "descr", "Test cbrtf(-Inf) == -Inf");
 184 }
 185
 186 ATF_TC_BODY(cbrtf_inf_neg, tc)
 187 {
 188         const float x = -1.0L / 0.0L;
 189         float y = cbrtf(x);
 190
 191         ATF_CHECK(isinf(y) != 0);
 192         ATF_CHECK(signbit(y) != 0);
 193 }
 194
 195 ATF_TC(cbrtf_inf_pos);
 196 ATF_TC_HEAD(cbrtf_inf_pos, tc)
 197 {
 198         atf_tc_set_md_var(tc, "descr", "Test cbrtf(+Inf) == +Inf");
 199 }
 200
 201 ATF_TC_BODY(cbrtf_inf_pos, tc)
 202 {
 203         const float x = 1.0L / 0.0L;
 204         float y = cbrtf(x);
 205
 206         ATF_CHECK(isinf(y) != 0);
 207         ATF_CHECK(signbit(y) == 0);
 208 }
 209
 210 ATF_TC(cbrtf_zero_neg);
 211 ATF_TC_HEAD(cbrtf_zero_neg, tc)
 212 {
 213         atf_tc_set_md_var(tc, "descr", "Test cbrtf(-0.0) == -0.0");
 214 }
 215
 216 ATF_TC_BODY(cbrtf_zero_neg, tc)
 217 {
 218         const float x = -0.0L;
 219         float y = cbrtf(x);
 220
 221         if (fabsf(y) > 0.0 || signbit(y) == 0)
 222                 atf_tc_fail_nonfatal("cbrtf(-0.0) != -0.0");
 223 }
 224
 225 ATF_TC(cbrtf_zero_pos);
 226 ATF_TC_HEAD(cbrtf_zero_pos, tc)
 227 {
 228         atf_tc_set_md_var(tc, "descr", "Test cbrtf(+0.0) == +0.0");
 229 }
 230
 231 ATF_TC_BODY(cbrtf_zero_pos, tc)
 232 {
 233         const float x = 0.0L;
 234         float y = cbrtf(x);
 235
 236         if (fabsf(y) > 0.0 || signbit(y) != 0)
 237                 atf_tc_fail_nonfatal("cbrtf(+0.0) != +0.0");
 238 }
 239
 240 #if !defined(__FreeBSD__) || LDBL_PREC != 53
 241 /*
 242  * cbrtl(3)
 243  */
 244 ATF_TC(cbrtl_nan);
 245 ATF_TC_HEAD(cbrtl_nan, tc)
 246 {
 247         atf_tc_set_md_var(tc, "descr", "Test cbrtl(NaN) == NaN");
 248 }
 249
 250 ATF_TC_BODY(cbrtl_nan, tc)
 251 {
 252         const long double x = 0.0L / 0.0L;
 253
 254         ATF_CHECK(isnan(x) != 0);
 255         ATF_CHECK(isnan(cbrtl(x)) != 0);
 256 }
 257
 258 ATF_TC(cbrtl_powl);
 259 ATF_TC_HEAD(cbrtl_powl, tc)
 260 {
 261         atf_tc_set_md_var(tc, "descr", "Test cbrtl(3) vs. powl(3)");
 262 }
 263
 264 ATF_TC_BODY(cbrtl_powl, tc)
 265 {
 266         const long double x[] = { 0.0, 0.005, 1.0, 99.0, 123.123, 9999.0 };
 267         const long double eps = 1.0e-15;
 268         long double y, z;
 269         size_t i;
 270
 271         for (i = 0; i < __arraycount(x); i++) {
 272
 273                 y = cbrtl(x[i]);
 274 #ifdef __FreeBSD__
 275                 z = powl(x[i], (long double)1.0 / 3.0);
 276 #else
 277                 z = powl(x[i], 1.0 / 3.0);
 278 #endif
 279
 280                 if (fabsl(y - z) > eps * fabsl(1 + x[i]))
 281                         atf_tc_fail_nonfatal("cbrtl(%0.03Lf) != "
 282                             "powl(%0.03Lf, 1/3)\n", x[i], x[i]);
 283         }
 284 }
 285
 286 ATF_TC(cbrtl_inf_neg);
 287 ATF_TC_HEAD(cbrtl_inf_neg, tc)
 288 {
 289         atf_tc_set_md_var(tc, "descr", "Test cbrtl(-Inf) == -Inf");
 290 }
 291
 292 ATF_TC_BODY(cbrtl_inf_neg, tc)
 293 {
 294         const long double x = -1.0L / 0.0L;
 295         long double y = cbrtl(x);
 296
 297         ATF_CHECK(isinf(y) != 0);
 298         ATF_CHECK(signbit(y) != 0);
 299 }
 300
 301 ATF_TC(cbrtl_inf_pos);
 302 ATF_TC_HEAD(cbrtl_inf_pos, tc)
 303 {
 304         atf_tc_set_md_var(tc, "descr", "Test cbrtl(+Inf) == +Inf");
 305 }
 306
 307 ATF_TC_BODY(cbrtl_inf_pos, tc)
 308 {
 309         const long double x = 1.0L / 0.0L;
 310         long double y = cbrtl(x);
 311
 312         ATF_CHECK(isinf(y) != 0);
 313         ATF_CHECK(signbit(y) == 0);
 314 }
 315
 316 ATF_TC(cbrtl_zero_neg);
 317 ATF_TC_HEAD(cbrtl_zero_neg, tc)
 318 {
 319         atf_tc_set_md_var(tc, "descr", "Test cbrtl(-0.0) == -0.0");
 320 }
 321
 322 ATF_TC_BODY(cbrtl_zero_neg, tc)
 323 {
 324         const long double x = -0.0L;
 325         long double y = cbrtl(x);
 326
 327         if (fabsl(y) > 0.0 || signbit(y) == 0)
 328                 atf_tc_fail_nonfatal("cbrtl(-0.0) != -0.0");
 329 }
 330
 331 ATF_TC(cbrtl_zero_pos);
 332 ATF_TC_HEAD(cbrtl_zero_pos, tc)
 333 {
 334         atf_tc_set_md_var(tc, "descr", "Test cbrtl(+0.0) == +0.0");
 335 }
 336
 337 ATF_TC_BODY(cbrtl_zero_pos, tc)
 338 {
 339         const long double x = 0.0L;
 340         long double y = cbrtl(x);
 341
 342         if (fabsl(y) > 0.0 || signbit(y) != 0)
 343                 atf_tc_fail_nonfatal("cbrtl(+0.0) != +0.0");
 344 }
 345 #endif
 346
 347 ATF_TP_ADD_TCS(tp)
 348 {
 349
 350         ATF_TP_ADD_TC(tp, cbrt_nan);
 351         ATF_TP_ADD_TC(tp, cbrt_pow);
 352         ATF_TP_ADD_TC(tp, cbrt_inf_neg);
 353         ATF_TP_ADD_TC(tp, cbrt_inf_pos);
 354         ATF_TP_ADD_TC(tp, cbrt_zero_neg);
 355         ATF_TP_ADD_TC(tp, cbrt_zero_pos);
 356
 357         ATF_TP_ADD_TC(tp, cbrtf_nan);
 358         ATF_TP_ADD_TC(tp, cbrtf_powf);
 359         ATF_TP_ADD_TC(tp, cbrtf_inf_neg);
 360         ATF_TP_ADD_TC(tp, cbrtf_inf_pos);
 361         ATF_TP_ADD_TC(tp, cbrtf_zero_neg);
 362         ATF_TP_ADD_TC(tp, cbrtf_zero_pos);
 363
 364 #if !defined(__FreeBSD__) || LDBL_PREC != 53
 365         ATF_TP_ADD_TC(tp, cbrtl_nan);
 366         ATF_TP_ADD_TC(tp, cbrtl_powl);
 367         ATF_TP_ADD_TC(tp, cbrtl_inf_neg);
 368         ATF_TP_ADD_TC(tp, cbrtl_inf_pos);
 369         ATF_TP_ADD_TC(tp, cbrtl_zero_neg);
 370         ATF_TP_ADD_TC(tp, cbrtl_zero_pos);
 371 #endif
 372
 373         return atf_no_error();
 374 }