In Haskell, it's even better (without errorhandling):

fac n = product [1..n]

 

(with errorhandling):

 fac n | n > 0 = product [1..n]

 

There are many languages that don't have issues with smallints and largeints, Haskell handles them automatically, for example. Ruby does too, but the problem is that they're not "mainstream".

I really like the way Smalltalk handles ifTrue/ifFalse with closures/code blocks, where Ruby has a keyword for that.

Sure, in something like C++ you have to declare that you want to use your favorite arbitrary precision integer library, if that's what you desire. I thought Smalltalk fans would be all for that. You know, using libraries instead of adding language features.

template <class T> T fact(T n){
    T f = 1;
    if(n<0) throw std::invalid_argument("arg to fact negative");
    for(; n>1; f*=n, --n);
    return f;
}

Oh, and your non-Javascript comment entry box has a but. It apparently converts a character entity like "&lt;" into literal "<" upon preview, which subsequently gets eaten after further previews. So the first line of the function above should really be...

template <class T> T fact(T n){

Arg. It has a "BUG", I guess that's what happens when the preview feature doesn't work correctly. I guess it's slightly better than the Javascript editor, where there's no preview available at all. And do you really get that much spam that you need have rate limited posting?

There was a server error accepting your comment. You must leave at least 300 seconds between comment attempts.

Comment by James Robertson

Yes, I get a lot of spam attempts. I look at my logs periodically, and if I didn't have a throttle, I'd get hosed.

Comment by Troy Brumley

As written, the Java implementation is a bit like putting lipstick on a pig. While I prefer the recursive nature of the Java implementation from an esthetic view, I don't like that it repeats the three guard clauses every time through in addition to the overhead of recursion. There should either be a private factorial method which counts on the guard clauses in the public factorial method, or it should go through the repeated multiplication as the Cincom Smalltalk version does.

As before, here's the entire SML implementation shown on Wikipedia

  fun fact n : IntInf.int =
      if n=0 then 1 else n * fact(n - 1)

a quick look at #become: will explain what I mean
How so? The factorial example demonstrates arbitrary precision arithmetic on numbers. Numbers are immutable:

   5 become: 10000

Unhandled exception: cannot use become: on immutable objects
SmallInteger(Object)>>error:
SmallInteger(Object)>>handleFailedBecome:
SmallInteger(Object)>>primBecome:
SmallInteger(Object)>>become:

would I be able to write one method in one place?
This Smalltalk implementation only provides arbitrary precision integer arithmetic - even in Java we can write one method in one place if we only ever use arbitrary precision integer arithmetic.

  public static BigInteger factorial(BigInteger n) {
    return n.compareTo(BigInteger.ONE) <= 0 ?
       BigInteger.ONE :
       n.multiply( factorial(n.subtract(BigInteger.ONE)) ); }

Troy wrote I don't like that it repeats the three guard clauses every time... as the Cincom Smalltalk version does
The Smalltalk example code is part of Cincom's product, the Java example code is something James' grabbed off the web - it isn't anything to do with Java the language or libraries.

Comment by Troy Brumley

In Smalltalk, we can see the library implementation. In Java, I don't know. My Mac is at home, and I don't have a Java environment on this PC, so I can't go looking to figure out what might be in the Java libraries. Google returned no items for my search "java.math.factorial source" while Yahoo! found quite a few hits, but nothing I felt was pertinent.

So, Isaac, can you delve into the library?

afaik the easiest way is to look at the Java^TM API Specification index.

afaik after a decade they still haven't found a reason to add a factorial method to the standard libraries - maybe a coalition of university professors lobbied to prevent them ruining their first term class assignment :-)

If it is going to be part of the standard library, then you'd probably want to implement it with a good algorithm.

If this is Smalltalk's idea of simplicity, I'll be sticking with Ruby, thanks.

Daniel, we could write a naive factorial in Smalltalk like this

fact
   ^(self <= 1) ifTrue: [1] ifFalse: [(self - 1) fact * self]

Just for the heck of it, in Ruby...

def fac(n) n<1 ? 1 : n * fac(n-1) end

Would this correspond to the Smalltalk?

def fac self<1 ? 1 : self * (self-1).fac end