Whgere can I find Factorial source code?

[petertwocakes]

Does anyone know where I could find a factorial function (C/C++) that
will handle large numbers up to 1000!
Googling has only found trivial ones that work up to 20!

Thanks

 

[user923005]

Does anyone know where I could find a factorial function (C/C++) that
will handle large numbers up to 1000!
Googling has only found trivial ones that work up to 20!

A web search of old postings for this newsgroup will turn something
up, I think.

If you want to do something with those numbers besides looking at
them, you will have to use an extended precision package.

I am fond of MPFR.
http://www.mpfr.org/

If you need native data type support, then this program:
http://cap.connx.com/chess-engines/new-approach/factorial.c.bz2
will return the largest factorial that your computer can store in long
double format

 

[jacob navia]

Does anyone know where I could find a factorial function (C/C++) that
will handle large numbers up to 1000!
Googling has only found trivial ones that work up to 20!

Thanks

Using the lcc-win compiler:

#include <qfloat.h>
#include <stdio.h>
#include <stdlib.h>
qfloat factorial(int n)
{
qfloat r = 1.0;
qfloat i = 1.0;

while (n > 0) {
r = r*i;
i++;
n--;
}
return r;
}

int main(int argc,char *argv[])
{
if (argc < 2) {
printf("Usage: factorial <number>\n");
return 0;
}
int n = atoi(argv[1]);
printf("Factorial %d =\n %110.105qf\n",n,factorial(n));
}

Output:
d:\lcc\mc75\test>tfact 1000
Factorial 1000 =
4.023872600770937735437024339230039857193748642107146325437999104299385123986290205920442
08486969404800480e+2567

Qfloats are floating point numbers. If you want more precision than the
105 digits qfloat gives you, you can use bignums with the lcc-win
*compiler:

#include <bignums.h>
#include <stdio.h>
#include <stdlib.h>
pBignum factorial(int n)
{
pBignum r = newBignum(1);
pBignum i = newBignum(1);

while (n > 0) {
r = r*i;
i = i+1;
n--;
}
return r;
}

int main(int argc,char *argv[])
{
pBignum b;
char buf[8192];
if (argc < 2) {
printf("Usage: factorial <number>\n");
return 0;
}
int n = atoi(argv[1]);
BignumPrecision(500);
b = factorial(n);
quadformat(b,buf);
puts(buf);
}

OUTPUT:
d:\lcc\mc75\test>tfact1 1000
402387260077093773543702433923003985719374864210714632543799910429938512398629020592044208
486969404800479988610197196058631666872994808558901323829669944590997424504087073759918823
627727188732519779505950995276120874975462497043601418278094646496291056393887437886487337
119181045825783647849977012476632889835955735432513185323958463075557409114262417474349347
553428646576611667797396668820291207379143853719588249808126867838374559731746136085379534
524221586593201928090878297308431392844403281231558611036976801357304216168747609675871348
312025478589320767169132448426236131412508780208000261683151027341827977704784635868170164
365024153691398281264810213092761244896359928705114964975419909342221566832572080821333186
116811553615836546984046708975602900950537616475847728421889679646244945160765353408198901
385442487984959953319101723355556602139450399736280750137837615307127761926849034352625200
015888535147331611702103968175921510907788019393178114194545257223865541461062892187960223
838971476088506276862967146674697562911234082439208160153780889893964518263243671616762179
168909779911903754031274622289988005195444414282012187361745992642956581746628302955570299
024324153181617210465832036786906117260158783520751516284225540265170483304226143974286933
061690897968482590125458327168226458066526769958652682272807075781391858178889652208164348
344825993266043367660176999612831860788386150279465955131156552036093988180612138558600301
435694527224206344631797460594682573103790084024432438465657245014402821885252470935190620
929023136493273497565513958720559654228749774011413346962715422845862377387538230483865688
976461927383814900140767310446640259899490222221765904339901886018566526485061799702356193
897017860040811889729918311021171229845901641921068884387121855646124960798722908519296819
372388642614839657382291123125024186649353143970137428531926649875337218940694281434118520
158014123344828015051399694290153483077644569099073152433278288269864602789864321139083506
217095002597389863554277196742822248757586765752344220207573630569498825087968928162753848
863396909959826280956121450994871701244516461260379029309120889086942028510640182154399457
156805941872748998094254742173582401063677404595741785160829230135358081840096996372524230
560855903700624271243416909004153690105933983835777939410970027753472000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000

You can download the lcc-win compiler from the URL below

 

[user923005]

Does anyone know where I could find a factorial function (C/C++) that
will handle large numbers up to 1000!
Googling has only found trivial ones that work up to 20!

Thanks

Using the lcc-win compiler:

#include <qfloat.h>
#include <stdio.h>
#include <stdlib.h>
qfloat factorial(int n)
{
         qfloat r = 1.0;
         qfloat i = 1.0;

         while (n > 0) {
                 r = r*i;
                 i++;
                 n--;
         }
         return r;

}

int main(int argc,char *argv[])
{
         if (argc < 2) {
                 printf("Usage: factorial <number>\n");
                 return 0;
         }
         int n = atoi(argv[1]);
         printf("Factorial %d =\n %110.105qf\n",n,factorial(n));

}

Output:
d:\lcc\mc75\test>tfact 1000
Factorial 1000 =
4.0238726007709377354370243392300398571937486421071463254379991042993851239­86290205920442
08486969404800480e+2567

Qfloats are floating point numbers. If you want more precision than the
105 digits qfloat gives you, you can use bignums with the lcc-win
*compiler:

#include <bignums.h>
#include <stdio.h>
#include <stdlib.h>
pBignum factorial(int n)
{
         pBignum r = newBignum(1);
         pBignum i = newBignum(1);

         while (n > 0) {
                 r = r*i;
                 i = i+1;
                 n--;
         }
         return r;

}

int main(int argc,char *argv[])
{
         pBignum b;
         char buf[8192];
         if (argc < 2) {
                 printf("Usage: factorial <number>\n");
                 return 0;
         }
         int n = atoi(argv[1]);
         BignumPrecision(500);
         b = factorial(n);
         quadformat(b,buf);
         puts(buf);

}

OUTPUT:
d:\lcc\mc75\test>tfact1 1000
402387260077093773543702433923003985719374864210714632543799910429938512398­629020592044208
486969404800479988610197196058631666872994808558901323829669944590997424504­087073759918823
627727188732519779505950995276120874975462497043601418278094646496291056393­887437886487337
119181045825783647849977012476632889835955735432513185323958463075557409114­262417474349347
553428646576611667797396668820291207379143853719588249808126867838374559731­746136085379534
524221586593201928090878297308431392844403281231558611036976801357304216168­747609675871348
312025478589320767169132448426236131412508780208000261683151027341827977704­784635868170164
365024153691398281264810213092761244896359928705114964975419909342221566832­572080821333186
116811553615836546984046708975602900950537616475847728421889679646244945160­765353408198901
385442487984959953319101723355556602139450399736280750137837615307127761926­849034352625200
015888535147331611702103968175921510907788019393178114194545257223865541461­062892187960223
838971476088506276862967146674697562911234082439208160153780889893964518263­243671616762179
168909779911903754031274622289988005195444414282012187361745992642956581746­628302955570299
024324153181617210465832036786906117260158783520751516284225540265170483304­226143974286933
061690897968482590125458327168226458066526769958652682272807075781391858178­889652208164348
344825993266043367660176999612831860788386150279465955131156552036093988180­612138558600301
435694527224206344631797460594682573103790084024432438465657245014402821885­252470935190620
929023136493273497565513958720559654228749774011413346962715422845862377387­538230483865688
976461927383814900140767310446640259899490222221765904339901886018566526485­061799702356193
897017860040811889729918311021171229845901641921068884387121855646124960798­722908519296819
372388642614839657382291123125024186649353143970137428531926649875337218940­694281434118520
158014123344828015051399694290153483077644569099073152433278288269864602789­864321139083506
217095002597389863554277196742822248757586765752344220207573630569498825087­968928162753848
863396909959826280956121450994871701244516461260379029309120889086942028510­640182154399457
156805941872748998094254742173582401063677404595741785160829230135358081840­096996372524230
560855903700624271243416909004153690105933983835777939410970027753472000000­000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000­000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000­000000000000000
000000000000000000000000000000000000000000000000

You can download the lcc-win compiler from the URL below

This is unspeakably cool. I wish pBignum and Qfloat would get
incorporated into the next C standard.

Sure, you can do the same thing using Moshier's library and other
tools like MIRACL or MPFR, but it is a lot cleaner to use native
operations instead of library calls.

I am finally convinced to download it and play around with it.

So now my first feature request (and I have not even tried it yet):
Generate 64 bit binaries.

 

[petertwocakes]

Using the lcc-win compiler:

#include <qfloat.h>
#include <stdio.h>
#include <stdlib.h>
qfloat factorial(int n)
{
         qfloat r = 1.0;
         qfloat i = 1.0;

         while (n > 0) {
                 r = r*i;
                 i++;
                 n--;
         }
         return r;

}

int main(int argc,char *argv[])
{
         if (argc < 2) {
                 printf("Usage: factorial <number>\n");
                 return 0;
         }
         int n = atoi(argv[1]);
         printf("Factorial %d =\n %110.105qf\n",n,factorial(n));

}

Output:
d:\lcc\mc75\test>tfact 1000
Factorial 1000 =
4.0238726007709377354370243392300398571937486421071463254379991042993851239 ­86290205920442
08486969404800480e+2567

Qfloats are floating point numbers. If you want more precision than the
105 digits qfloat gives you, you can use bignums with the lcc-win
*compiler:

#include <bignums.h>
#include <stdio.h>
#include <stdlib.h>
pBignum factorial(int n)
{
         pBignum r = newBignum(1);
         pBignum i = newBignum(1);

         while (n > 0) {
                 r = r*i;
                 i = i+1;
                 n--;
         }
         return r;

}

int main(int argc,char *argv[])
{
         pBignum b;
         char buf[8192];
         if (argc < 2) {
                 printf("Usage: factorial <number>\n");
                 return 0;
         }
         int n = atoi(argv[1]);
         BignumPrecision(500);
         b = factorial(n);
         quadformat(b,buf);
         puts(buf);

}

OUTPUT:
d:\lcc\mc75\test>tfact1 1000
402387260077093773543702433923003985719374864210714632543799910429938512398 ­629020592044208
486969404800479988610197196058631666872994808558901323829669944590997424504 ­087073759918823
627727188732519779505950995276120874975462497043601418278094646496291056393 ­887437886487337
119181045825783647849977012476632889835955735432513185323958463075557409114 ­262417474349347
553428646576611667797396668820291207379143853719588249808126867838374559731 ­746136085379534
524221586593201928090878297308431392844403281231558611036976801357304216168 ­747609675871348
312025478589320767169132448426236131412508780208000261683151027341827977704 ­784635868170164
365024153691398281264810213092761244896359928705114964975419909342221566832 ­572080821333186
116811553615836546984046708975602900950537616475847728421889679646244945160 ­765353408198901
385442487984959953319101723355556602139450399736280750137837615307127761926 ­849034352625200
015888535147331611702103968175921510907788019393178114194545257223865541461 ­062892187960223
838971476088506276862967146674697562911234082439208160153780889893964518263 ­243671616762179
168909779911903754031274622289988005195444414282012187361745992642956581746 ­628302955570299
024324153181617210465832036786906117260158783520751516284225540265170483304 ­226143974286933
061690897968482590125458327168226458066526769958652682272807075781391858178 ­889652208164348
344825993266043367660176999612831860788386150279465955131156552036093988180 ­612138558600301
435694527224206344631797460594682573103790084024432438465657245014402821885 ­252470935190620
929023136493273497565513958720559654228749774011413346962715422845862377387 ­538230483865688
976461927383814900140767310446640259899490222221765904339901886018566526485 ­061799702356193
897017860040811889729918311021171229845901641921068884387121855646124960798 ­722908519296819
372388642614839657382291123125024186649353143970137428531926649875337218940 ­694281434118520
158014123344828015051399694290153483077644569099073152433278288269864602789 ­864321139083506
217095002597389863554277196742822248757586765752344220207573630569498825087 ­968928162753848
863396909959826280956121450994871701244516461260379029309120889086942028510 ­640182154399457
156805941872748998094254742173582401063677404595741785160829230135358081840 ­096996372524230
560855903700624271243416909004153690105933983835777939410970027753472000000 ­000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000 ­000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000 ­000000000000000
000000000000000000000000000000000000000000000000

You can download the lcc-win compiler from the URL below

This is unspeakably cool.  I wish pBignum and Qfloat would get
incorporated into the next C standard.

Sure, you can do the same thing using Moshier's library and other
tools like MIRACL or MPFR, but it is a lot cleaner to use native
operations instead of library calls.

I am finally convinced to download it and play around with it.

So now my first feature request (and I have not even tried it yet):
Generate 64 bit binaries.

Cool indeed, unfortunately I don't have access to a Windows machine
( yes, we do exist ;-) )

 

[petertwocakes]

A web search of old postings for this newsgroup will turn something
up, I think.

If you want to do something with those numbers besides looking at
them, you will have to use an extended precision package.

I am fond of MPFR.http://www.mpfr.org/

If you need native data type support, then this program:http://cap.connx.com/chess-engines/new-approach/factorial.c.bz2
will return the largest factorial that your computer can store in long
double format

Yes, thanks, it seems the general advice is to find a big number
library. I thought there might be a way of working with arrays to
store digits, but as you say, I want to do more than just look at them.

 

[user923005]

petertwocakes wrote:
Does anyone know where I could find a factorial function (C/C++) that
will handle large numbers up to 1000!
Googling has only found trivial ones that work up to 20!
Thanks
Using the lcc-win compiler:
#include <qfloat.h>
#include <stdio.h>
#include <stdlib.h>
qfloat factorial(int n)
{
         qfloat r = 1.0;
         qfloat i = 1.0;
         while (n > 0) {
                 r = r*i;
                 i++;
                 n--;
         }
         return r;
}
int main(int argc,char *argv[])
{
         if (argc < 2) {
                 printf("Usage: factorial <number>\n");
                 return 0;
         }
         int n = atoi(argv[1]);
         printf("Factorial %d =\n %110.105qf\n",n,factorial(n));
}
Output:
d:\lcc\mc75\test>tfact 1000
Factorial 1000 =
4.0238726007709377354370243392300398571937486421071463254379991042993851239 ­86290205920442
08486969404800480e+2567
Qfloats are floating point numbers. If you want more precision than the
105 digits qfloat gives you, you can use bignums with the lcc-win
*compiler:
#include <bignums.h>
#include <stdio.h>
#include <stdlib.h>
pBignum factorial(int n)
{
         pBignum r = newBignum(1);
         pBignum i = newBignum(1);
         while (n > 0) {
                 r = r*i;
                 i = i+1;
                 n--;
         }
         return r;
}
int main(int argc,char *argv[])
{
         pBignum b;
         char buf[8192];
         if (argc < 2) {
                 printf("Usage: factorial <number>\n");
                 return 0;
         }
         int n = atoi(argv[1]);
         BignumPrecision(500);
         b = factorial(n);
         quadformat(b,buf);
         puts(buf);
}
OUTPUT:
d:\lcc\mc75\test>tfact1 1000
402387260077093773543702433923003985719374864210714632543799910429938512398 ­629020592044208
486969404800479988610197196058631666872994808558901323829669944590997424504 ­087073759918823
627727188732519779505950995276120874975462497043601418278094646496291056393 ­887437886487337
119181045825783647849977012476632889835955735432513185323958463075557409114 ­262417474349347
553428646576611667797396668820291207379143853719588249808126867838374559731 ­746136085379534
524221586593201928090878297308431392844403281231558611036976801357304216168 ­747609675871348
312025478589320767169132448426236131412508780208000261683151027341827977704 ­784635868170164
365024153691398281264810213092761244896359928705114964975419909342221566832 ­572080821333186
116811553615836546984046708975602900950537616475847728421889679646244945160 ­765353408198901
385442487984959953319101723355556602139450399736280750137837615307127761926 ­849034352625200
015888535147331611702103968175921510907788019393178114194545257223865541461 ­062892187960223
838971476088506276862967146674697562911234082439208160153780889893964518263 ­243671616762179
168909779911903754031274622289988005195444414282012187361745992642956581746 ­628302955570299
024324153181617210465832036786906117260158783520751516284225540265170483304 ­226143974286933
061690897968482590125458327168226458066526769958652682272807075781391858178 ­889652208164348
344825993266043367660176999612831860788386150279465955131156552036093988180 ­612138558600301
435694527224206344631797460594682573103790084024432438465657245014402821885 ­252470935190620
929023136493273497565513958720559654228749774011413346962715422845862377387 ­538230483865688
976461927383814900140767310446640259899490222221765904339901886018566526485 ­061799702356193
897017860040811889729918311021171229845901641921068884387121855646124960798 ­722908519296819
372388642614839657382291123125024186649353143970137428531926649875337218940 ­694281434118520
158014123344828015051399694290153483077644569099073152433278288269864602789 ­864321139083506
217095002597389863554277196742822248757586765752344220207573630569498825087 ­968928162753848
863396909959826280956121450994871701244516461260379029309120889086942028510 ­640182154399457
156805941872748998094254742173582401063677404595741785160829230135358081840 ­096996372524230
560855903700624271243416909004153690105933983835777939410970027753472000000 ­000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000 ­000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000 ­000000000000000
000000000000000000000000000000000000000000000000
You can download the lcc-win compiler from the URL below

This is unspeakably cool.  I wish pBignum and Qfloat would get
incorporated into the next C standard.

Sure, you can do the same thing using Moshier's library and other
tools like MIRACL or MPFR, but it is a lot cleaner to use native
operations instead of library calls.

I am finally convinced to download it and play around with it.

So now my first feature request (and I have not even tried it yet):
Generate 64 bit binaries.

Cool indeed, unfortunately I don't have access to a Windows machine
( yes, we do exist ;-)  )

You can achieve the same thing by using the MPFR library I mentioned
above.
The only difference is that it will be function calls instead of
mathematical notation.

 

[jacob navia]

Cool indeed, unfortunately I don't have access to a Windows machine
( yes, we do exist ;-) )

I am porting the 64 bit compiler to linux UBUNTU series.
I have run into several problems, kind of difficult to fix.

I generate "stabs" debug info, but gdb stopped supporting that
format some time ago. It has a bug that makes looking at
variables impossible. I downloaded gdb source code and fixed their bug,
but even if I mailed my patch gnu did NOT update the source
code, so you will need a patched version of gdb.

This wouldn't be so difficult but I have had a lot of problems
with the parameter passing convention that under linux is
quite nightmarish to generate, specially for the variable
arguments functions.

But I am making progress, I think it could be ready for
the spring.

 

[Kenny McCormack]

Cool indeed, unfortunately I don't have access to a Windows machine
( yes, we do exist ;-)  )

You can achieve the same thing by using the MPFR library I mentioned
above. The only difference is that it will be function calls instead
of mathematical notation.[/QUOTE]

You can, in fact, achieve the same thing by using assembly language, as
I may (or may not) have mentioned previously. The only difference is
that it will be invocations of machine op codes instead of function
calls or mathematical notation.