You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
116 lines
2.6 KiB
116 lines
2.6 KiB
/**
|
|
* This code is available at
|
|
* http://www.mindspring.com/~pfilandr/C/fs_math/
|
|
* and it is believed to be public domain.
|
|
*/
|
|
|
|
/* BEGIN fs_math.h */
|
|
/*
|
|
** Portable freestanding code.
|
|
*/
|
|
#ifndef H_FS_MATH_H
|
|
#define H_FS_MATH_H
|
|
|
|
double fs_sqrt(double x);
|
|
double fs_log(double x);
|
|
double fs_log10(double x);
|
|
/*
|
|
** exp(x) = 1 + x + x^2/2! + x^3/3! + ...
|
|
*/
|
|
double fs_exp(double x);
|
|
double fs_modf(double value, double *iptr);
|
|
double fs_fmod(double x, double y);
|
|
double fs_pow(double x, double y);
|
|
double fs_cos(double x);
|
|
/*
|
|
** C99
|
|
*/
|
|
double fs_log2(double x);
|
|
double fs_exp2(double x);
|
|
long double fs_powl(long double x, long double y);
|
|
long double fs_sqrtl(long double x);
|
|
long double fs_logl(long double x);
|
|
long double fs_expl(long double x);
|
|
long double fs_cosl(long double x);
|
|
long double fs_fmodl(long double x, long double y);
|
|
|
|
#endif
|
|
|
|
/* END fs_math.h */
|
|
|
|
#if 0
|
|
|
|
/*
|
|
> > Anybody know where I can get some source code for a
|
|
> > reasonably fast double
|
|
> > precision square root algorithm in C.
|
|
> > I'm looking for one that is not IEEE
|
|
> > compliant as I am running on a Z/OS mainframe.
|
|
> >
|
|
> > I would love to use the standard library but
|
|
> > unfortunatly I'm using a
|
|
> > stripped down version of C that looses the the runtime library
|
|
> > (we have to write our own).
|
|
>
|
|
> long double Ssqrt(long double x)
|
|
> {
|
|
> long double a, b;
|
|
> size_t c;
|
|
|
|
size_t is a bug here.
|
|
c needs to be a signed type:
|
|
long c;
|
|
|
|
> if (x > 0) {
|
|
> c = 0;
|
|
> while (x > 4) {
|
|
> x /= 4;
|
|
> ++c;
|
|
> }
|
|
> while (1.0 / 4 > x) {
|
|
> x *= 4;
|
|
> --c;
|
|
> }
|
|
> a = x;
|
|
> b = ((4 > a) + a) / 2;
|
|
|
|
Not a bug, but should be:
|
|
b = (1 + a) / 2;
|
|
|
|
> do {
|
|
> x = b;
|
|
> b = (a / x + x) / 2;
|
|
> } while (x > b);
|
|
> if (c > 0) {
|
|
|
|
The above line is why c needs to be a signed type,
|
|
otherwise the decremented values of c, are greater than zero,
|
|
and the function won't work if the initial value of x
|
|
is less than 0.25
|
|
|
|
> while (c--) {
|
|
> x *= 2;
|
|
> }
|
|
> } else {
|
|
> while (c++) {
|
|
> x /= 2;
|
|
> }
|
|
> }
|
|
> }
|
|
> return x;
|
|
> }
|
|
|
|
>
|
|
> >
|
|
> > That algorithm was actually 4 times slower
|
|
> > then the one below, and more
|
|
> > code. It was accurate though.
|
|
> >
|
|
>
|
|
> Sorry Pete, I wasn't looking very carefully.
|
|
> When I converted your function
|
|
> to double precision it's was much quicker, the best I've seen yet.
|
|
|
|
*/
|
|
|
|
#endif
|