diff --git a/library/GNUmakefile.68k b/library/GNUmakefile.68k
index 51eb213..dcf3160 100644
--- a/library/GNUmakefile.68k
+++ b/library/GNUmakefile.68k
@@ -1,5 +1,5 @@
 #
-# $Id: GNUmakefile.68k,v 1.56 2005-05-29 14:45:28 obarthel Exp $
+# $Id: GNUmakefile.68k,v 1.57 2005-05-30 08:10:36 obarthel Exp $
 #
 # :ts=8
 #
@@ -519,6 +519,9 @@ MATH_LIB = \
 	complex_creal.o \
 	complex_crealf.o \
 	complex_creall.o \
+	math_coshf.o \
+	math_sinhf.o \
+	math_tanhf.o \
 	math_acos.o \
 	math_acosf.o \
 	math_asin.o \
@@ -534,6 +537,7 @@ MATH_LIB = \
 	math_copysign.o \
 	math_copysignf.o \
 	math_cos.o \
+	math_cosf.o \
 	math_cosh.o \
 	math_erf.o \
 	math_erfc.o \
@@ -555,6 +559,7 @@ MATH_LIB = \
 	math_huge_val.o \
 	math_huge_valf.o \
 	math_hypot.o \
+	math_hypotf.o \
 	math_ilogb.o \
 	math_ilogbf.o \
 	math_inf.o \
@@ -562,6 +567,9 @@ MATH_LIB = \
 	math_init_exit.o \
 	math_isfinite.o \
 	math_isunordered.o \
+	math_kernel_cosf.o \
+	math_kernel_sinf.o \
+	math_kernel_tanf.o \
 	math_ldexp.o \
 	math_ldexpf.o \
 	math_log.o \
@@ -580,16 +588,19 @@ MATH_LIB = \
 	math_nextafterf.o \
 	math_pow.o \
 	math_powf.o \
+	math_rem_pio2f.o \
 	math_rint.o \
 	math_rintf.o \
 	math_scalbn.o \
 	math_scalbnf.o \
 	math_signbit.o \
 	math_sin.o \
+	math_sinf.o \
 	math_sinh.o \
 	math_sqrt.o \
 	math_sqrtf.o \
 	math_tan.o \
+	math_tanf.o \
 	math_tanh.o \
 	stdio_asprintf.o \
 	stdio_flush.o \
diff --git a/library/GNUmakefile.os4 b/library/GNUmakefile.os4
index df34c58..d0773c4 100644
--- a/library/GNUmakefile.os4
+++ b/library/GNUmakefile.os4
@@ -1,5 +1,5 @@
 #
-# $Id: GNUmakefile.os4,v 1.60 2005-05-29 14:45:29 obarthel Exp $
+# $Id: GNUmakefile.os4,v 1.61 2005-05-30 08:10:37 obarthel Exp $
 #
 # :ts=8
 #
@@ -519,6 +519,9 @@ MATH_LIB = \
 	complex_creal.o \
 	complex_crealf.o \
 	complex_creall.o \
+	math_coshf.o \
+	math_sinhf.o \
+	math_tanhf.o \
 	math_acos.o \
 	math_acosf.o \
 	math_asin.o \
@@ -534,6 +537,7 @@ MATH_LIB = \
 	math_copysign.o \
 	math_copysignf.o \
 	math_cos.o \
+	math_cosf.o \
 	math_cosh.o \
 	math_erf.o \
 	math_erfc.o \
@@ -555,6 +559,7 @@ MATH_LIB = \
 	math_huge_val.o \
 	math_huge_valf.o \
 	math_hypot.o \
+	math_hypotf.o \
 	math_ilogb.o \
 	math_ilogbf.o \
 	math_inf.o \
@@ -563,11 +568,14 @@ MATH_LIB = \
 	math_isfinite.o \
 	math_isunordered.o \
 	math_kernel_cos.o \
+	math_kernel_cosf.o \
 	math_kernel_expm1.o \
 	math_kernel_rem_pio2.o \
 	math_kernel_scalbn.o \
 	math_kernel_sin.o \
+	math_kernel_sinf.o \
 	math_kernel_tan.o \
+	math_kernel_tanf.o \
 	math_ldexp.o \
 	math_ldexpf.o \
 	math_log.o \
@@ -586,16 +594,19 @@ MATH_LIB = \
 	math_nextafterf.o \
 	math_pow.o \
 	math_powf.o \
+	math_rem_pio2f.o \
 	math_rint.o \
 	math_rintf.o \
 	math_scalbn.o \
 	math_scalbnf.o \
 	math_signbit.o \
 	math_sin.o \
+	math_sinf.o \
 	math_sinh.o \
 	math_sqrt.o \
 	math_sqrtf.o \
 	math_tan.o \
+	math_tanf.o \
 	math_tanh.o \
 	stdio_asprintf.o \
 	stdio_flush.o \
diff --git a/library/TODO b/library/TODO
index 4b9ef4a..7ac4ea8 100755
--- a/library/TODO
+++ b/library/TODO
@@ -1,11 +1,5 @@
 C99 math functions:
 
-	("float"-versions of existing "double" functions)
-	cosf
-	hypotf
-	sinf
-	tanf
-
 	(functions generally missing, including their "float" counterparts)
 	acosh
 	acoshf
@@ -33,10 +27,6 @@ C99 math functions:
 	remquof
 	round
 	roundf
-	sinh
-	sinhf
-	tanh
-	tanhf
 	tgamma
 	tgammaf
 	trunc
diff --git a/library/changes b/library/changes
index 787f4e3..fd7e0c4 100644
--- a/library/changes
+++ b/library/changes
@@ -70,6 +70,8 @@
 - Ported cbrt(), cbrtf(), erf(), erff(), erfc(), erfcf(), expm1(),
   expm1f(), ilogb(), ilogbf(), log1p() and log1pf() for C99.
 
+- Ported cosf(), coshf(), sinf(), sinhf(), tanf(), tanhf()
+  and hypotf() for C99.
 
 
 c.lib 1.192 (12.5.2005)
diff --git a/library/include/math.h b/library/include/math.h
index 3293c8a..d8c6b68 100644
--- a/library/include/math.h
+++ b/library/include/math.h
@@ -1,5 +1,5 @@
 /*
- * $Id: math.h,v 1.13 2005-05-29 14:45:33 obarthel Exp $
+ * $Id: math.h,v 1.14 2005-05-30 08:10:41 obarthel Exp $
  *
  * :ts=4
  *
@@ -101,13 +101,6 @@ extern double tanh(double x);
 
 /****************************************************************************/
 
-extern double rint(double x);
-extern float rintf(float x);
-extern double logb(double x);
-extern double hypot(double x,double y);
-
-/****************************************************************************/
-
 /* The following is not part of the ISO 'C' (1994) standard, but it should
    be part of ISO/IEC 9899:1999, also known as "C99". */
 
@@ -229,86 +222,74 @@ extern float asinf(float x);
 extern float atanf(float x);
 extern float atan2f(float y, float x);
 extern float ceilf(float x);
-
-
+extern float cosf(float x);
+extern float coshf(float x);
 extern float expf(float x);
 extern float fabsf(float x);
 extern float floorf(float x);
 extern float fmodf(float x, float y);
 extern float frexpf(float x, int *eptr);
-extern float ldexp(float x,int exp);
+extern float ldexpf(float x,int exp);
 extern float logf(float x);
 extern float log10f(float x);
-extern float logbf(float x);
 extern float modff(float x, float *iptr);
 extern float powf(float x, float y);
+extern float sinf(float x);
+extern float sinhf(float x);
 extern float sqrtf(float x);
+extern float tanf(float x);
+extern float tanhf(float x);
 
 /****************************************************************************/
 
+extern float logbf(float x);
+extern double logb(double x);
+
+extern float hypotf(float x, float y);
+extern double hypot(double x,double y);
+
 extern float nanf(const char *tagp);
 extern double nan(const char *tagp);
 
-/****************************************************************************/
-
 extern float nextafterf(float x,float y);
 extern double nextafter(double x,double y);
 
-/****************************************************************************/
-
 extern float copysignf(float x, float y);
 extern double copysign(double x, double y);
 
-/****************************************************************************/
-
 extern float fdimf(float x,float y);
 extern double fdim(double x,double y);
 
-/****************************************************************************/
-
 extern float fminf(float x,float y);
 extern double fmin(double x,double y);
 
-/****************************************************************************/
-
 extern float fmaxf(float x,float y);
 extern double fmax(double x,double y);
 
-/****************************************************************************/
-
 extern float scalbnf (float x, int n);
 extern double scalbn (double x, int n);
 
-/****************************************************************************/
-
 extern float cbrtf(float x);
 extern double cbrt(double x);
 
-/****************************************************************************/
-
 extern float erff(float x);
 extern double erf(double x);
 
-/****************************************************************************/
-
 extern float erfcf(float x);
 extern double erfc(double x);
 
-/****************************************************************************/
-
 extern float expm1f(float x);
 extern double expm1(double x);
 
-/****************************************************************************/
-
 extern int ilogbf(float x);
 extern int ilogb(double x);
 
-/****************************************************************************/
-
 extern float log1pf(float x);
 extern double log1p(double x);
 
+extern float rintf(float x);
+extern double rint(double x);
+
 /****************************************************************************/
 
 #define FLT_EVAL_METHOD 0
diff --git a/library/math_atan2f.c b/library/math_atan2f.c
index d21d201..2401529 100644
--- a/library/math_atan2f.c
+++ b/library/math_atan2f.c
@@ -1,5 +1,5 @@
 /*
- * $Id: math_atan2f.c,v 1.2 2005-05-29 14:45:29 obarthel Exp $
+ * $Id: math_atan2f.c,v 1.3 2005-05-30 08:10:37 obarthel Exp $
  *
  * :ts=4
  *
@@ -125,7 +125,7 @@ atan2f(float y, float x)
 	switch (m) {
 	    case 0: return       z  ;	/* atan(+,+) */
 	    case 1: {
-	    	      __uint32_t zh;
+	    	      ULONG zh;
 		      GET_FLOAT_WORD(zh,z);
 		      SET_FLOAT_WORD(z,zh ^ 0x80000000U);
 		    }
diff --git a/library/math_cosf.c b/library/math_cosf.c
index a6e993d..6b14a81 100644
--- a/library/math_cosf.c
+++ b/library/math_cosf.c
@@ -1,5 +1,5 @@
 /*
- * $Id: math_cosf.c,v 1.1 2005-05-29 11:19:00 obarthel Exp $
+ * $Id: math_cosf.c,v 1.2 2005-05-30 08:10:37 obarthel Exp $
  *
  * :ts=4
  *
@@ -29,6 +29,18 @@
  * 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.
+ *
+ *
+ * PowerPC math library based in part on work by Sun Microsystems
+ * 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.
+ *
+ *
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 #ifndef _MATH_HEADERS_H
@@ -41,11 +53,34 @@
 
 /****************************************************************************/
 
+static const float one=1.0;
+
 float
 cosf(float x)
 {
-	/* ZZZ unimplemented */
-	return(0);
+	float y[2],z=0.0;
+	LONG n,ix;
+
+	GET_FLOAT_WORD(ix,x);
+
+    /* |x| ~< pi/4 */
+	ix &= 0x7fffffff;
+	if(ix <= 0x3f490fd8) return __kernel_cosf(x,z);
+
+    /* cos(Inf or NaN) is NaN */
+	else if (ix>=0x7f800000) return x-x;
+
+    /* argument reduction needed */
+	else {
+	    n = __rem_pio2f(x,y);
+	    switch(n&3) {
+		case 0: return  __kernel_cosf(y[0],y[1]);
+		case 1: return -__kernel_sinf(y[0],y[1],1);
+		case 2: return -__kernel_cosf(y[0],y[1]);
+		default:
+		        return  __kernel_sinf(y[0],y[1],1);
+	    }
+	}
 }
 
 /****************************************************************************/
diff --git a/library/math_coshf.c b/library/math_coshf.c
index 402e6c6..8c8bc62 100644
--- a/library/math_coshf.c
+++ b/library/math_coshf.c
@@ -1,5 +1,5 @@
 /*
- * $Id: math_coshf.c,v 1.1 2005-05-29 11:19:00 obarthel Exp $
+ * $Id: math_coshf.c,v 1.2 2005-05-30 08:10:37 obarthel Exp $
  *
  * :ts=4
  *
@@ -29,6 +29,18 @@
  * 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.
+ *
+ *
+ * PowerPC math library based in part on work by Sun Microsystems
+ * 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.
+ *
+ *
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 #ifndef _MATH_HEADERS_H
@@ -41,11 +53,46 @@
 
 /****************************************************************************/
 
+static const float one = 1.0, half=0.5, huge = 1.0e30;
+
 float
 coshf(float x)
 {
-	/* ZZZ unimplemented */
-	return(0);
+	float t,w;
+	LONG ix;
+
+	GET_FLOAT_WORD(ix,x);
+	ix &= 0x7fffffff;
+
+    /* x is INF or NaN */
+	if(ix>=0x7f800000) return x*x;	
+
+    /* |x| in [0,0.5*ln2], return 1+expm1(|x|)^2/(2*exp(|x|)) */
+	if(ix<0x3eb17218) {
+	    t = expm1f(fabsf(x));
+	    w = one+t;
+	    if (ix<0x24000000) return w;	/* cosh(tiny) = 1 */
+	    return one+(t*t)/(w+w);
+	}
+
+    /* |x| in [0.5*ln2,22], return (exp(|x|)+1/exp(|x|)/2; */
+	if (ix < 0x41b00000) {
+		t = expf(fabsf(x));
+		return half*t+half/t;
+	}
+
+    /* |x| in [22, log(maxdouble)] return half*exp(|x|) */
+	if (ix < 0x42b17180)  return half*expf(fabsf(x));
+
+    /* |x| in [log(maxdouble), overflowthresold] */
+	if (ix<=0x42b2d4fc) {
+	    w = expf(half*fabsf(x));
+	    t = half*w;
+	    return t*w;
+	}
+
+    /* |x| > overflowthresold, cosh(x) overflow */
+	return huge*huge;
 }
 
 /****************************************************************************/
diff --git a/library/math_erf.c b/library/math_erf.c
index bf2f2c8..99115d8 100644
--- a/library/math_erf.c
+++ b/library/math_erf.c
@@ -1,5 +1,5 @@
 /*
- * $Id: math_erf.c,v 1.2 2005-05-29 14:45:29 obarthel Exp $
+ * $Id: math_erf.c,v 1.3 2005-05-30 08:10:37 obarthel Exp $
  *
  * :ts=4
  *
@@ -133,7 +133,7 @@ erf(double x)
 	GET_HIGH_WORD(hx,x);
 	ix = hx&0x7fffffff;
 	if(ix>=0x7ff00000) {		/* erf(nan)=nan */
-	    i = ((__uint32_t)hx>>31)<<1;
+	    i = ((ULONG)hx>>31)<<1;
 	    return (double)(1-i)+one/x;	/* erf(+-inf)=+-1 */
 	}
 
diff --git a/library/math_headers.h b/library/math_headers.h
index 8c7bad0..a81ca7f 100644
--- a/library/math_headers.h
+++ b/library/math_headers.h
@@ -1,5 +1,5 @@
 /*
- * $Id: math_headers.h,v 1.10 2005-05-12 13:21:43 obarthel Exp $
+ * $Id: math_headers.h,v 1.11 2005-05-30 08:10:37 obarthel Exp $
  *
  * :ts=4
  *
@@ -210,16 +210,16 @@ do {							\
   (d) = sf_u.value;				\
 } while (0)
 
-#if defined(PPC_FLOATING_POINT_SUPPORT)
-
 extern double __kernel_cos(double x, double y);
 extern double __kernel_sin(double x, double y, int iy);
 extern int __rem_pio2(double x, double *y);
 extern double __kernel_tan(double x, double y, int iy);
 extern double __expm1(double x);
 extern double __scalbn(double x, int n);
-
-#endif /* PPC_FLOATING_POINT_SUPPORT */
+extern float __kernel_cosf(float x, float y);
+extern float __kernel_sinf(float x, float y, int iy);
+extern LONG __rem_pio2f(float x, float *y);
+extern float __kernel_tanf(float x, float y, int iy);
 
 /****************************************************************************/
 
diff --git a/library/math_hypotf.c b/library/math_hypotf.c
index 47b4e1c..a2120b2 100644
--- a/library/math_hypotf.c
+++ b/library/math_hypotf.c
@@ -1,5 +1,5 @@
 /*
- * $Id: math_hypotf.c,v 1.1 2005-05-29 11:19:01 obarthel Exp $
+ * $Id: math_hypotf.c,v 1.2 2005-05-30 08:10:38 obarthel Exp $
  *
  * :ts=4
  *
@@ -29,6 +29,18 @@
  * 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.
+ *
+ *
+ * PowerPC math library based in part on work by Sun Microsystems
+ * 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.
+ *
+ *
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 #ifndef _MATH_HEADERS_H
@@ -41,11 +53,42 @@
 
 /****************************************************************************/
 
+#define	SQRT_FLT_MAX	1.84467429742e+19  /* 0x5f7fffff */
+
 float
-hypotf(float x,float y)
+hypotf(float x, float y)
 {
-	/* ZZZ unimplemented */
-	return(0);
+	float a=x,b=y,t1,t2,w;
+	LONG j,ha,hb;
+
+	if (isunordered(x,y))
+		return (x-x)/(y-y);
+	if (!isfinite(x) || !isfinite(y)) {
+		__set_errno(ERANGE);
+		return __get_huge_valf();
+	}
+
+	GET_FLOAT_WORD(ha,x);
+	ha &= 0x7fffffff;
+	GET_FLOAT_WORD(hb,y);
+	hb &= 0x7fffffff;
+	if(hb < ha) {a=y;b=x;j=ha; ha=hb;hb=j;} else {a=x;b=y;}
+	SET_FLOAT_WORD(a,ha);	/* a <- |a| */
+	SET_FLOAT_WORD(b,hb);	/* b <- |b| */
+	t1 = (a > 0) ? (a/b) : 0;
+	if ((t1 >= SQRT_FLT_MAX) && isfinite(x) && isfinite(y)) {
+		__set_errno(ERANGE);
+		return __get_huge_valf();
+	}
+	t1 *= t1;
+	t2 = sqrtf(++t1);
+	if ((t2 > 1) && (b >= FLT_MAX)) {
+		__set_errno(ERANGE);
+		return __get_huge_valf();
+	}
+	w = t2 * b;
+
+	       return w;
 }
 
 /****************************************************************************/
diff --git a/library/math_kernel_cosf.c b/library/math_kernel_cosf.c
new file mode 100644
index 0000000..e7db32f
--- /dev/null
+++ b/library/math_kernel_cosf.c
@@ -0,0 +1,94 @@
+/*
+ * $Id: math_kernel_cosf.c,v 1.1 2005-05-30 08:10:38 obarthel Exp $
+ *
+ * :ts=4
+ *
+ * Portable ISO 'C' (1994) runtime library for the Amiga computer
+ * Copyright (c) 2002-2005 by Olaf Barthel <olsen@sourcery.han.de>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *   - Neither the name of Olaf Barthel nor the names of contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT OWNER 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.
+ *
+ *
+ * PowerPC math library based in part on work by Sun Microsystems
+ * 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.
+ *
+ *
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+#ifndef _MATH_HEADERS_H
+#include "math_headers.h"
+#endif /* _MATH_HEADERS_H */
+
+/****************************************************************************/
+
+#if defined(FLOATING_POINT_SUPPORT)
+
+/****************************************************************************/
+
+static const float 
+one =  1.0000000000e+00, /* 0x3f800000 */
+C1  =  4.1666667908e-02, /* 0x3d2aaaab */
+C2  = -1.3888889225e-03, /* 0xbab60b61 */
+C3  =  2.4801587642e-05, /* 0x37d00d01 */
+C4  = -2.7557314297e-07, /* 0xb493f27c */
+C5  =  2.0875723372e-09, /* 0x310f74f6 */
+C6  = -1.1359647598e-11; /* 0xad47d74e */
+
+float
+__kernel_cosf(float x, float y)
+{
+	volatile float hz;	/* prevent optimizing out of existence */
+	float a,z,r,qx;
+	LONG ix;
+	GET_FLOAT_WORD(ix,x);
+	ix &= 0x7fffffff;			/* ix = |x|'s high word*/
+	if(ix<0x32000000) {			/* if x < 2**27 */
+	    if(((int)x)==0) return one;		/* generate inexact */
+	}
+	z  = x*x;
+	r  = z*(C1+z*(C2+z*(C3+z*(C4+z*(C5+z*C6)))));
+	if(ix < 0x3e99999a) 			/* if |x| < 0.3 */ 
+	    return one - ((float)0.5*z - (z*r - x*y));
+	else {
+	    if(ix > 0x3f480000) {		/* x > 0.78125 */
+		qx = (float)0.28125;
+	    } else {
+	        SET_FLOAT_WORD(qx,ix-0x01000000);	/* x/4 */
+	    }
+	    hz = (float)0.5*z-qx;
+	    a  = one-qx;
+	    return a - (hz - (z*r-x*y));
+	}
+}
+
+/****************************************************************************/
+
+#endif /* FLOATING_POINT_SUPPORT */
diff --git a/library/math_kernel_sinf.c b/library/math_kernel_sinf.c
new file mode 100644
index 0000000..893463c
--- /dev/null
+++ b/library/math_kernel_sinf.c
@@ -0,0 +1,83 @@
+/*
+ * $Id: math_kernel_sinf.c,v 1.1 2005-05-30 08:10:38 obarthel Exp $
+ *
+ * :ts=4
+ *
+ * Portable ISO 'C' (1994) runtime library for the Amiga computer
+ * Copyright (c) 2002-2005 by Olaf Barthel <olsen@sourcery.han.de>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *   - Neither the name of Olaf Barthel nor the names of contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT OWNER 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.
+ *
+ *
+ * PowerPC math library based in part on work by Sun Microsystems
+ * 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.
+ *
+ *
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+#ifndef _MATH_HEADERS_H
+#include "math_headers.h"
+#endif /* _MATH_HEADERS_H */
+
+/****************************************************************************/
+
+#if defined(FLOATING_POINT_SUPPORT)
+
+/****************************************************************************/
+
+static const float 
+half =  5.0000000000e-01,/* 0x3f000000 */
+S1  = -1.6666667163e-01, /* 0xbe2aaaab */
+S2  =  8.3333337680e-03, /* 0x3c088889 */
+S3  = -1.9841270114e-04, /* 0xb9500d01 */
+S4  =  2.7557314297e-06, /* 0x3638ef1b */
+S5  = -2.5050759689e-08, /* 0xb2d72f34 */
+S6  =  1.5896910177e-10; /* 0x2f2ec9d3 */
+
+float
+__kernel_sinf(float x, float y, int iy)
+{
+	float z,r,v;
+	LONG ix;
+	GET_FLOAT_WORD(ix,x);
+	ix &= 0x7fffffff;			/* high word of x */
+	if(ix<0x32000000)			/* |x| < 2**-27 */
+	   {if((int)x==0) return x;}		/* generate inexact */
+	z	=  x*x;
+	v	=  z*x;
+	r	=  S2+z*(S3+z*(S4+z*(S5+z*S6)));
+	if(iy==0) return x+v*(S1+z*r);
+	else      return x-((z*(half*y-v*r)-y)-v*S1);
+}
+
+/****************************************************************************/
+
+#endif /* FLOATING_POINT_SUPPORT */
diff --git a/library/math_kernel_tanf.c b/library/math_kernel_tanf.c
new file mode 100644
index 0000000..4851b3a
--- /dev/null
+++ b/library/math_kernel_tanf.c
@@ -0,0 +1,131 @@
+/*
+ * $Id: math_kernel_tanf.c,v 1.1 2005-05-30 08:10:38 obarthel Exp $
+ *
+ * :ts=4
+ *
+ * Portable ISO 'C' (1994) runtime library for the Amiga computer
+ * Copyright (c) 2002-2005 by Olaf Barthel <olsen@sourcery.han.de>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *   - Neither the name of Olaf Barthel nor the names of contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT OWNER 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.
+ *
+ *
+ * PowerPC math library based in part on work by Sun Microsystems
+ * 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.
+ *
+ *
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+#ifndef _MATH_HEADERS_H
+#include "math_headers.h"
+#endif /* _MATH_HEADERS_H */
+
+/****************************************************************************/
+
+#if defined(FLOATING_POINT_SUPPORT)
+
+/****************************************************************************/
+
+static const float 
+one   =  1.0000000000e+00, /* 0x3f800000 */
+pio4  =  7.8539812565e-01, /* 0x3f490fda */
+pio4lo=  3.7748947079e-08, /* 0x33222168 */
+T[] =  {
+  3.3333334327e-01, /* 0x3eaaaaab */
+  1.3333334029e-01, /* 0x3e088889 */
+  5.3968254477e-02, /* 0x3d5d0dd1 */
+  2.1869488060e-02, /* 0x3cb327a4 */
+  8.8632395491e-03, /* 0x3c11371f */
+  3.5920790397e-03, /* 0x3b6b6916 */
+  1.4562094584e-03, /* 0x3abede48 */
+  5.8804126456e-04, /* 0x3a1a26c8 */
+  2.4646313977e-04, /* 0x398137b9 */
+  7.8179444245e-05, /* 0x38a3f445 */
+  7.1407252108e-05, /* 0x3895c07a */
+ -1.8558637748e-05, /* 0xb79bae5f */
+  2.5907305826e-05, /* 0x37d95384 */
+};
+
+float
+__kernel_tanf(float x, float y, int iy)
+{
+	float z,r,v,w,s;
+	LONG ix,hx;
+	GET_FLOAT_WORD(hx,x);
+	ix = hx&0x7fffffff;	/* high word of |x| */
+	if(ix<0x31800000)			/* x < 2**-28 */
+	    {if((int)x==0) {			/* generate inexact */
+		if((ix|(iy+1))==0) return one/fabsf(x);
+		else return (iy==1)? x: -one/x;
+	    }
+	    }
+	if(ix>=0x3f2ca140) { 			/* |x|>=0.6744 */
+	    if(hx<0) {x = -x; y = -y;}
+	    z = pio4-x;
+	    w = pio4lo-y;
+	    x = z+w; y = 0.0;
+	}
+	z	=  x*x;
+	w 	=  z*z;
+    /* Break x^5*(T[1]+x^2*T[2]+...) into
+     *	  x^5(T[1]+x^4*T[3]+...+x^20*T[11]) +
+     *	  x^5(x^2*(T[2]+x^4*T[4]+...+x^22*[T12]))
+     */
+	r = T[1]+w*(T[3]+w*(T[5]+w*(T[7]+w*(T[9]+w*T[11]))));
+	v = z*(T[2]+w*(T[4]+w*(T[6]+w*(T[8]+w*(T[10]+w*T[12])))));
+	s = z*x;
+	r = y + z*(s*(r+v)+y);
+	r += T[0]*s;
+	w = x+r;
+	if(ix>=0x3f2ca140) {
+	    v = (float)iy;
+	    return (float)(1-((hx>>30)&2))*(v-(float)2.0*(x-(w*w/(w+v)-r)));
+	}
+	if(iy==1) return w;
+	else {		/* if allow error up to 2 ulp, 
+			   simply return -1.0/(x+r) here */
+     /*  compute -1.0/(x+r) accurately */
+	    float a,t;
+	    LONG i;
+	    z  = w;
+	    GET_FLOAT_WORD(i,z);
+	    SET_FLOAT_WORD(z,i&0xfffff000U);
+	    v  = r-(z - x); 	/* z+v = r+x */
+	    t = a  = -(float)1.0/w;	/* a = -1.0/w */
+	    GET_FLOAT_WORD(i,t);
+	    SET_FLOAT_WORD(t,i&0xfffff000U);
+	    s  = (float)1.0+t*z;
+	    return t+a*(s+t*v);
+	}
+}
+
+/****************************************************************************/
+
+#endif /* FLOATING_POINT_SUPPORT */
diff --git a/library/math_rem_pio2f.c b/library/math_rem_pio2f.c
new file mode 100755
index 0000000..af649f4
--- /dev/null
+++ b/library/math_rem_pio2f.c
@@ -0,0 +1,389 @@
+/*
+ * $Id: math_rem_pio2f.c,v 1.1 2005-05-30 08:10:38 obarthel Exp $
+ *
+ * :ts=4
+ *
+ * Portable ISO 'C' (1994) runtime library for the Amiga computer
+ * Copyright (c) 2002-2005 by Olaf Barthel <olsen@sourcery.han.de>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *   - Neither the name of Olaf Barthel nor the names of contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT OWNER 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.
+ *
+ *
+ * PowerPC math library based in part on work by Sun Microsystems
+ * 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.
+ *
+ *
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+#ifndef _MATH_HEADERS_H
+#include "math_headers.h"
+#endif /* _MATH_HEADERS_H */
+
+/****************************************************************************/
+
+#if defined(FLOATING_POINT_SUPPORT)
+
+/****************************************************************************/
+
+/* In the float version, the input parameter x contains 8 bit
+   integers, not 24 bit integers.  113 bit precision is not supported.  */
+
+static const int init_jk[] = {4,7,9}; /* initial value for jk */
+
+static const float PIo2[] = {
+  1.5703125000e+00, /* 0x3fc90000 */
+  4.5776367188e-04, /* 0x39f00000 */
+  2.5987625122e-05, /* 0x37da0000 */
+  7.5437128544e-08, /* 0x33a20000 */
+  6.0026650317e-11, /* 0x2e840000 */
+  7.3896444519e-13, /* 0x2b500000 */
+  5.3845816694e-15, /* 0x27c20000 */
+  5.6378512969e-18, /* 0x22d00000 */
+  8.3009228831e-20, /* 0x1fc40000 */
+  3.2756352257e-22, /* 0x1bc60000 */
+  6.3331015649e-25, /* 0x17440000 */
+};
+
+static const float			
+zero   = 0.0,
+one    = 1.0,
+two8   =  2.5600000000e+02, /* 0x43800000 */
+twon8  =  3.9062500000e-03; /* 0x3b800000 */
+
+static int
+__kernel_rem_pio2f(float *x, float *y, int e0, int nx, int prec, const LONG *ipio2) 
+{
+	LONG jz,jx,jv,jp,jk,carry,n,iq[20],i,j,k,m,q0,ih;
+	float z,fw,f[20],fq[20],q[20];
+
+    /* initialize jk*/
+	jk = init_jk[prec];
+	jp = jk;
+
+    /* determine jx,jv,q0, note that 3>q0 */
+	jx =  nx-1;
+	jv = (e0-3)/8; if(jv<0) jv=0;
+	q0 =  e0-8*(jv+1);
+
+    /* set up f[0] to f[jx+jk] where f[jx+jk] = ipio2[jv+jk] */
+	j = jv-jx; m = jx+jk;
+	for(i=0;i<=m;i++,j++) f[i] = (j<0)? zero : (float) ipio2[j];
+
+    /* compute q[0],q[1],...q[jk] */
+	for (i=0;i<=jk;i++) {
+	    for(j=0,fw=0.0;j<=jx;j++) fw += x[j]*f[jx+i-j]; q[i] = fw;
+	}
+
+	jz = jk;
+recompute:
+    /* distill q[] into iq[] reversingly */
+	for(i=0,j=jz,z=q[jz];j>0;i++,j--) {
+	    fw    =  (float)((LONG)(twon8* z));
+	    iq[i] =  (LONG)(z-two8*fw);
+	    z     =  q[j-1]+fw;
+	}
+
+    /* compute n */
+	z  = scalbnf(z,(int)q0);	/* actual value of z */
+	z -= (float)8.0*floorf(z*(float)0.125);	/* trim off integer >= 8 */
+	n  = (LONG) z;
+	z -= (float)n;
+	ih = 0;
+	if(q0>0) {	/* need iq[jz-1] to determine n */
+	    i  = (iq[jz-1]>>(8-q0)); n += i;
+	    iq[jz-1] -= i<<(8-q0);
+	    ih = iq[jz-1]>>(7-q0);
+	} 
+	else if(q0==0) ih = iq[jz-1]>>8;
+	else if(z>=(float)0.5) ih=2;
+
+	if(ih>0) {	/* q > 0.5 */
+	    n += 1; carry = 0;
+	    for(i=0;i<jz ;i++) {	/* compute 1-q */
+		j = iq[i];
+		if(carry==0) {
+		    if(j!=0) {
+			carry = 1; iq[i] = 0x100- j;
+		    }
+		} else  iq[i] = 0xff - j;
+	    }
+	    if(q0>0) {		/* rare case: chance is 1 in 12 */
+	        switch(q0) {
+	        case 1:
+	    	   iq[jz-1] &= 0x7f; break;
+	    	case 2:
+	    	   iq[jz-1] &= 0x3f; break;
+	        }
+	    }
+	    if(ih==2) {
+		z = one - z;
+		if(carry!=0) z -= scalbnf(one,(int)q0);
+	    }
+	}
+
+    /* check if recomputation is needed */
+	if(z==zero) {
+	    j = 0;
+	    for (i=jz-1;i>=jk;i--) j |= iq[i];
+	    if(j==0) { /* need recomputation */
+		for(k=1;iq[jk-k]==0;k++);   /* k = no. of terms needed */
+
+		for(i=jz+1;i<=jz+k;i++) {   /* add q[jz+1] to q[jz+k] */
+		    f[jx+i] = (float) ipio2[jv+i];
+		    for(j=0,fw=0.0;j<=jx;j++) fw += x[j]*f[jx+i-j];
+		    q[i] = fw;
+		}
+		jz += k;
+		goto recompute;
+	    }
+	}
+
+    /* chop off zero terms */
+	if(z==(float)0.0) {
+	    jz -= 1; q0 -= 8;
+	    while(iq[jz]==0) { jz--; q0-=8;}
+	} else { /* break z into 8-bit if necessary */
+	    z = scalbnf(z,-(int)q0);
+	    if(z>=two8) { 
+		fw = (float)((LONG)(twon8*z));
+		iq[jz] = (LONG)(z-two8*fw);
+		jz += 1; q0 += 8;
+		iq[jz] = (LONG) fw;
+	    } else iq[jz] = (LONG) z ;
+	}
+
+    /* convert integer "bit" chunk to floating-point value */
+	fw = scalbnf(one,(int)q0);
+	for(i=jz;i>=0;i--) {
+	    q[i] = fw*(float)iq[i]; fw*=twon8;
+	}
+
+    /* compute PIo2[0,...,jp]*q[jz,...,0] */
+	for(i=jz;i>=0;i--) {
+	    for(fw=0.0,k=0;k<=jp&&k<=jz-i;k++) fw += PIo2[k]*q[i+k];
+	    fq[jz-i] = fw;
+	}
+
+    /* compress fq[] into y[] */
+	switch(prec) {
+	    case 0:
+		fw = 0.0;
+		for (i=jz;i>=0;i--) fw += fq[i];
+		y[0] = (ih==0)? fw: -fw; 
+		break;
+	    case 1:
+	    case 2:
+		fw = 0.0;
+		for (i=jz;i>=0;i--) fw += fq[i]; 
+		y[0] = (ih==0)? fw: -fw; 
+		fw = fq[0]-fw;
+		for (i=1;i<=jz;i++) fw += fq[i];
+		y[1] = (ih==0)? fw: -fw; 
+		break;
+	    case 3:	/* painful */
+		for (i=jz;i>0;i--) {
+		    fw      = fq[i-1]+fq[i]; 
+		    fq[i]  += fq[i-1]-fw;
+		    fq[i-1] = fw;
+		}
+		for (i=jz;i>1;i--) {
+		    fw      = fq[i-1]+fq[i]; 
+		    fq[i]  += fq[i-1]-fw;
+		    fq[i-1] = fw;
+		}
+		for (fw=0.0,i=jz;i>=2;i--) fw += fq[i]; 
+		if(ih==0) {
+		    y[0] =  fq[0]; y[1] =  fq[1]; y[2] =  fw;
+		} else {
+		    y[0] = -fq[0]; y[1] = -fq[1]; y[2] = -fw;
+		}
+	}
+	return n&7;
+}
+
+/****************************************************************************/
+
+/*
+ * Table of constants for 2/pi, 396 Hex digits (476 decimal) of 2/pi 
+ */
+static const LONG two_over_pi[] = {
+0xA2, 0xF9, 0x83, 0x6E, 0x4E, 0x44, 0x15, 0x29, 0xFC,
+0x27, 0x57, 0xD1, 0xF5, 0x34, 0xDD, 0xC0, 0xDB, 0x62, 
+0x95, 0x99, 0x3C, 0x43, 0x90, 0x41, 0xFE, 0x51, 0x63,
+0xAB, 0xDE, 0xBB, 0xC5, 0x61, 0xB7, 0x24, 0x6E, 0x3A, 
+0x42, 0x4D, 0xD2, 0xE0, 0x06, 0x49, 0x2E, 0xEA, 0x09,
+0xD1, 0x92, 0x1C, 0xFE, 0x1D, 0xEB, 0x1C, 0xB1, 0x29, 
+0xA7, 0x3E, 0xE8, 0x82, 0x35, 0xF5, 0x2E, 0xBB, 0x44,
+0x84, 0xE9, 0x9C, 0x70, 0x26, 0xB4, 0x5F, 0x7E, 0x41, 
+0x39, 0x91, 0xD6, 0x39, 0x83, 0x53, 0x39, 0xF4, 0x9C,
+0x84, 0x5F, 0x8B, 0xBD, 0xF9, 0x28, 0x3B, 0x1F, 0xF8, 
+0x97, 0xFF, 0xDE, 0x05, 0x98, 0x0F, 0xEF, 0x2F, 0x11,
+0x8B, 0x5A, 0x0A, 0x6D, 0x1F, 0x6D, 0x36, 0x7E, 0xCF, 
+0x27, 0xCB, 0x09, 0xB7, 0x4F, 0x46, 0x3F, 0x66, 0x9E,
+0x5F, 0xEA, 0x2D, 0x75, 0x27, 0xBA, 0xC7, 0xEB, 0xE5, 
+0xF1, 0x7B, 0x3D, 0x07, 0x39, 0xF7, 0x8A, 0x52, 0x92,
+0xEA, 0x6B, 0xFB, 0x5F, 0xB1, 0x1F, 0x8D, 0x5D, 0x08, 
+0x56, 0x03, 0x30, 0x46, 0xFC, 0x7B, 0x6B, 0xAB, 0xF0,
+0xCF, 0xBC, 0x20, 0x9A, 0xF4, 0x36, 0x1D, 0xA9, 0xE3, 
+0x91, 0x61, 0x5E, 0xE6, 0x1B, 0x08, 0x65, 0x99, 0x85,
+0x5F, 0x14, 0xA0, 0x68, 0x40, 0x8D, 0xFF, 0xD8, 0x80, 
+0x4D, 0x73, 0x27, 0x31, 0x06, 0x06, 0x15, 0x56, 0xCA,
+0x73, 0xA8, 0xC9, 0x60, 0xE2, 0x7B, 0xC0, 0x8C, 0x6B, 
+};
+
+/* This array is like the one in e_rem_pio2.c, but the numbers are
+   single precision and the last 8 bits are forced to 0.  */
+static const LONG npio2_hw[] = {
+0x3fc90f00, 0x40490f00, 0x4096cb00, 0x40c90f00, 0x40fb5300, 0x4116cb00,
+0x412fed00, 0x41490f00, 0x41623100, 0x417b5300, 0x418a3a00, 0x4196cb00,
+0x41a35c00, 0x41afed00, 0x41bc7e00, 0x41c90f00, 0x41d5a000, 0x41e23100,
+0x41eec200, 0x41fb5300, 0x4203f200, 0x420a3a00, 0x42108300, 0x4216cb00,
+0x421d1400, 0x42235c00, 0x4229a500, 0x422fed00, 0x42363600, 0x423c7e00,
+0x4242c700, 0x42490f00
+};
+
+/*
+ * invpio2:  24 bits of 2/pi
+ * pio2_1:   first  17 bit of pi/2
+ * pio2_1t:  pi/2 - pio2_1
+ * pio2_2:   second 17 bit of pi/2
+ * pio2_2t:  pi/2 - (pio2_1+pio2_2)
+ * pio2_3:   third  17 bit of pi/2
+ * pio2_3t:  pi/2 - (pio2_1+pio2_2+pio2_3)
+ */
+
+static const float 
+half =  5.0000000000e-01, /* 0x3f000000 */
+invpio2 =  6.3661980629e-01, /* 0x3f22f984 */
+pio2_1  =  1.5707855225e+00, /* 0x3fc90f80 */
+pio2_1t =  1.0804334124e-05, /* 0x37354443 */
+pio2_2  =  1.0804273188e-05, /* 0x37354400 */
+pio2_2t =  6.0770999344e-11, /* 0x2e85a308 */
+pio2_3  =  6.0770943833e-11, /* 0x2e85a300 */
+pio2_3t =  6.1232342629e-17; /* 0x248d3132 */
+
+LONG
+__rem_pio2f(float x, float *y)
+{
+	volatile float z,r;	/* prevent optimizing out of existence */
+	float w,t,fn;
+	float tx[3];
+	LONG i,j,n,ix,hx;
+	int e0,nx;
+
+	GET_FLOAT_WORD(hx,x);
+	ix = hx&0x7fffffff;
+	if(ix<=0x3f490fd8)   /* |x| ~<= pi/4 , no need for reduction */
+	    {y[0] = x; y[1] = 0; return 0;}
+	if(ix<0x4016cbe4) {  /* |x| < 3pi/4, special case with n=+-1 */
+	    if(hx>0) { 
+		z = x - pio2_1;
+		if((ix&0xfffffff0U)!=0x3fc90fd0) { /* 24+24 bit pi OK */
+		    y[0] = z - pio2_1t;
+		    y[1] = (z-y[0])-pio2_1t;
+		} else {		/* near pi/2, use 24+24+24 bit pi */
+		    z -= pio2_2;
+		    y[0] = z - pio2_2t;
+		    y[1] = (z-y[0])-pio2_2t;
+		}
+		return 1;
+	    } else {	/* negative x */
+		z = x + pio2_1;
+		if((ix&0xfffffff0U)!=0x3fc90fd0) { /* 24+24 bit pi OK */
+		    y[0] = z + pio2_1t;
+		    y[1] = (z-y[0])+pio2_1t;
+		} else {		/* near pi/2, use 24+24+24 bit pi */
+		    z += pio2_2;
+		    y[0] = z + pio2_2t;
+		    y[1] = (z-y[0])+pio2_2t;
+		}
+		return -1;
+	    }
+	}
+	if(ix<=0x43490f80) { /* |x| ~<= 2^7*(pi/2), medium size */
+	    t  = fabsf(x);
+	    n  = (LONG) (t*invpio2+half);
+	    fn = (float)n;
+	    r  = t-fn*pio2_1;
+	    w  = fn*pio2_1t;	/* 1st round good to 40 bit */
+	    if(n<32&&((LONG)(ix&0xffffff00U))!=npio2_hw[n-1]) {	
+		y[0] = r-w;	/* quick check no cancellation */
+	    } else {
+	        ULONG high;
+	        j  = ix>>23;
+	        y[0] = r-w; 
+		GET_FLOAT_WORD(high,y[0]);
+	        i = j-((high>>23)&0xff);
+	        if(i>8) {  /* 2nd iteration needed, good to 57 */
+		    t  = r;
+		    w  = fn*pio2_2;	
+		    r  = t-w;
+		    w  = fn*pio2_2t-((t-r)-w);	
+		    y[0] = r-w;
+		    GET_FLOAT_WORD(high,y[0]);
+		    i = j-((high>>23)&0xff);
+		    if(i>25)  {	/* 3rd iteration need, 74 bits acc */
+		    	t  = r;	/* will cover all possible cases */
+		    	w  = fn*pio2_3;	
+		    	r  = t-w;
+		    	w  = fn*pio2_3t-((t-r)-w);	
+		    	y[0] = r-w;
+		    }
+		}
+	    }
+	    y[1] = (r-y[0])-w;
+	    if(hx<0) 	{y[0] = -y[0]; y[1] = -y[1]; return -n;}
+	    else	 return n;
+	}
+    /* 
+     * all other (large) arguments
+     */
+	if(ix>=0x7f800000) {		/* x is inf or NaN */
+	    y[0]=y[1]=x-x; return 0;
+	}
+    /* set z = scalbn(|x|,ilogb(x)-7) */
+	e0 	= (int)((ix>>23)-134);	/* e0 = ilogb(z)-7; */
+	SET_FLOAT_WORD(z, ix - ((LONG)e0<<23));
+	for(i=0;i<2;i++) {
+		tx[i] = (float)((LONG)(z));
+		z     = (z-tx[i])*two8;
+	}
+	tx[2] = z;
+	nx = 3;
+	while(tx[nx-1]==zero) nx--;	/* skip zero term */
+	n  =  __kernel_rem_pio2f(tx,y,e0,nx,2,two_over_pi);
+	if(hx<0) {y[0] = -y[0]; y[1] = -y[1]; return -n;}
+	return n;
+}
+
+/****************************************************************************/
+
+#endif /* FLOATING_POINT_SUPPORT */
diff --git a/library/math_sinf.c b/library/math_sinf.c
index 5924ffb..72207b3 100644
--- a/library/math_sinf.c
+++ b/library/math_sinf.c
@@ -1,5 +1,5 @@
 /*
- * $Id: math_sinf.c,v 1.1 2005-05-29 11:19:01 obarthel Exp $
+ * $Id: math_sinf.c,v 1.2 2005-05-30 08:10:38 obarthel Exp $
  *
  * :ts=4
  *
@@ -29,6 +29,18 @@
  * 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.
+ *
+ *
+ * PowerPC math library based in part on work by Sun Microsystems
+ * 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.
+ *
+ *
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 #ifndef _MATH_HEADERS_H
@@ -44,8 +56,29 @@
 float
 sinf(float x)
 {
-	/* ZZZ unimplemented */
-	return(0);
+	float y[2],z=0.0;
+	LONG n,ix;
+
+	GET_FLOAT_WORD(ix,x);
+
+    /* |x| ~< pi/4 */
+	ix &= 0x7fffffff;
+	if(ix <= 0x3f490fd8) return __kernel_sinf(x,z,0);
+
+    /* sin(Inf or NaN) is NaN */
+	else if (ix>=0x7f800000) return x-x;
+
+    /* argument reduction needed */
+	else {
+	    n = __rem_pio2f(x,y);
+	    switch(n&3) {
+		case 0: return  __kernel_sinf(y[0],y[1],1);
+		case 1: return  __kernel_cosf(y[0],y[1]);
+		case 2: return -__kernel_sinf(y[0],y[1],1);
+		default:
+			return -__kernel_cosf(y[0],y[1]);
+	    }
+	}
 }
 
 /****************************************************************************/
diff --git a/library/math_sinhf.c b/library/math_sinhf.c
index 3cc7735..05cc1f7 100644
--- a/library/math_sinhf.c
+++ b/library/math_sinhf.c
@@ -1,5 +1,5 @@
 /*
- * $Id: math_sinhf.c,v 1.1 2005-05-29 11:19:01 obarthel Exp $
+ * $Id: math_sinhf.c,v 1.2 2005-05-30 08:10:38 obarthel Exp $
  *
  * :ts=4
  *
@@ -29,6 +29,18 @@
  * 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.
+ *
+ *
+ * PowerPC math library based in part on work by Sun Microsystems
+ * 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.
+ *
+ *
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 #ifndef _MATH_HEADERS_H
@@ -41,11 +53,43 @@
 
 /****************************************************************************/
 
+static const float one = 1.0, shuge = 1.0e37;
+
 float
 sinhf(float x)
-{
-	/* ZZZ unimplemented */
-	return(0);
+{	
+	float t,w,h;
+	LONG ix,jx;
+
+	GET_FLOAT_WORD(jx,x);
+	ix = jx&0x7fffffff;
+
+    /* x is INF or NaN */
+	if(ix>=0x7f800000) return x+x;	
+
+	h = 0.5;
+	if (jx<0) h = -h;
+    /* |x| in [0,22], return sign(x)*0.5*(E+E/(E+1))) */
+	if (ix < 0x41b00000) {		/* |x|<22 */
+	    if (ix<0x31800000) 		/* |x|<2**-28 */
+		if(shuge+x>one) return x;/* sinh(tiny) = tiny with inexact */
+	    t = expm1f(fabsf(x));
+	    if(ix<0x3f800000) return h*((float)2.0*t-t*t/(t+one));
+	    return h*(t+t/(t+one));
+	}
+
+    /* |x| in [22, log(maxdouble)] return 0.5*exp(|x|) */
+	if (ix < 0x42b17180)  return h*expf(fabsf(x));
+
+    /* |x| in [log(maxdouble), overflowthresold] */
+	if (ix<=0x42b2d4fc) {
+	    w = expf((float)0.5*fabsf(x));
+	    t = h*w;
+	    return t*w;
+	}
+
+    /* |x| > overflowthresold, sinh(x) overflow */
+	return x*shuge;
 }
 
 /****************************************************************************/
diff --git a/library/math_tanf.c b/library/math_tanf.c
index 6df1cab..92ede37 100644
--- a/library/math_tanf.c
+++ b/library/math_tanf.c
@@ -1,5 +1,5 @@
 /*
- * $Id: math_tanf.c,v 1.1 2005-05-29 11:19:01 obarthel Exp $
+ * $Id: math_tanf.c,v 1.2 2005-05-30 08:10:38 obarthel Exp $
  *
  * :ts=4
  *
@@ -29,6 +29,18 @@
  * 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.
+ *
+ *
+ * PowerPC math library based in part on work by Sun Microsystems
+ * 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.
+ *
+ *
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 #ifndef _MATH_HEADERS_H
@@ -44,8 +56,24 @@
 float
 tanf(float x)
 {
-	/* ZZZ unimplemented */
-	return(0);
+	float y[2],z=0.0;
+	LONG n,ix;
+
+	GET_FLOAT_WORD(ix,x);
+
+    /* |x| ~< pi/4 */
+	ix &= 0x7fffffff;
+	if(ix <= 0x3f490fda) return __kernel_tanf(x,z,1);
+
+    /* tan(Inf or NaN) is NaN */
+	else if (ix>=0x7f800000) return x-x;		/* NaN */
+
+    /* argument reduction needed */
+	else {
+	    n = __rem_pio2f(x,y);
+	    return __kernel_tanf(y[0],y[1],1-((n&1)<<1)); /*   1 -- n even
+							      -1 -- n odd */
+	}
 }
 
 /****************************************************************************/
diff --git a/library/math_tanhf.c b/library/math_tanhf.c
index 1d9be09..f9b65a4 100644
--- a/library/math_tanhf.c
+++ b/library/math_tanhf.c
@@ -1,5 +1,5 @@
 /*
- * $Id: math_tanhf.c,v 1.1 2005-05-29 11:19:01 obarthel Exp $
+ * $Id: math_tanhf.c,v 1.2 2005-05-30 08:10:38 obarthel Exp $
  *
  * :ts=4
  *
@@ -29,6 +29,18 @@
  * 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.
+ *
+ *
+ * PowerPC math library based in part on work by Sun Microsystems
+ * 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.
+ *
+ *
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
  */
 
 #ifndef _MATH_HEADERS_H
@@ -41,11 +53,39 @@
 
 /****************************************************************************/
 
+static const float one=1.0, two=2.0, tiny = 1.0e-30;
+
 float
 tanhf(float x)
 {
-	/* ZZZ unimplemented */
-	return(0);
+	float t,z;
+	LONG jx,ix;
+
+	GET_FLOAT_WORD(jx,x);
+	ix = jx&0x7fffffff;
+
+    /* x is INF or NaN */
+	if(ix>=0x7f800000) { 
+	    if (jx>=0) return one/x+one;    /* tanh(+-inf)=+-1 */
+	    else       return one/x-one;    /* tanh(NaN) = NaN */
+	}
+
+    /* |x| < 22 */
+	if (ix < 0x41b00000) {		/* |x|<22 */
+	    if (ix<0x24000000) 		/* |x|<2**-55 */
+		return x*(one+x);    	/* tanh(small) = small */
+	    if (ix>=0x3f800000) {	/* |x|>=1  */
+		t = expm1f(two*fabsf(x));
+		z = one - two/(t+two);
+	    } else {
+	        t = expm1f(-two*fabsf(x));
+	        z= -t/(t+two);
+	    }
+    /* |x| > 22, return +-1 */
+	} else {
+	    z = one - tiny;		/* raised inexact flag */
+	}
+	return (jx>=0)? z: -z;
 }
 
 /****************************************************************************/