upstream/1.1.5.1_cvsrelease/1.1.5.1_cvsreleng/1

1 files changed, 229 insertions, 0 deletions

diff --git a/sys/gnu/fpemul/poly_tan.c b/sys/gnu/fpemul/poly_tan.c
new file mode 100644
index 000000000000..b167bd51a904
--- /dev/null
+++ b/sys/gnu/fpemul/poly_tan.c
@@ -0,0 +1,229 @@
+/*
+ *  poly_tan.c
+ *
+ * Compute the tan of a FPU_REG, using a polynomial approximation.
+ *
+ *
+ * Copyright (C) 1992,1993,1994
+ *                       W. Metzenthen, 22 Parker St, Ormond, Vic 3163,
+ *                       Australia.  E-mail   billm@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD, FreeBSD and NetBSD operating systems. Any other
+ * use is not permitted under this copyright.
+ *
+ * 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 include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``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
+ * W. METZENTHEN 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.
+ *
+ *
+ * The purpose of this copyright, based upon the Berkeley copyright, is to
+ * ensure that the covered software remains freely available to everyone.
+ *
+ * The software (with necessary differences) is also available, but under
+ * the terms of the GNU copyleft, for the Linux operating system and for
+ * the djgpp ms-dos extender.
+ *
+ * W. Metzenthen   June 1994.
+ *
+ *
+ *      $Id: poly_tan.c,v 1.4 1994/06/10 07:44:42 rich Exp $
+ * 
+ */
+
+#include "exception.h"
+#include "reg_constant.h"
+#include "fpu_emu.h"
+#include "control_w.h"
+
+
+#define	HIPOWERop	3	/* odd poly, positive terms */
+static unsigned short oddplterms[HIPOWERop][4] =
+{
+	{0x846a, 0x42d1, 0xb544, 0x921f},
+	{0x6fb2, 0x0215, 0x95c0, 0x099c},
+	{0xfce6, 0x0cc8, 0x1c9a, 0x0000}
+};
+#define	HIPOWERon	2	/* odd poly, negative terms */
+static unsigned short oddnegterms[HIPOWERon][4] =
+{
+	{0x6906, 0xe205, 0x25c8, 0x8838},
+	{0x1dd7, 0x3fe3, 0x944e, 0x002c}
+};
+#define	HIPOWERep	2	/* even poly, positive terms */
+static unsigned short evenplterms[HIPOWERep][4] =
+{
+	{0xdb8f, 0x3761, 0x1432, 0x2acf},
+	{0x16eb, 0x13c1, 0x3099, 0x0003}
+};
+#define	HIPOWERen	2	/* even poly, negative terms */
+static unsigned short evennegterms[HIPOWERen][4] =
+{
+	{0x3a7c, 0xe4c5, 0x7f87, 0x2945},
+	{0x572b, 0x664c, 0xc543, 0x018c}
+};
+
+
+/*--- poly_tan() ------------------------------------------------------------+
+ |                                                                           |
+ +---------------------------------------------------------------------------*/
+void
+poly_tan(FPU_REG * arg, FPU_REG * y_reg)
+{
+	char    invert = 0;
+	short   exponent;
+	FPU_REG odd_poly, even_poly, pos_poly, neg_poly;
+	FPU_REG argSq;
+	long long arg_signif, argSqSq;
+
+
+	exponent = arg->exp - EXP_BIAS;
+
+	if (arg->tag == TW_Zero) {
+		/* Return 0.0 */
+		reg_move(&CONST_Z, y_reg);
+		return;
+	}
+	if (exponent >= -1) {
+		/* argument is in the range  [0.5 .. 1.0] */
+		if (exponent >= 0) {
+#ifdef PARANOID
+			if ((exponent == 0) &&
+			    (arg->sigl == 0) && (arg->sigh == 0x80000000))
+#endif				/* PARANOID */
+			{
+				arith_overflow(y_reg);
+				return;
+			}
+#ifdef PARANOID
+			EXCEPTION(EX_INTERNAL | 0x104);	/* There must be a logic
+							 * error */
+			return;
+#endif				/* PARANOID */
+		}
+		/* The argument is in the range  [0.5 .. 1.0) */
+		/* Convert the argument to a number in the range  (0.0 .. 0.5] */
+		*((long long *) (&arg->sigl)) = -*((long long *) (&arg->sigl));
+		normalize(arg);	/* Needed later */
+		exponent = arg->exp - EXP_BIAS;
+		invert = 1;
+	}
+#ifdef PARANOID
+	if (arg->sign != 0) {	/* Can't hack a number < 0.0 */
+		arith_invalid(y_reg);
+		return;
+	}			/* Need a positive number */
+#endif				/* PARANOID */
+
+	*(long long *) &arg_signif = *(long long *) &(arg->sigl);
+	if (exponent < -1) {
+		/* shift the argument right by the required places */
+		if (shrx(&arg_signif, -1 - exponent) >= (unsigned)0x80000000)
+			arg_signif++;	/* round up */
+	}
+	mul64(&arg_signif, &arg_signif, (long long *) (&argSq.sigl));
+	mul64((long long *) (&argSq.sigl), (long long *) (&argSq.sigl), &argSqSq);
+
+	/* will be a valid positive nr with expon = 0 */
+	*(short *) &(pos_poly.sign) = 0;
+	pos_poly.exp = EXP_BIAS;
+
+	/* Do the basic fixed point polynomial evaluation */
+	polynomial((u_int *) &pos_poly.sigl, (unsigned *) &argSqSq, oddplterms, HIPOWERop - 1);
+
+	/* will be a valid positive nr with expon = 0 */
+	*(short *) &(neg_poly.sign) = 0;
+	neg_poly.exp = EXP_BIAS;
+
+	/* Do the basic fixed point polynomial evaluation */
+	polynomial((u_int *) &neg_poly.sigl, (unsigned *) &argSqSq, oddnegterms, HIPOWERon - 1);
+	mul64((long long *) (&argSq.sigl), (long long *) (&neg_poly.sigl),
+	    (long long *) (&neg_poly.sigl));
+
+	/* Subtract the mantissas */
+	*((long long *) (&pos_poly.sigl)) -= *((long long *) (&neg_poly.sigl));
+
+	/* Convert to 64 bit signed-compatible */
+	pos_poly.exp -= 1;
+
+	reg_move(&pos_poly, &odd_poly);
+	normalize(&odd_poly);
+
+	reg_mul(&odd_poly, arg, &odd_poly, FULL_PRECISION);
+	reg_u_add(&odd_poly, arg, &odd_poly, FULL_PRECISION);	/* This is just the odd
+								 * polynomial */
+
+
+	/* will be a valid positive nr with expon = 0 */
+	*(short *) &(pos_poly.sign) = 0;
+	pos_poly.exp = EXP_BIAS;
+
+	/* Do the basic fixed point polynomial evaluation */
+	polynomial((u_int *) &pos_poly.sigl, (unsigned *) &argSqSq, evenplterms, HIPOWERep - 1);
+	mul64((long long *) (&argSq.sigl),
+	    (long long *) (&pos_poly.sigl), (long long *) (&pos_poly.sigl));
+
+	/* will be a valid positive nr with expon = 0 */
+	*(short *) &(neg_poly.sign) = 0;
+	neg_poly.exp = EXP_BIAS;
+
+	/* Do the basic fixed point polynomial evaluation */
+	polynomial((u_int *) &neg_poly.sigl, (unsigned *) &argSqSq, evennegterms, HIPOWERen - 1);
+
+	/* Subtract the mantissas */
+	*((long long *) (&neg_poly.sigl)) -= *((long long *) (&pos_poly.sigl));
+	/* and multiply by argSq */
+
+	/* Convert argSq to a valid reg number */
+	*(short *) &(argSq.sign) = 0;
+	argSq.exp = EXP_BIAS - 1;
+	normalize(&argSq);
+
+	/* Convert to 64 bit signed-compatible */
+	neg_poly.exp -= 1;
+
+	reg_move(&neg_poly, &even_poly);
+	normalize(&even_poly);
+
+	reg_mul(&even_poly, &argSq, &even_poly, FULL_PRECISION);
+	reg_add(&even_poly, &argSq, &even_poly, FULL_PRECISION);
+	reg_sub(&CONST_1, &even_poly, &even_poly, FULL_PRECISION);	/* This is just the even
+									 * polynomial */
+
+	/* Now ready to copy the results */
+	if (invert) {
+		reg_div(&even_poly, &odd_poly, y_reg, FULL_PRECISION);
+	} else {
+		reg_div(&odd_poly, &even_poly, y_reg, FULL_PRECISION);
+	}
+
+}