John said:
That's the school-book definition. In a serious text-book x! is defined
as an integral, for any real x. The book then goes on to prove that
(x+1)! = (x+1)*x and that 0! = 1. From this you can use a for loop to
calculate 1!, 2!, 3!, ..., just as in a school text-book.
The 'school-book' definition is the formal definition of the factorial
for natural numbers (including zero) which I think can be assumed unless
something more complex is indicated.
The basic factorial function can be modified to estimate factorials for
fractions, but I don't think that alters the above. I'd bee keen to see
a JavaScript implementation of the factorial function for non-integers. ;-)
The modified function can be used to determine values for negative
fractions but their behaviour is bizarre and as far as I can tell have
no useful purpose - exactly what is complex negative infinity?
Every formal definition of a factorial I can find only relates to
numbers greater than or equal to zero, so I'll continue to believe that
n! is undefined where n<0.
The Wolfram Research page probably has more than any of us wishes to know:
<URL:
http://mathworld.wolfram.com/Factorial.html >
[...]
I'm not the original poster so I don't know what's needed. My intention
was to point out that the answer depends on the context.
Ooops, sorry. I got my threads crossed. :-x
For instance, if the context is statistical tests of significance then
0.5! is likely to crop up. On the other hand, if the context is
combinations then both 0.5 and 0 are very likely to be errors.
In that case I'd try to avoid non-integers, which should be possible in
most cases.
Simplified functions can be defined for specific non-integer cases - a
function that calculates half-integer factorials is below (the error
message could be more useful
):
function halfFactorial(n)
{
if ( n < 0 || (n-0.5) % 1) {
return 'Only +ve half-integers will do, e.g. 0.5, 3.5, etc.';
}
var rtPI = Math.sqrt(Math.atan(1)*4);
var x=1;
while (n>0){
x *= n--;
}
return (rtPI*x).toFixed(2);
}
Which gives:
0.5! = 0.89
1.5! = 1.33
2.5! = 3.32
3.5! = 11.63
4.5! = 52.34
But it should only be used for halves, not whole numbers and I have no
idea what it would be useful for. A general solution for non-integer
factorials written in JavaScript might be useful.
[...]
Obviously, silly values should be trapped as close to the input as
possible. Then you have to choose what the factorial function should do.
One choice is to ignore the problem as it's not going to happen. The
other is to check the parameter and return a special value if it's bad.
This has the disadvantage that you have to check the function with
several silly values, not just sensible ones.
Yes, I presumed the OP's post was just an example. Hopefully we've
provided food for thought - I've had some fun!
