Can't Copy and Paste this?

Click here for a copy-and-paste friendly version of this code!

//**************************************

//     

//INCLUDE files for :FACTORYL.C

//**************************************

//     

/* +++Date last modified: 05-Jul-1997 */

/*

** SNIPMATH.H - Header file for SNIPPETS math functions and macros

*/

#ifndef SNIPMATH__H

#define SNIPMATH__H

#include 

#include "sniptype.h"

#include "round.h"

/*

** Callable library functions begin here

*/

voidSetBCDLen(int n); /* Bcdl.C */

longBCDtoLong(char *BCDNum); /* Bcdl.C */

voidLongtoBCD(long num, char BCDNum[]);/* Bcdl.C */

double bcd_to_double(void *buf, size_t len, /* Bcdd.C */

int digits);

int double_to_bcd(double arg, char *buf, /* Bcdd.C */

size_t length, size_t digits );

DWORDncomb1 (int n, int m);/* Combin.C*/

DWORDncomb2 (int n, int m);/* Combin.C*/

voidSolveCubic(double a, double b, double c, /* Cubic.C*/

double d, int *solutions,

double *x);

DWORDdbl2ulong(double t); /* Dbl2Long.C */

longdbl2long(double t);/* Dbl2Long.C */

double dround(double x); /* Dblround.C */

/* Use #defines for Permutations and Combinations -- Factoryl.C */

#define log10P(n,r) (log10factorial(n)-log10factorial((n)-(r)))

#define log10C(n,r) (log10P((n),(r))-log10factorial(r))

double log10factorial(double N); /* Factoryl.C */

double fibo(unsigned short term);/* Fibo.C */

double frandom(int n);/* Frand.C*/

double ipow(double x, int n);/* Ipow.C */

int ispow2(int x);/* Ispow2.C*/

longdouble ldfloor(long double a);/* Ldfloor.C */

int initlogscale(long dmax, long rmax);/* Logscale.C */

longlogscale(long d); /* Logscale.C */

floatMSBINToIEEE(float f); /* Msb2Ieee.C */

floatIEEEToMSBIN(float f); /* Msb2Ieee.C */

int perm_index (char pit[], int size);/* Perm_Idx.C */

int round_div(int n, int d); /* Rnd_Div.C */

longround_ldiv(long n, long d);/* Rnd_Div.C */

double rad2deg(double rad); /* Rad2Deg.C */

double deg2rad(double deg); /* Rad2Deg.C */

#include "pi.h"

#ifndef PHI

#define PHI ((1.0+sqrt(5.0))/2.0) /* the golden number*/

#define INV_PHI (1.0/PHI) /* the golden ratio */

#endif

/*

** File: ISQRT.C

*/

    struct int_sqrt {

    unsigned sqrt,

    frac;

};

void usqrt(unsigned long x, struct int_sqrt *q);

#endif /* SNIPMATH__H */

code:

Can't Copy and Paste this?

Click here for a copy-and-paste friendly version of this code!

Terms of Agreement:   

By using this code, you agree to the following terms...   

1) You may use this code in your own programs (and may compile it into a program and distribute it in compiled format for langauges that allow it) freely and with no charge.   

2) You MAY NOT redistribute this code (for example to a web site) without written permission from the original author. Failure to do so is a violation of copyright laws.   

3) You may link to this code from another website, but ONLY if it is not wrapped in a frame. 

4) You will abide by any additional copyright restrictions which the author may have placed in the code or code's description.  

//     

/* +++Date last modified: 05-Jul-1997 */

/*

** FACTORYL.C

**

** Original Copyright 1992 by Bob Stout as part of

** the MicroFirm Function Library (MFL)

**

** The user is granted a free limited license to use this source file

** to create royalty-free programs, subject to the terms of the

** license restrictions specified in the LICENSE.MFL file.

**

** Uses DBLROUND.C, also in SNIPPETS

*/

#include 

#include "snipmath.h"

#define dfrac(x) ((x)-dround(x))

#define SQRT2PI sqrt(2 * PI)

#define ONESIXTH (1.0/6.0)

/*

** log10factorial()

**

** Returns the logarithm (base 10) of the factorial of a given number.

** The logarithm is returned since this allows working with extremely

** large values which would otherwise overflow the F.P. range.

**

** Parameters: 1 - Number whose factorial to return.

**

** Returns: log10() of the passed value, -1.0 if error

**

** Limitations: Cannot return 0! since log(0) is undefined.

*/

double log10factorial(double N)

    {

    double dummy;

    if ((N < 1.0) || (0.0 != modf(N, &dummy)))

    return -1.0;

    if (N < 40) /* Small, explicitly compute */

        {

        int i;

        double f;

        if (0.0 == N)

        return N;

        for (i = 1, f = 1.0; i <= (int)N; ++i)

        f *= i;

        return log10(f);

    }

    else/* Large, use approximation*/

        {

        return log10(SQRT2PI)+((N + 0.5) *

        (log10(sqrt(N * N + N + ONESIXTH) / exp(1.0))));

    }

}

#ifdef TEST

#include 

#include 

main(int argc, char *argv[])

    {

    double f, lf;

    char *dummy;

    while (--argc)

        {

        f = strtod((const char *)(*(++argv)), &dummy);

        if (0.0 == f)

            {

            puts("0! = 0");

            continue;

        }

        if (-1.0 == (lf = log10factorial(f)))

            {

            printf(">>> ERROR: %g! is not a valid expression\n", f);

            continue;

        }

        if (171.0 > f)

        printf("%.14g! = %.14g\n", f, pow(10.0, lf));

        else

            {

            printf("%.14g! = %.14ge+%ld\n", f,

            pow(10.0, dfrac(lf)), (long)dround(lf));

        }

    }

    lf = log10C(1000000L,750000L);

    printf("\nJust to dazzle with you with big numbers:\n"

    "C(1000000,750000) = %.14ge+%ld\n",

    pow(10.0, dfrac(lf)), (long)dround(lf));

    lf = log10P(1000000L,750000L);

    printf("\n...once more:\n"

    "P(1000000,750000) = %.14ge+%ld\n",

    pow(10.0, dfrac(lf)), (long)dround(lf));

    return EXIT_SUCCESS;

}

#endif /* TEST */