D10765.id28446.diff
No OneTemporary
Actions

Size

35 KB

Referenced Files

None

Subscribers

None

D10765.id28446.diff
View Options

	Index: lib/msun/Makefile
	===================================================================
	--- lib/msun/Makefile
	+++ lib/msun/Makefile
	@@ -73,7 +73,8 @@
	s_nexttowardf.c s_remquo.c s_remquof.c \
	s_rint.c s_rintf.c s_round.c s_roundf.c \
	s_scalbln.c s_scalbn.c s_scalbnf.c s_signbit.c \
	- s_signgam.c s_significand.c s_significandf.c s_sin.c s_sinf.c \
	+ s_signgam.c s_significand.c s_significandf.c s_sin.c \
	+ s_sincos.c s_sincosf.c s_sinf.c \
	s_tan.c s_tanf.c s_tanh.c s_tanhf.c s_tgammaf.c s_trunc.c s_truncf.c \
	w_cabs.c w_cabsf.c w_drem.c w_dremf.c

	@@ -104,7 +105,8 @@
	s_csqrtl.c s_erfl.c s_exp2l.c s_expl.c s_floorl.c s_fmal.c \
	s_fmaxl.c s_fminl.c s_frexpl.c s_logbl.c s_logl.c s_nanl.c \
	s_nextafterl.c s_nexttoward.c s_remquol.c s_rintl.c s_roundl.c \
	- s_scalbnl.c s_sinl.c s_tanhl.c s_tanl.c s_truncl.c w_cabsl.c
	+ s_scalbnl.c s_sinl.c s_sincosl.c \
	+ s_tanhl.c s_tanl.c s_truncl.c w_cabsl.c
	.endif

	# C99 complex functions
	@@ -137,7 +139,8 @@
	fma.3 fmax.3 fmod.3 hypot.3 ieee.3 ieee_test.3 ilogb.3 j0.3 \
	lgamma.3 log.3 lrint.3 lround.3 math.3 nan.3 \
	nextafter.3 remainder.3 rint.3 \
	- round.3 scalbn.3 signbit.3 sin.3 sinh.3 sqrt.3 tan.3 tanh.3 trunc.3 \
	+ round.3 scalbn.3 signbit.3 sin.3 sincos.3 \
	+ sinh.3 sqrt.3 tan.3 tanh.3 trunc.3 \
	complex.3

	MLINKS+=acos.3 acosf.3 acos.3 acosl.3
	@@ -215,6 +218,7 @@
	MLINKS+=scalbn.3 scalbln.3 scalbn.3 scalblnf.3 scalbn.3 scalblnl.3
	MLINKS+=scalbn.3 scalbnf.3 scalbn.3 scalbnl.3
	MLINKS+=sin.3 sinf.3 sin.3 sinl.3
	+MLINKS+=sincos.3 sincosf.3 sin.3 sincosl.3
	MLINKS+=sinh.3 sinhf.3 sinh.3 sinhl.3
	MLINKS+=sqrt.3 cbrt.3 sqrt.3 cbrtf.3 sqrt.3 cbrtl.3 sqrt.3 sqrtf.3 \
	sqrt.3 sqrtl.3
	Index: lib/msun/Symbol.map
	===================================================================
	--- lib/msun/Symbol.map
	+++ lib/msun/Symbol.map
	@@ -294,4 +294,7 @@
	casinl;
	catanl;
	catanhl;
	+ sincos;
	+ sincosf;
	+ sincosl;
	};
	Index: lib/msun/man/sincos.3
	===================================================================
	--- /dev/null
	+++ lib/msun/man/sincos.3
	@@ -0,0 +1,81 @@
	+.\" Copyright (c) 2011 Steven G. Kargl.
	+.\"
	+.\" Redistribution and use in source and binary forms, with or without
	+.\" modification, are permitted provided that the following conditions
	+.\" are met:
	+.\" 1. Redistributions of source code must retain the above copyright
	+.\" notice, this list of conditions and the following disclaimer.
	+.\" 2. Redistributions in binary form must reproduce the above copyright
	+.\" notice, this list of conditions and the following disclaimer in the
	+.\" documentation and/or other materials provided with the distribution.
	+.\"
	+.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	+.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	+.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	+.\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	+.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	+.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	+.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	+.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	+.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	+.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	+.\" SUCH DAMAGE.
	+.\"
	+.\"
	+.Dd March 12, 2011
	+.Dt SINCOS 3
	+.Os
	+.Sh NAME
	+.Nm sincos ,
	+.Nm sincosf ,
	+.Nm sincosl
	+.Nd sine and cosine functions
	+.Sh LIBRARY
	+.Lb libm
	+.Sh SYNOPSIS
	+.In math.h
	+.Ft void
	+.Fn sincos "double x" "double s" "double c"
	+.Ft void
	+.Fn sincosf "float x" "float s" "float c"
	+.Ft void
	+.Fn sincosl "long double x" "long double s" "long double c"
	+.Sh DESCRIPTION
	+The
	+.Fn sincos ,
	+.Fn sincosf ,
	+and
	+.Fn sincosl
	+functions compute the sine and cosine of
	+.Fa x .
	+Using these functions allows argument reduction to occur only
	+once instead of twice with individual invocations of
	+.Fn sin
	+and
	+.Fn cos .
	+Like
	+.Fn sin
	+and
	+.Fn cos ,
	+a large magnitude argument may yield a result with little
	+or no significance.
	+.Sh RETURN VALUES
	+Upon returning from
	+.Fn sincos ,
	+.Fn sincosf ,
	+and
	+.Fn sincosl ,
	+the memory pointed to by
	+.Ar "*s"
	+and
	+.Ar "*c"
	+are assigned the values of sine and cosine, respectively.
	+.Sh SEE ALSO
	+.Xr cos 3 ,
	+.Xr sin 3 ,
	+.Sh HISTORY
	+These functions were added to
	+.Fx 9.0
	+to aid in writing various complex function contained in
	+.St -isoC-99 .
	+
	Index: lib/msun/src/k_sincos.h
	===================================================================
	--- /dev/null
	+++ lib/msun/src/k_sincos.h
	@@ -0,0 +1,49 @@
	+/*
	+ * ====================================================
	+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
	+ *
	+ * Developed at SunSoft, a Sun Microsystems, Inc. business.
	+ * Permission to use, copy, modify, and distribute this
	+ * software is freely granted, provided that this notice
	+ * is preserved.
	+ * ====================================================
	+ *
	+ * k_sin.c and k_cos.c merged by Steven G. Kargl.
	+ */
	+
	+static const double
	+S1 = -1.66666666666666324348e-01, /* 0xBFC55555, 0x55555549 */
	+S2 = 8.33333333332248946124e-03, /* 0x3F811111, 0x1110F8A6 */
	+S3 = -1.98412698298579493134e-04, /* 0xBF2A01A0, 0x19C161D5 */
	+S4 = 2.75573137070700676789e-06, /* 0x3EC71DE3, 0x57B1FE7D */
	+S5 = -2.50507602534068634195e-08, /* 0xBE5AE5E6, 0x8A2B9CEB */
	+S6 = 1.58969099521155010221e-10; /* 0x3DE5D93A, 0x5ACFD57C */
	+
	+static const double
	+C1 = 4.16666666666666019037e-02, /* 0x3FA55555, 0x5555554C */
	+C2 = -1.38888888888741095749e-03, /* 0xBF56C16C, 0x16C15177 */
	+C3 = 2.48015872894767294178e-05, /* 0x3EFA01A0, 0x19CB1590 */
	+C4 = -2.75573143513906633035e-07, /* 0xBE927E4F, 0x809C52AD */
	+C5 = 2.08757232129817482790e-09, /* 0x3E21EE9E, 0xBDB4B1C4 */
	+C6 = -1.13596475577881948265e-11; /* 0xBDA8FAE9, 0xBE8838D4 */
	+
	+static inline void
	+__kernel_sincos(double x, double y, int iy, double sn, double cs)
	+{
	+ double hz, r, v, w, z;
	+
	+ z = x * x;
	+ w = z * z;
	+ r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);
	+ v = z * x;
	+
	+ if (iy == 0)
	+ sn = x + v (S1 + z * r);
	+ else
	+ sn = x - ((z (y / 2 - v * r) - y) - v * S1);
	+
	+ r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));
	+ hz = z / 2;
	+ w = 1 - hz;
	+ cs = w + (((1 - w) - hz) + (z r - x * y));
	+}
	Index: lib/msun/src/k_sincosf.h
	===================================================================
	--- /dev/null
	+++ lib/msun/src/k_sincosf.h
	@@ -0,0 +1,40 @@
	+/*
	+ * ====================================================
	+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
	+ *
	+ * Developed at SunPro, a Sun Microsystems, Inc. business.
	+ * Permission to use, copy, modify, and distribute this
	+ * software is freely granted, provided that this notice
	+ * is preserved.
	+ * ====================================================
	+ *
	+ * k_sinf.c and k_cosf.c merged by Steven G. Kargl.
	+ */
	+
	+/* \|sin(x)/x - s(x)\| < 2*-37.5 (~[-4.89e-12, 4.824e-12]). /
	+static const double
	+S1 = -0x15555554cbac77.0p-55, /* -0.166666666416265235595 */
	+S2 = 0x111110896efbb2.0p-59, /* 0.0083333293858894631756 */
	+S3 = -0x1a00f9e2cae774.0p-65, /* -0.000198393348360966317347 */
	+S4 = 0x16cd878c3b46a7.0p-71; /* 0.0000027183114939898219064 */
	+
	+/* \|cos(x) - c(x)\| < 2*-34.1 (~[-5.37e-11, 5.295e-11]). /
	+static const double
	+C0 = -0x1ffffffd0c5e81.0p-54, /* -0.499999997251031003120 */
	+C1 = 0x155553e1053a42.0p-57, /* 0.0416666233237390631894 */
	+C2 = -0x16c087e80f1e27.0p-62, /* -0.00138867637746099294692 */
	+C3 = 0x199342e0ee5069.0p-68; /* 0.0000243904487962774090654 */
	+
	+static inline void
	+__kernel_sincosdf(double x, float sn, float cs)
	+{
	+ double r, s, w, z;
	+
	+ z = x * x;
	+ w = z * z;
	+ r = S3 + z * S4;
	+ s = z * x;
	+ sn = (x + s (S1 + z * S2)) + s * w * r;
	+ r = C2 + z * C3;
	+ cs = ((1 + z C0) + w * C1) + (w * z) * r;
	+}
	Index: lib/msun/src/k_sincosl.h
	===================================================================
	--- /dev/null
	+++ lib/msun/src/k_sincosl.h
	@@ -0,0 +1,131 @@
	+/*
	+ * ====================================================
	+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
	+ * Copyright (c) 2008 Steven G. Kargl, David Schultz, Bruce D. Evans.
	+ *
	+ * Developed at SunSoft, a Sun Microsystems, Inc. business.
	+ * Permission to use, copy, modify, and distribute this
	+ * software is freely granted, provided that this notice
	+ * is preserved.
	+ * ====================================================
	+ *
	+ * k_sinl.c and k_cosl.c merged by Steven G. Kargl
	+ */
	+
	+#if LDBL_MANT_DIG == 64 /* ld80 version of k_sincosl.c. */
	+
	+#if defined(__amd64__) \|\| defined(__i386__)
	+/* Long double constants are slow on these arches, and broken on i386. */
	+static const volatile double
	+C1hi = 0.041666666666666664, /* 0x15555555555555.0p-57 */
	+C1lo = 2.2598839032744733e-18, /* 0x14d80000000000.0p-111 */
	+S1hi = -0.16666666666666666, /* -0x15555555555555.0p-55 */
	+S1lo = -9.2563760475949941e-18; /* -0x15580000000000.0p-109 */
	+#define S1 ((long double)S1hi + S1lo)
	+#define C1 ((long double)C1hi + C1lo)
	+#else
	+static const long double
	+C1 = 0.0416666666666666666136L; /* 0xaaaaaaaaaaaaaa9b.0p-68 */
	+S1 = -0.166666666666666666671L, /* -0xaaaaaaaaaaaaaaab.0p-66 */
	+#endif
	+
	+static const double
	+C2 = -0.0013888888888888874, /* -0x16c16c16c16c10.0p-62 */
	+C3 = 0.000024801587301571716, /* 0x1a01a01a018e22.0p-68 */
	+C4 = -0.00000027557319215507120, /* -0x127e4fb7602f22.0p-74 */
	+C5 = 0.0000000020876754400407278, /* 0x11eed8caaeccf1.0p-81 */
	+C6 = -1.1470297442401303e-11, /* -0x19393412bd1529.0p-89 */
	+C7 = 4.7383039476436467e-14, /* 0x1aac9d9af5c43e.0p-97 */
	+S2 = 0.0083333333333333332, /* 0x11111111111111.0p-59 */
	+S3 = -0.00019841269841269427, /* -0x1a01a01a019f81.0p-65 */
	+S4 = 0.0000027557319223597490, /* 0x171de3a55560f7.0p-71 */
	+S5 = -0.000000025052108218074604, /* -0x1ae64564f16cad.0p-78 */
	+S6 = 1.6059006598854211e-10, /* 0x161242b90243b5.0p-85 */
	+S7 = -7.6429779983024564e-13, /* -0x1ae42ebd1b2e00.0p-93 */
	+S8 = 2.6174587166648325e-15; /* 0x179372ea0b3f64.0p-101 */
	+
	+static inline void
	+__kernel_sincosl(long double x, long double y, int iy, long double *sn,
	+ long double *cs)
	+{
	+ long double hz, r, v, w, z;
	+
	+ z = x * x;
	+ v = z * x;
	+ /*
	+ * XXX Replace Horner scheme with an algorithm suitable for CPUs
	+ * with more complex pipelines.
	+ */
	+ r = S2 + z * (S3 + z * (S4 + z * (S5 + z * (S6 + z * (S7 + z * S8)))));
	+
	+ if (iy == 0)
	+ sn = x + v (S1 + z * r);
	+ else
	+ sn = x - ((z (y / 2 - v * r) - y) - v * S1);
	+
	+ hz = z / 2;
	+ w = 1 - hz;
	+ r = z * (C1 + z * (C2 + z * (C3 + z * (C4 + z * (C5 + z * (C6 +
	+ z * C7))))));
	+ cs = w + (((1 - w) - hz) + (z r - x * y));
	+}
	+
	+#elif LDBL_MANT_DIG == 113 /* ld128 version of k_sincosl.c. */
	+
	+static const long double
	+C1 = 0.04166666666666666666666666666666658424671L,
	+C2 = -0.001388888888888888888888888888863490893732L,
	+C3 = 0.00002480158730158730158730158600795304914210L,
	+C4 = -0.2755731922398589065255474947078934284324e-6L,
	+C5 = 0.2087675698786809897659225313136400793948e-8L,
	+C6 = -0.1147074559772972315817149986812031204775e-10L,
	+C7 = 0.4779477332386808976875457937252120293400e-13L,
	+S1 = -0.16666666666666666666666666666666666606732416116558L,
	+S2 = 0.0083333333333333333333333333333331135404851288270047L,
	+S3 = -0.00019841269841269841269841269839935785325638310428717L,
	+S4 = 0.27557319223985890652557316053039946268333231205686e-5L,
	+S5 = -0.25052108385441718775048214826384312253862930064745e-7L,
	+S6 = 0.16059043836821614596571832194524392581082444805729e-9L,
	+S7 = -0.76471637318198151807063387954939213287488216303768e-12L,
	+S8 = 0.28114572543451292625024967174638477283187397621303e-14L;
	+
	+static const double
	+C8 = -0.1561920696721507929516718307820958119868e-15,
	+C9 = 0.4110317413744594971475941557607804508039e-18,
	+C10 = -0.8896592467191938803288521958313920156409e-21,
	+C11 = 0.1601061435794535138244346256065192782581e-23,
	+S9 = -0.82206352458348947812512122163446202498005154296863e-17,
	+S10 = 0.19572940011906109418080609928334380560135358385256e-19,
	+S11 = -0.38680813379701966970673724299207480965452616911420e-22,
	+S12 = 0.64038150078671872796678569586315881020659912139412e-25;
	+
	+static inline void
	+__kernel_sincosl(long double x, long double y, int iy, long double *sn,
	+ long double *cs)
	+{
	+ long double hz, r, v, w, z;
	+
	+ z = x * x;
	+ v = z * x;
	+ /*
	+ * XXX Replace Horner scheme with an algorithm suitable for CPUs
	+ * with more complex pipelines.
	+ */
	+ r = S2 + z * (S3 + z * (S4 + z * (S5 + z * (S6 + z * (S7 + z * (S8 +
	+ z * (S9 + z * (S10 + z * (S11 + z * S12)))))))));
	+
	+ if (iy == 0)
	+ sn = x + v (S1 + z * r);
	+ else
	+ cs = x - ((z (y / 2 - v * r) - y) - v * S1);
	+
	+ hz = z / 2;
	+ w = 1 - hz;
	+ r = z * (C1 + z * (C2 + z * (C3 + z * (C4 + z * (C5 + z * (C6 +
	+ z * (C7 + z * (C8 + z * (C9 + z * (C10 + z * C11))))))))));
	+
	+ cs = w + (((1 - w) - hz) + (z r - x * y));
	+}
	+#else
	+#error "Unsupported long double format"
	+#endif
	Index: lib/msun/src/math.h
	===================================================================
	--- lib/msun/src/math.h
	+++ lib/msun/src/math.h
	@@ -500,6 +500,9 @@

	#if __BSD_VISIBLE
	long double lgammal_r(long double, int *);
	+void sincos(double, double , double );
	+void sincosf(float, float , float );
	+void sincosl(long double, long double , long double );
	#endif

	__END_DECLS
	Index: lib/msun/src/math.h.orig
	===================================================================
	--- /dev/null
	+++ lib/msun/src/math.h.orig
	@@ -0,0 +1,507 @@
	+/*
	+ * ====================================================
	+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
	+ *
	+ * Developed at SunPro, a Sun Microsystems, Inc. business.
	+ * Permission to use, copy, modify, and distribute this
	+ * software is freely granted, provided that this notice
	+ * is preserved.
	+ * ====================================================
	+ */
	+
	+/*
	+ * from: @(#)fdlibm.h 5.1 93/09/24
	+ * $FreeBSD$
	+ */
	+
	+#ifndef _MATH_H_
	+#define _MATH_H_
	+
	+#include <sys/cdefs.h>
	+#include <sys/_types.h>
	+#include <machine/_limits.h>
	+
	+/*
	+ * ANSI/POSIX
	+ */
	+extern const union __infinity_un {
	+ unsigned char __uc[8];
	+ double __ud;
	+} __infinity;
	+
	+extern const union __nan_un {
	+ unsigned char __uc[sizeof(float)];
	+ float __uf;
	+} __nan;
	+
	+#if __GNUC_PREREQ__(3, 3) \|\| (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 800)
	+#define __MATH_BUILTIN_CONSTANTS
	+#endif
	+
	+#if __GNUC_PREREQ__(3, 0) && !defined(__INTEL_COMPILER)
	+#define __MATH_BUILTIN_RELOPS
	+#endif
	+
	+#ifdef __MATH_BUILTIN_CONSTANTS
	+#define HUGE_VAL __builtin_huge_val()
	+#else
	+#define HUGE_VAL (__infinity.__ud)
	+#endif
	+
	+#if __ISO_C_VISIBLE >= 1999
	+#define FP_ILOGB0 (-__INT_MAX)
	+#define FP_ILOGBNAN __INT_MAX
	+
	+#ifdef __MATH_BUILTIN_CONSTANTS
	+#define HUGE_VALF __builtin_huge_valf()
	+#define HUGE_VALL __builtin_huge_vall()
	+#define INFINITY __builtin_inff()
	+#define NAN __builtin_nanf("")
	+#else
	+#define HUGE_VALF (float)HUGE_VAL
	+#define HUGE_VALL (long double)HUGE_VAL
	+#define INFINITY HUGE_VALF
	+#define NAN (__nan.__uf)
	+#endif /* __MATH_BUILTIN_CONSTANTS */
	+
	+#define MATH_ERRNO 1
	+#define MATH_ERREXCEPT 2
	+#define math_errhandling MATH_ERREXCEPT
	+
	+#define FP_FAST_FMAF 1
	+
	+/* Symbolic constants to classify floating point numbers. */
	+#define FP_INFINITE 0x01
	+#define FP_NAN 0x02
	+#define FP_NORMAL 0x04
	+#define FP_SUBNORMAL 0x08
	+#define FP_ZERO 0x10
	+
	+#if (__STDC_VERSION__ >= 201112L && defined(__clang__)) \|\| \
	+ __has_extension(c_generic_selections)
	+#define __fp_type_select(x, f, d, ld) _Generic((x), \
	+ float: f(x), \
	+ double: d(x), \
	+ long double: ld(x), \
	+ volatile float: f(x), \
	+ volatile double: d(x), \
	+ volatile long double: ld(x), \
	+ volatile const float: f(x), \
	+ volatile const double: d(x), \
	+ volatile const long double: ld(x), \
	+ const float: f(x), \
	+ const double: d(x), \
	+ const long double: ld(x))
	+#elif __GNUC_PREREQ__(3, 1) && !defined(__cplusplus)
	+#define __fp_type_select(x, f, d, ld) __builtin_choose_expr( \
	+ __builtin_types_compatible_p(__typeof(x), long double), ld(x), \
	+ __builtin_choose_expr( \
	+ __builtin_types_compatible_p(__typeof(x), double), d(x), \
	+ __builtin_choose_expr( \
	+ __builtin_types_compatible_p(__typeof(x), float), f(x), (void)0)))
	+#else
	+#define __fp_type_select(x, f, d, ld) \
	+ ((sizeof(x) == sizeof(float)) ? f(x) \
	+ : (sizeof(x) == sizeof(double)) ? d(x) \
	+ : ld(x))
	+#endif
	+
	+#define fpclassify(x) \
	+ __fp_type_select(x, __fpclassifyf, __fpclassifyd, __fpclassifyl)
	+#define isfinite(x) __fp_type_select(x, __isfinitef, __isfinite, __isfinitel)
	+#define isinf(x) __fp_type_select(x, __isinff, __isinf, __isinfl)
	+#define isnan(x) \
	+ __fp_type_select(x, __inline_isnanf, __inline_isnan, __inline_isnanl)
	+#define isnormal(x) __fp_type_select(x, __isnormalf, __isnormal, __isnormall)
	+
	+#ifdef __MATH_BUILTIN_RELOPS
	+#define isgreater(x, y) __builtin_isgreater((x), (y))
	+#define isgreaterequal(x, y) __builtin_isgreaterequal((x), (y))
	+#define isless(x, y) __builtin_isless((x), (y))
	+#define islessequal(x, y) __builtin_islessequal((x), (y))
	+#define islessgreater(x, y) __builtin_islessgreater((x), (y))
	+#define isunordered(x, y) __builtin_isunordered((x), (y))
	+#else
	+#define isgreater(x, y) (!isunordered((x), (y)) && (x) > (y))
	+#define isgreaterequal(x, y) (!isunordered((x), (y)) && (x) >= (y))
	+#define isless(x, y) (!isunordered((x), (y)) && (x) < (y))
	+#define islessequal(x, y) (!isunordered((x), (y)) && (x) <= (y))
	+#define islessgreater(x, y) (!isunordered((x), (y)) && \
	+ ((x) > (y) \|\| (y) > (x)))
	+#define isunordered(x, y) (isnan(x) \|\| isnan(y))
	+#endif /* __MATH_BUILTIN_RELOPS */
	+
	+#define signbit(x) __fp_type_select(x, __signbitf, __signbit, __signbitl)
	+
	+typedef __double_t double_t;
	+typedef __float_t float_t;
	+#endif /* __ISO_C_VISIBLE >= 1999 */
	+
	+/*
	+ * XOPEN/SVID
	+ */
	+#if __BSD_VISIBLE \|\| __XSI_VISIBLE
	+#define M_E 2.7182818284590452354 /* e */
	+#define M_LOG2E 1.4426950408889634074 /* log 2e */
	+#define M_LOG10E 0.43429448190325182765 /* log 10e */
	+#define M_LN2 0.69314718055994530942 /* log e2 */
	+#define M_LN10 2.30258509299404568402 /* log e10 */
	+#define M_PI 3.14159265358979323846 /* pi */
	+#define M_PI_2 1.57079632679489661923 /* pi/2 */
	+#define M_PI_4 0.78539816339744830962 /* pi/4 */
	+#define M_1_PI 0.31830988618379067154 /* 1/pi */
	+#define M_2_PI 0.63661977236758134308 /* 2/pi */
	+#define M_2_SQRTPI 1.12837916709551257390 /* 2/sqrt(pi) */
	+#define M_SQRT2 1.41421356237309504880 /* sqrt(2) */
	+#define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */
	+
	+#define MAXFLOAT ((float)3.40282346638528860e+38)
	+extern int signgam;
	+#endif /* __BSD_VISIBLE \|\| __XSI_VISIBLE */
	+
	+#if __BSD_VISIBLE
	+#if 0
	+/* Old value from 4.4BSD-Lite math.h; this is probably better. */
	+#define HUGE HUGE_VAL
	+#else
	+#define HUGE MAXFLOAT
	+#endif
	+#endif /* __BSD_VISIBLE */
	+
	+/*
	+ * Most of these functions depend on the rounding mode and have the side
	+ * effect of raising floating-point exceptions, so they are not declared
	+ * as __pure2. In C99, FENV_ACCESS affects the purity of these functions.
	+ */
	+__BEGIN_DECLS
	+/*
	+ * ANSI/POSIX
	+ */
	+int __fpclassifyd(double) __pure2;
	+int __fpclassifyf(float) __pure2;
	+int __fpclassifyl(long double) __pure2;
	+int __isfinitef(float) __pure2;
	+int __isfinite(double) __pure2;
	+int __isfinitel(long double) __pure2;
	+int __isinff(float) __pure2;
	+int __isinf(double) __pure2;
	+int __isinfl(long double) __pure2;
	+int __isnormalf(float) __pure2;
	+int __isnormal(double) __pure2;
	+int __isnormall(long double) __pure2;
	+int __signbit(double) __pure2;
	+int __signbitf(float) __pure2;
	+int __signbitl(long double) __pure2;
	+
	+static __inline int
	+__inline_isnan(__const double __x)
	+{
	+
	+ return (__x != __x);
	+}
	+
	+static __inline int
	+__inline_isnanf(__const float __x)
	+{
	+
	+ return (__x != __x);
	+}
	+
	+static __inline int
	+__inline_isnanl(__const long double __x)
	+{
	+
	+ return (__x != __x);
	+}
	+
	+/*
	+ * Version 2 of the Single UNIX Specification (UNIX98) defined isnan() and
	+ * isinf() as functions taking double. C99, and the subsequent POSIX revisions
	+ * (SUSv3, POSIX.1-2001, define it as a macro that accepts any real floating
	+ * point type. If we are targeting SUSv2 and C99 or C11 (or C++11) then we
	+ * expose the newer definition, assuming that the language spec takes
	+ * precedence over the operating system interface spec.
	+ */
	+#if __XSI_VISIBLE > 0 && __XSI_VISIBLE < 600 && __ISO_C_VISIBLE < 1999
	+#undef isinf
	+#undef isnan
	+int isinf(double);
	+int isnan(double);
	+#endif
	+
	+double acos(double);
	+double asin(double);
	+double atan(double);
	+double atan2(double, double);
	+double cos(double);
	+double sin(double);
	+double tan(double);
	+
	+double cosh(double);
	+double sinh(double);
	+double tanh(double);
	+
	+double exp(double);
	+double frexp(double, int ); / fundamentally !__pure2 */
	+double ldexp(double, int);
	+double log(double);
	+double log10(double);
	+double modf(double, double ); / fundamentally !__pure2 */
	+
	+double pow(double, double);
	+double sqrt(double);
	+
	+double ceil(double);
	+double fabs(double) __pure2;
	+double floor(double);
	+double fmod(double, double);
	+
	+/*
	+ * These functions are not in C90.
	+ */
	+#if __BSD_VISIBLE \|\| __ISO_C_VISIBLE >= 1999 \|\| __XSI_VISIBLE
	+double acosh(double);
	+double asinh(double);
	+double atanh(double);
	+double cbrt(double);
	+double erf(double);
	+double erfc(double);
	+double exp2(double);
	+double expm1(double);
	+double fma(double, double, double);
	+double hypot(double, double);
	+int ilogb(double) __pure2;
	+double lgamma(double);
	+long long llrint(double);
	+long long llround(double);
	+double log1p(double);
	+double log2(double);
	+double logb(double);
	+long lrint(double);
	+long lround(double);
	+double nan(const char *) __pure2;
	+double nextafter(double, double);
	+double remainder(double, double);
	+double remquo(double, double, int *);
	+double rint(double);
	+#endif /* __BSD_VISIBLE \|\| __ISO_C_VISIBLE >= 1999 \|\| __XSI_VISIBLE */
	+
	+#if __BSD_VISIBLE \|\| __XSI_VISIBLE
	+double j0(double);
	+double j1(double);
	+double jn(int, double);
	+double y0(double);
	+double y1(double);
	+double yn(int, double);
	+
	+#if __XSI_VISIBLE <= 500 \|\| __BSD_VISIBLE
	+double gamma(double);
	+#endif
	+
	+#if __XSI_VISIBLE <= 600 \|\| __BSD_VISIBLE
	+double scalb(double, double);
	+#endif
	+#endif /* __BSD_VISIBLE \|\| __XSI_VISIBLE */
	+
	+#if __BSD_VISIBLE \|\| __ISO_C_VISIBLE >= 1999
	+double copysign(double, double) __pure2;
	+double fdim(double, double);
	+double fmax(double, double) __pure2;
	+double fmin(double, double) __pure2;
	+double nearbyint(double);
	+double round(double);
	+double scalbln(double, long);
	+double scalbn(double, int);
	+double tgamma(double);
	+double trunc(double);
	+#endif
	+
	+/*
	+ * BSD math library entry points
	+ */
	+#if __BSD_VISIBLE
	+double drem(double, double);
	+int finite(double) __pure2;
	+int isnanf(float) __pure2;
	+
	+/*
	+ * Reentrant version of gamma & lgamma; passes signgam back by reference
	+ * as the second argument; user must allocate space for signgam.
	+ */
	+double gamma_r(double, int *);
	+double lgamma_r(double, int *);
	+
	+/*
	+ * IEEE Test Vector
	+ */
	+double significand(double);
	+#endif /* __BSD_VISIBLE */
	+
	+/* float versions of ANSI/POSIX functions */
	+#if __ISO_C_VISIBLE >= 1999
	+float acosf(float);
	+float asinf(float);
	+float atanf(float);
	+float atan2f(float, float);
	+float cosf(float);
	+float sinf(float);
	+float tanf(float);
	+
	+float coshf(float);
	+float sinhf(float);
	+float tanhf(float);
	+
	+float exp2f(float);
	+float expf(float);
	+float expm1f(float);
	+float frexpf(float, int ); / fundamentally !__pure2 */
	+int ilogbf(float) __pure2;
	+float ldexpf(float, int);
	+float log10f(float);
	+float log1pf(float);
	+float log2f(float);
	+float logf(float);
	+float modff(float, float ); / fundamentally !__pure2 */
	+
	+float powf(float, float);
	+float sqrtf(float);
	+
	+float ceilf(float);
	+float fabsf(float) __pure2;
	+float floorf(float);
	+float fmodf(float, float);
	+float roundf(float);
	+
	+float erff(float);
	+float erfcf(float);
	+float hypotf(float, float);
	+float lgammaf(float);
	+float tgammaf(float);
	+
	+float acoshf(float);
	+float asinhf(float);
	+float atanhf(float);
	+float cbrtf(float);
	+float logbf(float);
	+float copysignf(float, float) __pure2;
	+long long llrintf(float);
	+long long llroundf(float);
	+long lrintf(float);
	+long lroundf(float);
	+float nanf(const char *) __pure2;
	+float nearbyintf(float);
	+float nextafterf(float, float);
	+float remainderf(float, float);
	+float remquof(float, float, int *);
	+float rintf(float);
	+float scalblnf(float, long);
	+float scalbnf(float, int);
	+float truncf(float);
	+
	+float fdimf(float, float);
	+float fmaf(float, float, float);
	+float fmaxf(float, float) __pure2;
	+float fminf(float, float) __pure2;
	+#endif
	+
	+/*
	+ * float versions of BSD math library entry points
	+ */
	+#if __BSD_VISIBLE
	+float dremf(float, float);
	+int finitef(float) __pure2;
	+float gammaf(float);
	+float j0f(float);
	+float j1f(float);
	+float jnf(int, float);
	+float scalbf(float, float);
	+float y0f(float);
	+float y1f(float);
	+float ynf(int, float);
	+
	+/*
	+ * Float versions of reentrant version of gamma & lgamma; passes
	+ * signgam back by reference as the second argument; user must
	+ * allocate space for signgam.
	+ */
	+float gammaf_r(float, int *);
	+float lgammaf_r(float, int *);
	+
	+/*
	+ * float version of IEEE Test Vector
	+ */
	+float significandf(float);
	+#endif /* __BSD_VISIBLE */
	+
	+/*
	+ * long double versions of ISO/POSIX math functions
	+ */
	+#if __ISO_C_VISIBLE >= 1999
	+long double acoshl(long double);
	+long double acosl(long double);
	+long double asinhl(long double);
	+long double asinl(long double);
	+long double atan2l(long double, long double);
	+long double atanhl(long double);
	+long double atanl(long double);
	+long double cbrtl(long double);
	+long double ceill(long double);
	+long double copysignl(long double, long double) __pure2;
	+long double coshl(long double);
	+long double cosl(long double);
	+long double erfcl(long double);
	+long double erfl(long double);
	+long double exp2l(long double);
	+long double expl(long double);
	+long double expm1l(long double);
	+long double fabsl(long double) __pure2;
	+long double fdiml(long double, long double);
	+long double floorl(long double);
	+long double fmal(long double, long double, long double);
	+long double fmaxl(long double, long double) __pure2;
	+long double fminl(long double, long double) __pure2;
	+long double fmodl(long double, long double);
	+long double frexpl(long double, int ); / fundamentally !__pure2 */
	+long double hypotl(long double, long double);
	+int ilogbl(long double) __pure2;
	+long double ldexpl(long double, int);
	+long double lgammal(long double);
	+long long llrintl(long double);
	+long long llroundl(long double);
	+long double log10l(long double);
	+long double log1pl(long double);
	+long double log2l(long double);
	+long double logbl(long double);
	+long double logl(long double);
	+long lrintl(long double);
	+long lroundl(long double);
	+long double modfl(long double, long double ); / fundamentally !__pure2 */
	+long double nanl(const char *) __pure2;
	+long double nearbyintl(long double);
	+long double nextafterl(long double, long double);
	+double nexttoward(double, long double);
	+float nexttowardf(float, long double);
	+long double nexttowardl(long double, long double);
	+long double powl(long double, long double);
	+long double remainderl(long double, long double);
	+long double remquol(long double, long double, int *);
	+long double rintl(long double);
	+long double roundl(long double);
	+long double scalblnl(long double, long);
	+long double scalbnl(long double, int);
	+long double sinhl(long double);
	+long double sinl(long double);
	+long double sqrtl(long double);
	+long double tanhl(long double);
	+long double tanl(long double);
	+long double tgammal(long double);
	+long double truncl(long double);
	+#endif /* __ISO_C_VISIBLE >= 1999 */
	+
	+#if __BSD_VISIBLE
	+long double lgammal_r(long double, int *);
	+#endif
	+
	+__END_DECLS
	+
	+#endif /* !_MATH_H_ */
	Index: lib/msun/src/math_private.h
	===================================================================
	--- lib/msun/src/math_private.h
	+++ lib/msun/src/math_private.h
	@@ -306,9 +306,15 @@
	fpsetprec(__oprec); \
	RETURNF(__retval); \
	} while (0)
	+#define RETURNV() do { \
	+ if (__oprec != FP_PE) \
	+ fpsetprec(__oprec); \
	+ return; \
	+} while (0)
	#else
	#define ENTERI(x)
	#define RETURNI(x) RETURNF(x)
	+#define RETURNV() return
	#endif

	/* Default return statement if hack_t() is not used. /
	Index: lib/msun/src/s_sincos.c
	===================================================================
	--- /dev/null
	+++ lib/msun/src/s_sincos.c
	@@ -0,0 +1,80 @@
	+/*
	+ * ====================================================
	+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
	+ *
	+ * Developed at SunPro, a Sun Microsystems, Inc. business.
	+ * Permission to use, copy, modify, and distribute this
	+ * software is freely granted, provided that this notice
	+ * is preserved.
	+ * ====================================================
	+ *
	+ * s_sin.c and s_cos.c merged by Steven G. Kargl. Descriptions of the
	+ * algorithms are contained in the original files.
	+ */
	+
	+#include <sys/cdefs.h>
	+__FBSDID("$FreeBSD$");
	+
	+#include <float.h>
	+
	+#include "math.h"
	+#define INLINE_REM_PIO2
	+#include "math_private.h"
	+#include "e_rem_pio2.c"
	+#include "k_sincos.h"
	+
	+void
	+sincos(double x, double sn, double cs)
	+{
	+ double y[2];
	+ int32_t n, ix;
	+
	+ /* High word of x. */
	+ GET_HIGH_WORD(ix, x);
	+
	+ /* \|x\| ~< pi/4 */
	+ ix &= 0x7fffffff;
	+ if (ix <= 0x3fe921fb) {
	+ if (ix < 0x3e400000) { /* \|x\| < 2*-27 /
	+ if ((int)x == 0) { /* Generate inexact. */
	+ *sn = x;
	+ *cs = 1;
	+ return;
	+ }
	+ }
	+ __kernel_sincos(x, 0, 0, sn, cs);
	+ return;
	+ }
	+
	+ /* If x = Inf or NaN, then sin(x) = NaN and cos(x) = NaN. */
	+ if (ix >= 0x7ff00000) {
	+ *sn = x - x;
	+ *cs = x - x;
	+ return;
	+ }
	+
	+ /* Argument reduction. */
	+ n = __ieee754_rem_pio2(x, y);
	+
	+ switch(n & 3) {
	+ case 0:
	+ __kernel_sincos(y[0], y[1], 1, sn, cs);
	+ break;
	+ case 1:
	+ __kernel_sincos(y[0], y[1], 1, cs, sn);
	+ cs = -cs;
	+ break;
	+ case 2:
	+ __kernel_sincos(y[0], y[1], 1, sn, cs);
	+ sn = -sn;
	+ cs = -cs;
	+ break;
	+ default:
	+ __kernel_sincos(y[0], y[1], 1, cs, sn);
	+ sn = -sn;
	+ }
	+}
	+
	+#if (LDBL_MANT_DIG == 53)
	+__weak_reference(sincos, sincosl);
	+#endif
	Index: lib/msun/src/s_sincosf.c
	===================================================================
	--- /dev/null
	+++ lib/msun/src/s_sincosf.c
	@@ -0,0 +1,126 @@
	+/* s_sincosf.c -- float version of s_sincos.c.
	+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
	+ * Optimized by Bruce D. Evans.
	+ * Merged s_sinf.c and s_cosf.c by Steven G. Kargl.
	+ */
	+
	+/*
	+ * ====================================================
	+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
	+ *
	+ * Developed at SunPro, a Sun Microsystems, Inc. business.
	+ * Permission to use, copy, modify, and distribute this
	+ * software is freely granted, provided that this notice
	+ * is preserved.
	+ * ====================================================
	+ */
	+
	+#include <sys/cdefs.h>
	+__FBSDID("$FreeBSD$");
	+
	+#include <float.h>
	+
	+#include "math.h"
	+#define INLINE_REM_PIO2F
	+#include "math_private.h"
	+#include "e_rem_pio2f.c"
	+#include "k_sincosf.h"
	+
	+/* Small multiples of pi/2 rounded to double precision. */
	+static const double
	+p1pio2 = 1M_PI_2, / 0x3FF921FB, 0x54442D18 */
	+p2pio2 = 2M_PI_2, / 0x400921FB, 0x54442D18 */
	+p3pio2 = 3M_PI_2, / 0x4012D97C, 0x7F3321D2 */
	+p4pio2 = 4M_PI_2; / 0x401921FB, 0x54442D18 */
	+
	+void
	+sincosf(float x, float sn, float cs)
	+{
	+ float c, s;
	+ double y;
	+ int32_t n, hx, ix;
	+
	+ GET_FLOAT_WORD(hx, x);
	+ ix = hx & 0x7fffffff;
	+
	+ if (ix <= 0x3f490fda) { /* \|x\| ~<= pi/4 */
	+ if (ix < 0x39800000) { /* \|x\| < 2*-12 /
	+ if ((int)x == 0) {
	+ sn = x; / x with inexact if x != 0 */
	+ *cs = 1;
	+ return;
	+ }
	+ }
	+ __kernel_sincosdf(x, sn, cs);
	+ return;
	+ }
	+
	+ if (ix <= 0x407b53d1) { /* \|x\| ~<= 5pi/4 /
	+ if (ix <= 0x4016cbe3) { /* \|x\| ~<= 3pi/4 */
	+ if (hx > 0) {
	+ __kernel_sincosdf(x - p1pio2, cs, sn);
	+ cs = -cs;
	+ } else {
	+ __kernel_sincosdf(x + p1pio2, cs, sn);
	+ sn = -sn;
	+ }
	+ } else {
	+ if (hx > 0)
	+ __kernel_sincosdf(x - p2pio2, sn, cs);
	+ else
	+ __kernel_sincosdf(x + p2pio2, sn, cs);
	+ sn = -sn;
	+ cs = -cs;
	+ }
	+ return;
	+ }
	+
	+ if (ix <= 0x40e231d5) { /* \|x\| ~<= 9pi/4 /
	+ if (ix <= 0x40afeddf) { /* \|x\| ~<= 7pi/4 /
	+ if (hx > 0) {
	+ __kernel_sincosdf(x - p3pio2, cs, sn);
	+ sn = -sn;
	+ } else {
	+ __kernel_sincosdf(x + p3pio2, cs, sn);
	+ cs = -cs;
	+ }
	+ } else {
	+ if (hx > 0)
	+ __kernel_sincosdf(x - p4pio2, sn, cs);
	+ else
	+ __kernel_sincosdf(x + p4pio2, sn, cs);
	+ }
	+ return;
	+ }
	+
	+ /* If x = Inf or NaN, then sin(x) = NaN and cos(x) = NaN. */
	+ if (ix >= 0x7f800000) {
	+ *sn = x - x;
	+ *cs = x - x;
	+ return;
	+ }
	+
	+ /* Argument reduction. */
	+ n = __ieee754_rem_pio2f(x, &y);
	+ __kernel_sincosdf(y, &s, &c);
	+
	+ switch(n & 3) {
	+ case 0:
	+ *sn = s;
	+ *cs = c;
	+ break;
	+ case 1:
	+ *sn = c;
	+ *cs = -s;
	+ break;
	+ case 2:
	+ *sn = -s;
	+ *cs = -c;
	+ break;
	+ default:
	+ *sn = -c;
	+ *cs = s;
	+ }
	+}
	+
	+
	Index: lib/msun/src/s_sincosl.c
	===================================================================
	--- /dev/null
	+++ lib/msun/src/s_sincosl.c
	@@ -0,0 +1,105 @@
	+/*-
	+ * Copyright (c) 2007, 2010-2013 Steven G. Kargl
	+ * All rights reserved.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice unmodified, this list of conditions, and the following
	+ * disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	+ *
	+ * s_sinl.c and s_cosl.c merged by Steven G. Kargl.
	+ */
	+
	+#include <sys/cdefs.h>
	+__FBSDID("$FreeBSD$");
	+
	+#include <float.h>
	+#ifdef __i386__
	+#include <ieeefp.h>
	+#endif
	+
	+#include "math.h"
	+#include "math_private.h"
	+#include "k_sincosl.h"
	+
	+#if LDBL_MANT_DIG == 64
	+#include "../ld80/e_rem_pio2l.h"
	+#elif LDBL_MANT_DIG == 113
	+#include "../ld128/e_rem_pio2l.h"
	+#else
	+#error "Unsupported long double format"
	+#endif
	+
	+void
	+sincosl(long double x, long double sn, long double cs)
	+{
	+ union IEEEl2bits z;
	+ int e0, sgn;
	+ long double y[2];
	+
	+ z.e = x;
	+ sgn = z.bits.sign;
	+ z.bits.sign = 0;
	+
	+ ENTERI();
	+
	+ /* Optimize the case where x is already within range. */
	+ if (z.e < M_PI_4) {
	+ /*
	+ * If x = +-0 or x is a subnormal number, then sin(x) = x and
	+ * cos(x) = 1.
	+ */
	+ if (z.bits.exp == 0) {
	+ *sn = x;
	+ *cs = 1;
	+ } else
	+ __kernel_sincosl(x, 0, 0, sn, cs);
	+ RETURNV();
	+ }
	+
	+ /* If x = NaN or Inf, then sin(x) and cos(x) are NaN. */
	+ if (z.bits.exp == 32767) {
	+ *sn = x - x;
	+ *cs = x - x;
	+ RETURNV();
	+ }
	+
	+ /* Range reduction. */
	+ e0 = __ieee754_rem_pio2l(x, y);
	+
	+ switch (e0 & 3) {
	+ case 0:
	+ __kernel_sincosl(y[0], y[1], 1, sn, cs);
	+ break;
	+ case 1:
	+ __kernel_sincosl(y[0], y[1], 1, cs, sn);
	+ cs = -cs;
	+ break;
	+ case 2:
	+ __kernel_sincosl(y[0], y[1], 1, sn, cs);
	+ sn = -sn;
	+ cs = -cs;
	+ break;
	+ default:
	+ __kernel_sincosl(y[0], y[1], 1, cs, sn);
	+ sn = -sn;
	+ }
	+
	+ RETURNV();
	+}

File Metadata

Mime Type: text/plain
Expires: Sat, May 16, 5:20 AM (16 h, 40 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 33115529
Default Alt Text: D10765.id28446.diff (35 KB)

D10765.id28446.diffNo OneTemporaryActions

D10765.id28446.diffView Options

File Metadata

Event Timeline

D10765.id28446.diff
No OneTemporary
Actions

D10765.id28446.diff
View Options