Carlos Quintanilla's blog

Factorial and Fibonacci in Ceylon

2012-07-11T14:09:00.001-07:00

Update 1: Porting code examples to Ceylon M5 - syntax changes on assignent operator, module definition and support for String Interpolation.
Update 2: Interoperability with java code via .jar containing the Stopwatch class imported as a ceylon module using ceylon import-jar.

Here below a little program in Ceylon that implements 2 modules (+ an extra utility Stopwatch java class from my previous post http://carlosqt.blogspot.com/2011/05/stopwatch-class-for-java.html). There is the module called Fiborial (Fibo(nnacci)+(Facto)rial) that implements the Fibonacci and the Factorial algorithms in two ways, one Recursive (using recursion) and the other Imperative (using loops and states). The second class is just an instance class that does the same thing, but its there just to show the difference between static and instance classes, and finally the execution of the program done by the running function "main".

You can also find 3 more little examples at the bottom. One prints out the Factorial's Series and Fibonacci's Series, the second one just shows a class that mixes both: static and instance members, and finally the third one that uses different return types (including java.math.BigInteger) for the Factorial method to compare the timing and result.

As with the previous posts, you can copy and paste the code below in your Eclipse IDE and start playing and learning with it. This little "working" program will teach you some more basics of the Programming Language.

There are some "comments" on the code added just to tell you what are or how are some features called. In case you want to review the theory, you can read my previous post, where I give a definition of each of the concepts mentioned on the code. You can find it here: http://carlosqt.blogspot.com/2011/01/new-series-factorial-and-fibonacci.html

The Fiborial Program

module com.series.staticfiborial '1.0.0' {
    shared import java.base '7';
    import blog.series.lib '1.0.0';
}

// Factorial and Fibonacci in Ceylon  
  
// Module "Static Class" using top level members  
import java.math { BigInteger { bigone=\iONE, bigzero=\iZERO,  
                                big=\IvalueOf } }  
import blog.series.lib { Stopwatch }  
  
// '(private) Static Field' + Initialization  
variable String _className = "'Static' Constructor";  
  
// Static Initializer Method instead, but need to be explicitly called.  
shared void constructor() {  
    print(_className);  
}  
  
// 'Static' Method - Factorial Recursive    
 shared BigInteger factorialR(Integer n) {    
    if (n == 1) {  
        return bigone;  
    }  
    else {  
        return big(n).multiply(factorialR(n - 1));  
    }    
}    
  
// 'Static' Method - Factorial Imperative    
shared BigInteger factorialI(Integer n) {  
    variable Integer c = n;  
    variable BigInteger res = bigone;  
    while (c > 1) {    
        res = res.multiply(big(c));  
        c--;  
    }  
    return res;  
}    
  
// 'Static' Method - Fibonacci Recursive    
shared Integer fibonacciR(Integer n) {    
    if (n < 2) {   
        return 1;  
    }    
    else {  
        return fibonacciR(n - 1) + fibonacciR(n - 2);  
    }    
}    
  
// 'Static' Method - Fibonacci Imperative    
shared Integer fibonacciI(Integer n) {    
    variable Integer pre = 1;  
    variable Integer cur = 1;  
    variable Integer tmp = 0;  
    for (i in 2..n) {    
        tmp = cur + pre;    
        pre = cur;    
        cur = tmp;    
    }    
    return cur;    
}  
  
// 'Static' Method - Benchmarking Algorithms    
shared void benchmarkAlgorithm(Integer algorithm, Integer[] values) {    
    Stopwatch timer = Stopwatch();  
    variable BigInteger facTimeResult = bigzero;  
    variable Integer fibTimeResult = 0;  
      
    if (algorithm == 1) {  
        print("\nFactorial Imperative:");  
        // "For" Loop Statement    
        for (j in 0..values.size - 1) {  
            if (exists testValue = values[j]) {  
                // Taking Time    
                timer.start();   
                facTimeResult = factorialI(testValue);  
                timer.stop();    
                // Getting Time    
                print(" (``testValue.string``) = ``timer.elapsed``");    
            }              
        }    
    }  
    else if(algorithm == 2) {  
        print("\nFactorial Recursive:");    
        // "While" Loop Statement    
        variable Integer i = 0;  
        while (i < values.size) {  
            if (exists testValue = values[i]) {       
                // Taking Time    
                timer.start();    
                facTimeResult = factorialR(testValue);    
                timer.stop();    
                // Getting Time    
                print(" (``testValue.string``) = ``timer.elapsed``");               
            }  
            i++;  
        }          
    }  
    else if (algorithm == 3) {  
        print("\nFibonacci Imperative:");    
        // "For Each" Loop Statement    
        for (testValue in values) {              
            // Taking Time    
            timer.start();   
            fibTimeResult = fibonacciI(testValue);    
            timer.stop();    
            // Getting Time    
            print(" (``testValue.string``) = ``timer.elapsed``");                        
        }    
    }  
    else if (algorithm == 4) {  
        print("\nFibonacci Recursive:");    
        // "For Each" Loop Statement    
        for (testValue in values) {              
            // Taking Time    
            timer.start();    
            fibTimeResult = fibonacciR(testValue);    
            timer.stop();    
            // Getting Time    
            print(" (``testValue.string``) = ``timer.elapsed``");  
        }          
    }  
    else {  
        print("DONG!");  
    }  
}  

doc "Run the module `com.series.staticfiborial`."  
void run() {  
    // pass    
}

module com.series.fiborial '1.0.0' {
    import java.base '7';
    shared import com.series.staticfiborial '1.0.0';
}

import java.math { BigInteger }  
import java.util { Scanner }  
import java.lang { System { sin=\Iin } }   
// Import 'Static' Module's 'methods'  
import com.series.staticfiborial { staticFiborial=constructor, benchmarkAlgorithm,  
                                    facI=factorialI, facR=factorialR,  
                                    fibI=fibonacciI, fibR=fibonacciR }  
  
// Instance Class    
class InstanceFiborial(className="Instance Constructor") {    
    // Instance Field and Constructor/Initializer  
    variable String className;  
    print(className);  
    // Instance Method - Factorial Recursive    
    shared BigInteger factorialR(Integer n) {    
        // Calling Static Method    
        return facR(n);    
    }    
    // Instance Method - Factorial Imperative    
    shared BigInteger factorialI(Integer n) {    
        // Calling Static Method    
        return facI(n);    
    }    
    // Instance Method - Fibonacci Recursive    
    shared Integer fibonacciR(Integer n) {    
        // Calling Static Method    
        return fibR(n);    
    }    
    // Instance Method - Fibonacci Imperative    
    shared Integer fibonacciI(Integer n) {    
        // Calling Static Method    
        return fibI(n);    
    }    
}    

doc "Run the module `com.series.fiborial`."  
void main() {  
    print("\n'Static' Class");    
    // Calling 'Static' Class and Methods    
    // No instantiation needed. Calling method directly from the class    
    staticFiborial();    
    print("FacImp(5) = ``facI(5).string``");    
    print("FacRec(5) = ``facR(5).string``");    
    print("FibImp(11)= ``fibI(11).string``");    
    print("FibRec(11)= ``fibR(11).string``");   
    
    print("\nInstance Class");  
    // Calling Instance Class and Methods    
    // Need to instantiate before using. Call method from instantiated object    
    value ff = InstanceFiborial();    
    print("FacImp(5) = ``ff.factorialI(5).string``");  
    print("FacRec(5) = ``ff.factorialR(5).string``");    
    print("FibImp(11)= ``ff.fibonacciI(11).string``");  
    print("FibRec(11)= ``ff.fibonacciR(11).string``");  
    
    // Create a (generic) list of integer values to test    
    // From 5 to 50 by 5        
    Integer[] values = [
        for (i in 5..50)    
            if (i%5==0) i
    ];    

    // Benchmarking Fibonacci    
    // 1 = Factorial Imperative    
    benchmarkAlgorithm(1, values);    
    // 2 = Factorial Recursive    
    benchmarkAlgorithm(2, values);    
    
    // Benchmarking Factorial    
    // 3 = Fibonacci Imperative    
    benchmarkAlgorithm(3, values);    
    // 4 = Fibonacci Recursive    
    benchmarkAlgorithm(4, values);  
    
    // Stop and exit    
    print("Press any key to exit...");   
    value s = Scanner(sin);  
    //String line = s.nextLine();  
    s.nextLine();
    s.close();  
}

And the Output is:

Printing the Factorial and Fibonacci Series

module com.series.fiborialseries '1.0.0' {
    shared import java.base '7';
}

import java.math { BigInteger { bigone=\iONE,     
                                big=\IvalueOf } }    
      
class Fiborial() {      
    // Using a StringBuilder as a list of string elements        
    shared String getFactorialSeries(Integer n) {        
        // Create the String that will hold the list        
        value series = StringBuilder();        
        // We begin by concatenating the number you want to calculate        
        // in the following format: "!# ="        
        series.append("!");        
        series.append(n.string);    
        series.append(" = ");        
        // We iterate backwards through the elements of the series        
        variable value i = n;        
        while (i > 0) {        
            // and append it to the list        
            series.append(i.string);    
            if (i > 1) {        
                series.append(" * ");    
            }        
            else {        
                series.append(" = ");    
            }    
            i--;        
        }        
        // Get the result from the Factorial Method        
        // and append it to the end of the list        
        series.append(factorial(n).string);        
        // return the list as a string        
        return series.string;     
    }    
        
    // Using a StringBuilder as a list of string elements        
    shared String getFibonnaciSeries(Integer n) {        
        // Create the String that will hold the list        
        value series = StringBuilder();        
        // We begin by concatenating the first 3 values which        
        // are always constant        
        series.append("0, 1, 1");  
        // Then we calculate the Fibonacci of each element        
        // and add append it to the list        
        for (i in 2..n) {        
            if (i < n) {       
                series.append(", ");    
            }    
            else {        
                series.append(" = ");    
            }    
            series.append(fibonacci(i).string);        
        }        
        // return the list as a string        
        return series.string;      
    }        
        
    shared BigInteger factorial(Integer n) {      
        if (n == 1) {        
              return bigone;    
        }    
        else {    
            return big(n).multiply(factorial(n - 1));    
        }             
    }             
        
    shared Integer fibonacci(Integer n) {      
        if (n < 2) {      
            return 1;    
        }    
        else {      
            return fibonacci(n - 1) + fibonacci(n - 2);    
        }    
    }          
}      
    
void run() {    
     // Printing Factorial Series      
    print("");      
    value fiborial = Fiborial();     
    print(fiborial.getFactorialSeries(5));      
    print(fiborial.getFactorialSeries(7));     
    print(fiborial.getFactorialSeries(9));      
    print(fiborial.getFactorialSeries(11));      
    print(fiborial.getFactorialSeries(40));      
    // Printing Fibonacci Series      
    print("");    
    print(fiborial.getFibonnaciSeries(5));      
    print(fiborial.getFibonnaciSeries(7));      
    print(fiborial.getFibonnaciSeries(9));      
    print(fiborial.getFibonnaciSeries(11));     
    print(fiborial.getFibonnaciSeries(40));      
}

And the Output is:

Mixing Instance and Static Members in the same Class

In Ceylon it is not possible to define a class with static members. To emulate that you need to create a module with toplevel methods, attributes, and even other instance types/classes.
"There are no static members. Instead, toplevel methods and attributes are declared as direct members of a package. This, along with certain other features, gives the language a more regular block structure." taken from Ceylon documentation.

    
module com.series.staticfiborial '1.0.0' {}

    
// Module "Static Class" using top level members  
  
// 'Static' Field'   
variable Integer _staticCount = 0;    
// 'Static' Read-Only Property/Getter  
shared Integer staticCount {  
    return _staticCount;  
}  
// 'Static' Initializer Method instead, but need to be explicitly called.  
shared void constructor() {  
    print("\nStatic Constructor ``_staticCount.string``");  
}  
// 'Static' Method  
shared void fibonacci(Integer n) {  
    _staticCount++;  
    print("\nFibonacci(``n.string``)");  
}  
  
void run() {  
    // pass  
}

    
module com.series.fiborial '1.0.0' {
    import com.series.staticfiborial '1.0.0';
}

    
import com.series.staticfiborial { staticCount, fibonacci,  
                                    staticFiborial=constructor }  
  
// Instance Class  
shared class InstanceFiborial(_instanceCount=0) {    
    // Instance Field and Constructor/Initializer  
    variable Integer _instanceCount;      
    print("Instance Constructor ``this._instanceCount.string``");      
    // Instance Read-Only Property/Getter  
    shared Integer instanceCount {  
        return this._instanceCount;  
    }  
    // Instance Method    
    shared void factorial(Integer n) {    
        this._instanceCount++;    
        print("\nFactorial(``n.string``)");    
    }    
}  
  
void main() {  
    // Calling Static Constructor and Methods    
    // No need to instantiate    
    staticFiborial();    
    fibonacci(5);    
    
    // Calling Instance Constructor and Methods    
    // Instance required    
    value fib = InstanceFiborial();    
    fib.factorial(5);    
    
    fibonacci(15);    
    fib.factorial(5);    
    
    // Calling Instance Constructor and Methods    
    // for a second object    
    value fib2 = InstanceFiborial();    
    fib2.factorial(5);    
    
    print("");    
    // Calling Static Property    
    print("Static Count = " + staticCount.string);    
    // Calling Instance Property of object 1 and 2    
    print("Instance 1 Count = " + fib.instanceCount.string);    
    print("Instance 2 Count = " + fib2.instanceCount.string);    
}

And the Output is:

Factorial using java.lang.Long, java.lang.Double, java.math.BigInteger

module com.series.fiborial '1.0.0' {
    shared import java.base '7';
    import blog.series.lib '1.0.0'; 
}

import java.math { BigInteger { bigone=\iONE, bigzero=\iZERO,  
                                big=\IvalueOf } }  
import blog.series.lib { Stopwatch }  
  
// Long/Integer Factorial      
Integer factorialInt64(Integer n) {    
    if (n == 1) {  
        return 1;  
    }  
    else {  
        return n * factorialInt64(n - 1);  
    }    
}    
  
// Double Factorial    
Float factorialDouble(Integer n) {    
    if (n == 1) {  
        return 1.0;  
    }  
    else {  
        return n * factorialDouble(n - 1);  
    }    
}    
  
// BigInteger Factorial      
BigInteger factorialBigInteger(Integer n) {    
    if (n == 1) {  
        return bigone;  
    }  
    else {  
        return big(n).multiply(factorialBigInteger(n - 1));  
    }    
}     

void main() {  
    value timer = Stopwatch();    
    variable Integer facIntResult = 0;    
    variable Float facDblResult = 0.0;    
    variable BigInteger facBigResult = bigzero;        
      
    print("\nFactorial using Int64");  
    // Benchmark Factorial using Int64    
    for (i in (5..50).by(5)) {  
        timer.start();  
        facIntResult = factorialInt64(i);   
        timer.stop();  
        print(" (``i.string``) = ``timer.elapsed.string`` : ``facIntResult.string``");    
    }  
  
    print("\nFactorial using Double");    
    // Benchmark Factorial using Double  
    for (i in (5..50).by(5)) {  
        timer.start();  
        facDblResult = factorialDouble(i);   
        timer.stop();  
        print(" (``i.string``) = ``timer.elapsed.string`` : ``facDblResult.string``");  
    }  
  
    print("\nFactorial using BigInteger");    
    // Benchmark Factorial using BigInteger  
    for (i in (5..50).by(5)) {  
        timer.start();  
        facBigResult = factorialBigInteger(i);   
        timer.stop();  
        print(" (``i.string``) = ``timer.elapsed.string`` : ``facBigResult.string``");  
    }    
}

And the Output is:

Ceylon - Basics by Example

2012-07-09T09:36:00.001-07:00

Update 1: Porting code examples to Ceylon M5 - syntax changes on assignent operator, module definition and support for String Interpolation.

Extending my Basics by Example series to a new language. today's version of the post written in Ceylon.

You can copy and paste the code below in Eclipse and start playing and learning with it. This little "working" program will teach you the basics of the Programming Language.

There are some "comments" on the code added just to tell you what are or how are some features called. In case you want to review the theory, you can read my previous post, where I give a definition of each of the concepts mentioned on the code. You can find it here: http://carlosqt.blogspot.com/2010/08/new-series-languages-basics-by-example.html

Greetings Program - Verbose

module com.series.basics '1.0.0' {
    import java.base '7';
}

// Ceylon Basics  
import java.util { Calendar, GregorianCalendar, Scanner }  
import java.lang { System { sin = \Iin } }  
  
// (Main) Constructor/Initializer  
// Instead of method and constructor overloading,   
// Ceylon supports parameters with default values and sequenced ("varargs") parameters.  
shared class Greet(_name="", _message="", _loopMessage=0) {  
    // Fields or Attributes    
    variable String _name;  
    variable String _message;  
    variable Integer _loopMessage;  
    // Getters and Setters  
    shared String name {  
        return _name;  
    }  
    assign name {  
        _name = this.capitalize(name);  
    }  
    shared String message {  
        return _message;  
    }  
    assign message {  
        _message = this.capitalize(message);  
    }  
    shared Integer loopMessage {  
        return _loopMessage;  
    }  
    assign loopMessage {  
        _loopMessage = loopMessage;  
    }  
    // Overloaded/Secondary Constructor    
    // No overloaded constructors/initializers  
    // Method 1    
    String capitalize(String val) {    
          // "if-then-else" statement    
        if (val.size > 0) {  
            return val[0..0].uppercased + val[1...];  
        }    
        else {  
            return "";  
        }  
     }  
    // Method 2    
    shared void salute() {    
        // "for" statement    
        for(i in 1..this._loopMessage) {    
            print("``this._message`` ``this._name``!");    
        }    
    }    
    // Overloaded Method    
    // No Overloaded Methods Support. New methods instead.    
    // Method 2.1    
    shared void salute21(String message, String name, Integer loopMessage) {    
        // "while" statement    
        variable Integer i = 1;    
        while (i <= loopMessage) {    
            print("``this.capitalize(message)`` ``this.capitalize(name)``!");    
            i++;    
        }    
    }    
    // Overloaded Method    
    // No Overloaded Methods Support. New methods instead.    
    // Method 2.2    
    shared void salute22(String name) {  
        Calendar dtNow = GregorianCalendar();  
        variable Integer hh = dtNow.get(dtNow.\iHOUR_OF_DAY);  
        // Ceylon doc: The type of the switched expression must be an enumerated type.   
        // You can't switch on a String or Integer. (Use if instead.)  
        // if-else-if statement  
        if (hh in 6..11) { this._message = "good morning,"; }   
        else if (hh in 12..17) { this._message = "good afternoon,"; }   
        else if (hh in 18..22) { this._message = "good evening,"; }   
        else if (hh == 23 || hh in 0..5) { this._message = "good night,"; }   
        else { this._message = "huh?"; }  
        print("``this.capitalize(this._message)`` ``this.capitalize(name)``!");  
    }  
  
}  
  
doc "Run the module `com.series.basics`."
shared void run() {  
    // Define variable object of type Greet and Instantiate. Call Constructor      
    value g = Greet();  
    // Call Setter  
    g.message = "hello";    
    g.name = "world";    
    g.loopMessage = 5;    
    // Call Method 2    
    g.salute();  
    // Call Overloaded Method 2.1 and Getter    
    g.salute21(g.message, "Ceylon", g.loopMessage);    
    // Call Overloaded Method 2.2    
    g.salute22("carlos");    
  
    print("Press any key to exit...");  
    Scanner s = Scanner(sin);  
    String line = s.nextLine();  
    s.close();  
}

Greetings Program - Minimal

module com.series.basics '1.0.0' {
    import java.base '7';
}

// Ceylon Basics  
import java.util { Calendar, GregorianCalendar, Scanner }  
import java.lang { System { sin = \Iin } }  
  
// (Main) Constructor/Initializer  
// Instead of method and constructor overloading,   
// Ceylon supports parameters with default values and sequenced ("varargs") parameters.  
class Greet(_name="", _message="", _loopMessage=0) {  
    // Fields or Attributes    
    variable String _name;  
    variable String _message;  
    variable Integer _loopMessage;  
    // Getters and Setters  
    shared String name {  
        return _name;  
    }  
    assign name {  
        _name = capitalize(name);  
    }  
    shared String message {  
        return _message;  
    }  
    assign message {  
        _message = capitalize(message);  
    }  
    shared Integer loopMessage {  
        return _loopMessage;  
    }  
    assign loopMessage {  
        _loopMessage = loopMessage;  
    }  
    // Overloaded/Secondary Constructor    
    // No overloaded constructors/initializers  
    // Method 1    
    String capitalize(String val) {    
          // "if-then-else" statement    
        if (val.size > 0) {  
            return val[0..0].uppercased + val[1...];  
        }    
        else {  
            return "";  
        }  
     }  
    // Method 2    
    shared void salute() {    
        // "for" statement    
        for(i in 1.._loopMessage) {    
            print("``_message`` ``_name``!");    
        }    
    }    
    // Overloaded Method    
    // No Overloaded Methods Support. New methods instead.    
    // Method 2.1    
    shared void salute21(String message, String name, Integer loopMessage) {    
        // "while" statement    
        variable Integer i = 1;    
        while (i <= loopMessage) {    
            print("``capitalize(message)`` ``capitalize(name)``!");    
            i++;    
        }    
    }    
    // Overloaded Method    
    // No Overloaded Methods Support. New methods instead.    
    // Method 2.2    
    shared void salute22(String name) {  
        Calendar dtNow = GregorianCalendar();  
        variable Integer hh = dtNow.get(dtNow.\iHOUR_OF_DAY);  
        // Ceylon documentation: The type of the switched expression must be an enumerated type.   
        // You can't switch on a String or Integer. (Use if instead.)  
        // if-else-if statement  
        if (hh in 6..11) { _message = "good morning,"; }   
        else if (hh in 12..17) { _message = "good afternoon,"; }   
        else if (hh in 18..22) { _message = "good evening,"; }   
        else if (hh == 23 || hh in 0..5) { _message = "good night,"; }   
        else { _message = "huh?"; }  
        print("``capitalize(_message)`` ``capitalize(name)``!");  
    }  
  
}  
  
void run() {  
    // Define variable object of type Greet and Instantiate. Call Constructor      
    value g = Greet();  
    // Call Setter  
    g.message = "hello";    
    g.name = "world";    
    g.loopMessage = 5;    
    // Call Method 2    
    g.salute();  
    // Call Overloaded Method 2.1 and Getter    
    g.salute21(g.message, "Ceylon", g.loopMessage);    
    // Call Overloaded Method 2.2    
    g.salute22("carlos");    
  
    print("Press any key to exit...");  
    value s = Scanner(sin);  
    s.nextLine();  
    s.close();  
}

And the Output is:

Note: the following is extracted from Ceylon documentation:
"you don't need to write getters and setters unless you're doing something special with the value you're getting or setting.
Don't ever write code like this in Ceylon:

variable String _name;
shared String name { return _name; }
assign name { _name=name; }

It's not necessary, and there's never any benefit to it."

That is exactly what I'm doing with the setters and loopMessage's getter, but remember that the code is like that just because I'm showing the syntax constructs, more importantly, this helps to compare with other languages. The code above is not intended to teach "good practices" nor "idiomatic" code.

Auto-Implemented Properties in Ceylon

In Ceylon there are no such auto-implemented properties that generate automatically a Java bean like getter/setter, instead you need to use class attributes directly using the shared annotation to make them public.

class UsingAttributesToSetGet() {  
    // Attributes   
    shared variable String name = "";  
    shared variable String message = "";  
    shared variable Integer loopMessage = 0;  
    // Methods    
    shared void salute() {    
        print("``message`` ``name`` ``loopMessage.string``!");   
    }    
}

void run() {  
    value g = UsingAttributesToSetGet();  
    // Set the attribute    
    g.message = "hello";    
    g.name = "world";    
    g.loopMessage = 5;    
    // print them out    
    g.salute();    
    // and print them again using the attribute    
    print("``g.message`` ``g.name`` ``g.loopMessage.string``!");
}

And the output is:

Factorial and Fibonacci in Xtend

2012-07-08T16:31:00.000-07:00

Here below a little program in Xtend that implements 2 classes (in fact, they are 3 + an extra utility Stopwatch class from my previous post http://carlosqt.blogspot.com/2011/05/stopwatch-class-for-java.html). There is the main class, called Fiborial (Fibo(nnacci)+(Facto)rial) that implements the Fibonacci and the Factorial algorithms in two ways, one Recursive (using recursion) and the other Imperative (using loops and states). The second class is just an instance class that does the same thing, but its there just to show the difference between static and instance classes, and finally the third one (which will not appear in other languages) is the Program class which has the static execution method "main".

You can also find 3 more little examples at the bottom. One prints out the Factorial's Series and Fibonacci's Series, the second one just shows a class that mixes both: static and instance members, and finally the third one that uses different return types (including java.math.BigInteger) for the Factorial method to compare the timing and result.

As with the previous posts, you can copy and paste the code below in your Eclipse IDE and start playing and learning with it. This little "working" program will teach you some more basics of the Programming Language.

There are some "comments" on the code added just to tell you what are or how are some features called. In case you want to review the theory, you can read my previous post, where I give a definition of each of the concepts mentioned on the code. You can find it here: http://carlosqt.blogspot.com/2011/01/new-series-factorial-and-fibonacci.html

The Fiborial Program

// Factorial and Fibonacci in Xtend  
package com.series
import com.series.Stopwatch
import java.math.BigInteger
import java.util.List

// Instance Class
// static is not a class modifier in Xtend
class StaticFiborial {
    // Static Field
    private static String className = "'Static' Constructor"
    // Static Constructor/Initializer  
    // no available static constructor support  
    // Static Initializer Method instead, but need to be explicitly invoked  
    def static constructor() {  
        className = "'Static' Constructor"  
        println(className)  
    }  
    // Static Method - Factorial Recursive  
    def static BigInteger factorialR(int n) {
        if (n == 1)  
              return 1BI
        else
            return BigInteger::valueOf(n) * factorialR(n - 1)       
    }
    // Static Method - Factorial Imperative  
    def static BigInteger factorialI(int n) {
        var res = 1BI
        var m = n // method parameters are final
        while (m > 1) {
            res = res * BigInteger::valueOf(m)
            m = m - 1    
        }   
        return res     
    }
    // Static Method - Fibonacci Recursive   
    def static long fibonacciR(int n) {
        if (n < 2)
            return 1L
        else
            return fibonacciR(n - 1) + fibonacciR(n - 2)
    } 
    // Static Method - Fibonacci Imperative
    def static long fibonacciI(int n) {
        var pre = 1L
        var cur = 1L
        var tmp = 0L
        for (int i : 2..n) {
            tmp = cur + pre
            pre = cur
            cur = tmp
        }             
        return cur
    }    
    // Static Method - Benchmarking Algorithms  
      def static void benchmarkAlgorithm(int algorithm, List<Integer> values) {  
        val timer = new Stopwatch  
        var testValue = 0
        var facTimeResult = 0BI  
        var fibTimeResult = 0L 
        var i = 0 
        // "Switch" Flow Control Statement
        switch algorithm {
            case 1: {
                println("\nFactorial Imperative:")  
                // "For" Loop Statement  
                for (int j : 0..values.size - 1) {  
                    testValue = values.get(j).intValue
                    // Taking Time
                    timer.start
                    facTimeResult = factorialI(testValue)  
                    timer.stop 
                    // Getting Time  
                    println(''' («testValue») = «timer.getElapsed»''')
                    }
                }
            case 2: {
                println("\nFactorial Recursive:")    
                // "While" Loop Statement                
                while (i < values.size) {                            
                    testValue = values.get(i).intValue    
                    // Taking Time    
                    timer.start    
                    facTimeResult = factorialR(testValue)    
                    timer.stop    
                    // Getting Time    
                    println(''' («testValue») = «timer.getElapsed»''')
                    i = i + 1    
                }
            }
            case 3: {
                println("\nFibonacci Imperative:")   
                // "Do-While" Loop Statement
                do {    
                    testValue = values.get(i).intValue    
                    // Taking Time    
                    timer.start    
                    fibTimeResult = fibonacciI(testValue)    
                    timer.stop
                    // Getting Time    
                    println(''' («testValue») = «timer.getElapsed»''')
                    i = i + 1        
                } while (i < values.size)    
            }
            case 4: {
                println("\nFibonacci Recursive:")    
                // "For Each" Loop Statement    
                for (int item : values) {    
                    testValue = item;    
                    // Taking Time    
                    timer.start    
                    fibTimeResult = fibonacciR(testValue)    
                    timer.stop    
                    // Getting Time    
                    println(''' («testValue») = «timer.getElapsed»''')
                }    
            }
            default : println("DONG!")
        }
    }
}

package com.series
import com.series.StaticFiborial
import java.math.BigInteger

// Instance Class    
class InstanceFiborial {
    // Instance Field    
    private String className    
    // Instance Constructor    
    new() {    
        this.className = "Instance Constructor"
        println(this.className)
    }    
    // Instance Method - Factorial Recursive    
    def BigInteger factorialR(int n) {    
        // Calling Static Method    
        return StaticFiborial::factorialR(n)    
    }    
    // Instance Method - Factorial Imperative    
    def BigInteger factorialI(int n) {    
        // Calling Static Method
        return StaticFiborial::factorialI(n)
    }    
    // Instance Method - Fibonacci Recursive
    def long fibonacciR(int n) {    
        // Calling Static Method    
        return StaticFiborial::fibonacciR(n)    
    }    
    // Instance Method - Factorial Imperative    
    def long fibonacciI(int n) {    
        // Calling Static Method    
        return StaticFiborial::fibonacciI(n);    
    }    
}

package com.series
import com.series.StaticFiborial
import com.series.InstanceFiborial 
import java.util.List
import java.util.ArrayList
import java.util.Scanner

class FiborialProgram {
    def static main(String[] args) {
        println("\n'Static' Class")    
        // Calling Static Class and Methods    
        // No instantiation needed. Calling method directly from the class
        StaticFiborial::constructor        
        println('''FacImp(5) = «StaticFiborial::factorialI(5)»''')    
        println('''FacRec(5) = «StaticFiborial::factorialR(5)»''')    
        println('''FibImp(11)= «StaticFiborial::fibonacciI(11)»''')    
        println('''FibRec(11)= «StaticFiborial::fibonacciR(11)»''')    

        println("\nInstance Class");    
        // Calling Instance Class and Methods     
        // Need to instantiate before using. Calling method from instantiated object    
        val ff = new InstanceFiborial
        println('''FacImp(5) = «ff.factorialI(5)»''')
        println('''FacRec(5) = «ff.factorialR(5)»''')  
        println('''FibImp(11)= «ff.fibonacciI(11)»''')   
        println('''FibRec(11)= «ff.fibonacciR(11)»''')  
  
        // Create a (generic) list of integer values to test    
        // From 5 to 50 by 5    
        val List<Integer> values = new ArrayList<Integer>
        var i = 5
        while (i < 55) {  
            values.add(i)  
            i = i + 5  
        }
  
        // Benchmarking Fibonacci                         
        // 1 = Factorial Imperative                
        StaticFiborial::benchmarkAlgorithm(1, values)    
        // 2 = Factorial Recursive    
        StaticFiborial::benchmarkAlgorithm(2, values)     
  
        // Benchmarking Factorial                
        // 3 = Fibonacci Imperative    
        StaticFiborial::benchmarkAlgorithm(3, values)    
        // 4 = Fibonacci Recursive    
        StaticFiborial::benchmarkAlgorithm(4, values)     
  
        // Stop and exit    
        println("Press any key to exit...")          
        val in = new Scanner(System::in)    
        val line = in.nextLine    
        in.close         
    }
}

And the Output is:

Printing the Factorial and Fibonacci Series

package com.series
import java.math.BigInteger
import java.lang.StringBuffer

class Fiborial {
    // Using a StringBuffer as a list of string elements  
    def static String getFactorialSeries(int n) {  
        // Create the String that will hold the list  
        val series = new StringBuffer  
        // We begin by concatenating the number you want to calculate  
        // in the following format: "!# ="  
        series.append("!")  
        series.append(n) 
        series.append(" = ")  
        // We iterate backwards through the elements of the series  
        var i = n  
        while (i > 0) {  
            // and append it to the list  
            series.append(i)  
            if (i > 1)  
                series.append(" * ")  
            else  
                series.append(" = ")  
            i = i - 1  
        }  
        // Get the result from the Factorial Method  
        // and append it to the end of the list  
        series.append(factorial(n))  
        // return the list as a string  
        return series.toString
    }  
  
    // Using a StringBuffer as a list of string elements  
    def static String getFibonnaciSeries(int n)  
    {  
        // Create the String that will hold the list  
        val series = new StringBuffer  
        // We begin by concatenating the first 3 values which  
        // are always constant  
        series.append("0, 1, 1")
        // Then we calculate the Fibonacci of each element  
        // and add append it to the list  
        for (int i : 2..n) {  
            if (i < n)  
                series.append(", ")  
            else  
                series.append(" = ")  
            series.append(fibonacci(i))  
        }  
        // return the list as a string  
        return series.toString
    }  
  
    def static BigInteger factorial(int n) {
        if (n == 1)  
              return 1BI
        else
            return BigInteger::valueOf(n) * factorial(n - 1)       
    }       
  
    def static long fibonacci(int n) {
        if (n < 2)
            return 1L
        else
            return fibonacci(n - 1) + fibonacci(n - 2)
    }    
}

package com.series
import com.series.Fiborial

class FiborialProgram {
    def static void main(String[] args) {
        // Printing Factorial Series  
        println 
        println(Fiborial::getFactorialSeries(5))
        println(Fiborial::getFactorialSeries(7))  
        println(Fiborial::getFactorialSeries(9))  
        println(Fiborial::getFactorialSeries(11))  
        println(Fiborial::getFactorialSeries(40))  
        // Printing Fibonacci Series  
        println 
        println(Fiborial::getFibonnaciSeries(5))  
        println(Fiborial::getFibonnaciSeries(7))  
        println(Fiborial::getFibonnaciSeries(9))  
        println(Fiborial::getFibonnaciSeries(11))  
        println(Fiborial::getFibonnaciSeries(40))  
    }
}

And the Output is:

Mixing Instance and Static Members in the same Class

Instance classes can contain both, instance and static members such as: fields, getters/setters, constructors/initializers, methods, etc.

package com.series

class Fiborial {
    // Instance Field    
    var int instanceCount
    // Static Field    
    static var int staticCount
    // Instance Read-Only Getter    
    // Within instance members, you can always use      
    // the "this" reference pointer to access your (instance) members.    
    def int getInstanceCount() {    
        return this.instanceCount     
    }    
    // Static Read-Only Getter        
    // As with Static Methods, you cannot reference your class members    
    // with the "this" reference pointer since static members are not    
    // instantiated.            
    def static int getStaticCount() {    
        return staticCount
    }    
    // Instance Constructor    
    public new() {    
        this.instanceCount = 0
        println    
        println('''Instance Constructor «this.instanceCount»''')   
    }    
    // Static Constructor 
    // not supported in Xtend. Constructor cannot be static.
    // using an explicit initializer method instead    
    def static constructor() { 
        staticCount = 0
        println 
        println('''Static Constructor «staticCount»''') 
    }    
    // Instance Method    
    def void factorial(int n) {    
        this.instanceCount =  this.instanceCount + 1
        println    
        println('''Factorial(«n»)''')    
    }    
  
    // Static Method    
    def static void fibonacci(int n) {    
        staticCount = staticCount + 1
        println    
        println('''Fibonacci(«n»)''');    
    }                    
}

package com.series
import com.series.Fiborial

class FiborialProgram {
    def static void main(String[] args) {
        // Calling Static Initializer and Methods  
        // No need to instantiate  
        Fiborial::constructor  
        Fiborial::fibonacci(5)  
      
        // Calling Instance Constructor and Methods  
        // Instance required  
        val fib = new Fiborial  
        fib.factorial(5)  
      
        Fiborial::fibonacci(15)  
        fib.factorial(5)  
      
        // Calling Instance Constructor and Methods  
        // for a second object  
        val fib2 = new Fiborial  
        fib2.factorial(5)  
      
        println
        // Calling Static Property  
        println('''Static Count = «Fiborial::getStaticCount»''')  
        // Calling Instance Property of object 1 and 2  
        println('''Instance 1 Count = «fib.getInstanceCount»''')  
        println('''Instance 2 Count = «fib2.getInstanceCount»''')          
    } 
}

And the Output is:

Factorial using java.lang.Long, java.lang.Double, java.math.BigInteger

package com.series
import com.series.Stopwatch
import java.math.BigInteger

class Fiborial {
    def static void main(String[] args) {
        val timer = new Stopwatch  
        var facIntResult = 0L
        var facDblResult  = 0d  
        var facBigResult = 0BI 
        var i = 5
        
        println("\nFactorial using Int64")  
        // Benchmark Factorial using Int64  
        while (i < 55) {  
            timer.start
            facIntResult = factorialInt64(i)  
            timer.stop  
              println(''' (Â«iÂ») = «timer.getElapsed» : «facIntResult»''')  
              i = i + 5  
        }  
        println("\nFactorial using Double")  
        // Benchmark Factorial using Double  
        i = 5  
        while (i < 55) {  
            timer.start  
            facDblResult = factorialDouble(i)  
            timer.stop
            println(''' («i») = «timer.getElapsed» : «facDblResult»''')  
            i = i + 5  
        }  
        println("\nFactorial using BigInteger")  
        // Benchmark Factorial using BigInteger  
        i = 5  
        while (i < 55) {  
            timer.start  
            facBigResult = factorialBigInteger(i)  
            timer.stop  
              println(''' («i») = «timer.getElapsed» : «facBigResult»''')  
            i = i + 5    
        }  
    }
    
    // Long Factorial    
    def static long factorialInt64(int n) {    
        if (n == 1)    
            return 1L  
        else    
            return n * factorialInt64(n - 1)  
    }  
      
    // Double Factorial
    def static double factorialDouble(int n) {    
        if (n == 1)    
            return 1d
        else    
            return n * factorialDouble(n - 1)  
    }  
      
    // BigInteger Factorial   
    def static BigInteger factorialBigInteger(int n) {    
        if (n == 1)    
            return 1BI  
        else    
            return BigInteger::valueOf(n) * factorialBigInteger(n - 1)  
    }  
}

And the Output is:

Xtend - Basics by Example

2012-05-06T12:27:00.001-07:00

Extending my Basics by Example series to a new language. today's version of the post written in Xtend.

You can copy and paste the code below in your favorite IDE/Editor and start playing and learning with it. This little "working" program will teach you the basics of the Programming Language.

There are some "comments" on the code added just to tell you what are or how are some features called. In case you want to review the theory, you can read my previous post, where I give a definition of each of the concepts mentioned on the code. You can find it here: http://carlosqt.blogspot.com/2010/08/new-series-languages-basics-by-example.html

Greetings Program - Verbose

// Xtend Basics
package com.series
import java.util.Calendar
import java.util.GregorianCalendar

public class Greet {
    // Fields or Attributes
    private String message  
    private String name
    private int loopMessage 
    // Getters and Setters. 
    // M7 will introduce annotation @Property to auto generate them (if not present)
    def public String getMessage() {  
        return this.message
    }  
    def public void setMessage(String value) {  
        this.message = this.capitalize(value)  
    }  
    def public String getName() {  
        return this.name
    }  
    def public void setName(String value) {  
        this.name = this.capitalize(value)  
    }  
    def public int getLoopMessage() {  
        return this.loopMessage  
    }  
    def public void setLoopMessage(int value) {  
        this.loopMessage = value  
    }  
    // Constructor  
    public new() {
        this.message = ""  
        this.name = ""
        this.loopMessage = 0           
    }
    // Overloaded Constructor  
    public new(String message, String name, int loopMessage) {  
        this.message = this.capitalize(message)  
        this.name = this.capitalize(name)  
        this.loopMessage = loopMessage  
    }    
    // Method 1  
    def private String capitalize(String value) {  
        // "if-then-else" statement  
        if (value.length() >= 1) {  
            return value.toFirstUpper()  
        }  
        else  {  
            return ""  
        }  
    }  
    // Method 2  
    def public void Salute() {  
        // "for (each)" statement
        for (int i : 0..this.loopMessage) {  
            println(this.message + " " + this.name + "!")  
        }  
    }  
    // Overloaded Method 2.1  
    def public void Salute(String message, String name, int loopMessage) {  
        // "while" statement  
        var int i = 0  
        while(i < loopMessage) {  
            println(this.capitalize(message) + " " + this.capitalize(name) + "!")
            i = i + 1
        }  
    }      
    // Overloaded Method 2.2  
    def public void Salute(String name) {  
        // "switch/case" statement  
        // doesn't work with iterables (i.e: case 6..11: ...)
        // doesn't allow multiple expressions in one case (i.e: case i>=6 && i<=11: ...)
        // doesn't allow fall through (i.e: case 6: case 7: case N: ...)
        // so better to use if-else-if expression instead
        var GregorianCalendar dtNow = new GregorianCalendar()        
        val int hh = dtNow.get(Calendar::HOUR_OF_DAY) 
        if (hh >= 6 && hh <= 11) this.message = "good morning,"        
        else if (hh >= 12 && hh <= 17) this.message = "good afternoon,"
        else if (hh >= 18 && hh <= 22) this.message = "good evening,"            
        else if (hh == 23 || (hh >= 0 && hh <= 5)) this.message = "good night,"
        else this.message = "huh?"        
        println(this.capitalize(this.message) + " " + this.capitalize(name) + "!")  
    }  
}

package com.series
import java.util.Scanner  
import java.lang.System 
// Greet Program
public class Program { 
    def public static void main(String[] args) {
        // Define variable object of type Greet and Instantiate. Call Constructor  
        val Greet g = new Greet()           
        // Call Setters  
        g.setMessage("hello")  
        g.setName("world")  
        g.setLoopMessage(5)  
        // Call Method 2  
        g.Salute()
        // Overloaded Method 2.1 and Getters  
        g.Salute(g.getMessage(), "xtend", g.getLoopMessage())  
        // Overloaded Method 2.2  
        g.Salute("carlos")
        
        // Stop and exit  
        println("Press any key to exit...")        
        val Scanner in = new Scanner(System::in)  
        val String line = in.nextLine()  
        in.close()                 
    }    
}

Greetings Program - Minimal

// Xtend Basics
import java.util.Calendar
import java.util.GregorianCalendar

class Greet {
    // Fields or Attributes
    private String message  
    private String name
    private int loopMessage    
    // Getters and Setters. 
    // M7 will introduce annotation @Property to auto generate them (if not present)    
    def getMessage() {  
        message
    }  
    def setMessage(String value) {  
        message = capitalize(value)  
    }  
    def getName() {  
        name
    }  
    def setName(String value) {  
        name = capitalize(value)  
    }  
    def getLoopMessage() {  
        loopMessage  
    }  
    def setLoopMessage(int value) {  
        loopMessage = value  
    }  
    // Constructor  
    new() {
        message = ""  
        name = ""
        loopMessage = 0           
    }
    // Overloaded Constructor  
    new(String message, String name, int loopMessage) {  
        this.message = capitalize(message)  
        this.name = capitalize(name)  
        this.loopMessage = loopMessage  
    }    
    // Method 1  
    def private String capitalize(String value) {  
        // "if-then-else" statement  
        if (value.length >= 1)  
            value.toFirstUpper  
        else    
            ""  
    }  
    // Method 2  
    def Salute() {  
        // "for (each)" statement
        for (i : 0..loopMessage) {  
            println(message + " " + name + "!")  
        }  
    }  
    // Overloaded Method 2.1  
    def Salute(String message, String name, int loopMessage) {  
        // "while" statement  
        var i = 0  
        while(i < loopMessage) {  
            println(capitalize(message) + " " + capitalize(name) + "!")
            i = i + 1
        }  
    }      
    // Overloaded Method 2.2  
    def Salute(String name) {  
        // "switch/case" statement  
        // doesn't work with iterables (i.e: case 6..11: ...)
        // doesn't allow multiple expressions in one case (i.e: case i>=6 && i<=11: ...)
        // doesn't allow fall through (i.e: case 6: case 7: case N: ...)
        // so better to use if-else-if expression instead
        var dtNow = new GregorianCalendar        
        val hh = dtNow.get(Calendar::HOUR_OF_DAY) 
        if (hh >= 6 && hh <= 11) message = "good morning,"        
        else if (hh >= 12 && hh <= 17) message = "good afternoon,"
        else if (hh >= 18 && hh <= 22) message = "good evening,"            
        else if (hh == 23 || (hh >= 0 && hh <= 5)) message = "good night,"
        else message = "huh?"        
        println(capitalize(message) + " " + capitalize(name) + "!")  
    }  
}

import java.util.Scanner  
// Greet Program
class Program { 
    def static main(String[] args) {
        // Define variable object of type Greet and Instantiate. Call Constructor  
        val g = new Greet           
        // Call Setters  
        g.setMessage("hello")  
        g.setName("world")  
        g.setLoopMessage(5)  
        // Call Method 2  
        g.Salute
        // Overloaded Method 2.1 and Getters  
        g.Salute(g.getMessage, "xtend", g.getLoopMessage)  
        // Overloaded Method 2.2  
        g.Salute("carlos")
        
        // Stop and exit  
        println("Press any key to exit...")        
        val in = new Scanner(System::in)  
        val line = in.nextLine  
        in.close
    }    
}

And the Output is:

Auto-Implemented Properties in Xtend

Auto-implemented properties enable you to quickly specify a property of a class without having to write code to Get and Set the field. In Xtend you will use the @Property annotation which will generate a Java-Bean-style getter and setter (if the field is not final) for an annotated field and only generated when not explicitly defined.

// Xtend Basics  
class AutoImplementedProperties {  
    // Fields + Auto-Implemented Properties  
    @Property String message  
    @Property String name  
    @Property int loopMessage  
    // Methods  
    def salute() {    
        println('''«message.toFirstUpper» «name.toFirstUpper» «loopMessage»!''')
    }  
}

class Program { 
    def static void main(String[] args) {
        var g = new AutoImplementedProperties => [ 
            // Call Set Property  
            message = "hello"         
            name = "world"
            loopMessage = 5        
        ]
        // print them out  
        g.salute
        // and print them again using Get Properties  
        println('''«g.message» «g.name» «g.loopMessage»!''')
    }    
}

And the output is:

OO Hello World - Xtend

2012-04-22T14:41:00.000-07:00

The OO Hello World in Xtend, the "the CoffeScript for the JVM", is here!

Xtend is a statically-typed programming language which is tightly integrated with and
runs on the Java Virtual Machine.

You can see the OO Hello World series post here: http://carlosqt.blogspot.com/2010/06/oo-hello-world.html where I give some details on why these "oo hello world series" samples.

Version 1 (Minimal):

The minimum you need to type to get your program compiled and running.

class Greet {
 String name
 new(String name) {
  this.name = name.toFirstUpper
 }
 def salute() {
  println("Hello " + name + "!")
 }
}

// Greet Program
class Program {
 def static void main(String[] args) {
  val g = new Greet("world")  
  g.salute
 } 
}

Version 2 (Verbose):

Explicitly adding instructions and keywords that are optional to the compiler.

package com.series

public class Greet {
 private String name
 public new(String name) {
  this.name = name.toFirstUpper()
 }
 def public void salute() {
  println("Hello " + this.name + "!")
 }
}

package com.series

// Greet Program
public class Program { 
 def public static void main(String[] args) {
  val g = new Greet("world")  
  g.salute()
 } 
}

The Program Output:

Xtend Info:

"Xtend is a statically-typed programming language developed at Eclipse.org. It
has a strong focus on leveraging all the good parts of Java, including seamless
integration with the huge amount of Java frameworks and libraries out there.” Taken from: ( Pragmatic Magazine - Issue 30, December 2011 )

Appeared:	2011
Current Version:	2.3 (latest version in "Languages" page)
Developed by:	Eclipse
Creator:	Sven Efftinge, Sebastian Zarnekow
Influenced by:	Java (James Gosling)
Predecessor Language	N/A
Predecessor Appeared	N/A
Predecessor Creator	N/A
Runtime Target:	JVM
Latest Framework Target:	JDK 6,7
Mono Target:	No
Allows Unmanaged Code:	No
Source Code Extension:	“.xtend”
Keywords:	41
Case Sensitive:	Yes
Free Version Available:	Yes
Open Source:	Yes
Standard:	N/A
Latest IDE Support:	Eclipse http://www.eclipse.org/xtend/download.html http://download.eclipse.org/modeling/tmf/xtext/updates/composite/milestones/
Language Reference:	http://www.eclipse.org/xtend/documentation/Xtend%20User%20Guide.pdf
Extra Info:	http://eclipse.org/projects/project.php?id=tools.xtend http://en.wikipedia.org/wiki/Xtend_(programming_language)

Factorial and Fibonacci in Kotlin

2012-04-18T07:05:00.000-07:00

Here below a little program in Kotlin that implements 2 classes (+ an extra utility Stopwatch class from my previous post http://carlosqt.blogspot.com/2011/05/stopwatch-class-for-java.html). There is the main class, called Fiborial (Fibo(nnacci)+(Facto)rial) that implements the Fibonacci and the Factorial algorithms in two ways, one Recursive (using recursion) and the other Imperative (using loops and states). The second class is just an instance class that does the same thing, but its there just to show the difference between static and instance classes, and finally the third one is the main function which has the execution entry point.

You can also find 3 more little examples at the bottom. One prints out the Factorial's Series and Fibonacci's Series, the second one just shows a class that mixes both: static and instance members (or 2 separate classes in the case of Kotlin since it does not supports staitc methods in a class), and finally the third one that uses different return types (including java.math.BigInteger) for the Factorial method to compare the timing and result.

As with the previous posts, you can copy and paste the code below in your favorite IDE/Editor and start playing and learning with it. This little "working" program will teach you some more basics of the Programming Language.

There are some "comments" on the code added just to tell you what are or how are some features called. In case you want to review the theory, you can read my previous post, where I give a definition of each of the concepts mentioned on the code. You can find it here: http://carlosqt.blogspot.com/2011/01/new-series-factorial-and-fibonacci.html

The Fiborial Program

// Factorial and Fibonacci in Kotlin
package com.series

import java.math.BigInteger
import com.series.Stopwatch

// Instance (Singleton) Class that works as a Module/Utils class
// static is not a class modifier in Kotlin
object StaticFiborial {
    // 'Static' Field
    private var className : String = "'Static' Constructor"
    // no available static __constructor support
    // Static Initializer Method instead, but need to be explicitly invoked
    fun constructor() {
        className = "'Static' Constructor";
        println(className)
    }
    // 'Static' Method - Factorial Recursive
    fun factorialR(n : Int) : BigInteger? {
        if (n == 1)
            return BigInteger.ONE
        else
            return BigInteger.valueOf(n.toLong())?.multiply(factorialR(n - 1))
    }
    // 'Static' Method - Factorial Imperative
    fun factorialI(var n : Int) : BigInteger? {
        var res: BigInteger? = BigInteger.ONE
        while (n > 1) {
            res = res?.multiply(BigInteger.valueOf(n.toLong()))
            n -= 1
        }
        return res
    }
    // 'Static' Method - Fibonacci Recursive
    fun fibonacciR(n : Int) : Long {
        if (n < 2)
            return 1
        else
            return fibonacciR(n - 1) + fibonacciR(n - 2)
    }
    // 'Static' Method - Fibonacci Imperative
    fun fibonacciI(n : Int) : Long {
        var pre : Long = 1
        var cur : Long = 1
        var tmp : Long
        for (i in 2..n) {
            tmp = cur + pre
            pre = cur
            cur = tmp
        }
        return cur
    }
    // 'Static' Method - Benchmarking Algorithms
    fun benchmarkAlgorithm(algorithm : Int, values : Array<Int>) {
        val timer : Stopwatch = Stopwatch()
        var testValue : Int
        var i : Int = 1
        var facTimeResult : BigInteger? = BigInteger.ZERO
        var fibTimeResult : Long

        when (algorithm) {
            1 -> {
                println("\nFactorial Imperative:");
                // "For" Loop Statement
                for (j in 1..values.size - 1) {
                    testValue = values[j]
                    // Taking Time
                    timer.start()
                    facTimeResult = factorialI(testValue)
                    timer.stop()
                    // Getting Time
                    println(" (${testValue}) = ${timer.getElapsed()}")
                }
            }
            2 -> {
                println("\nFactorial Recursive:")
                // "While" Loop Statement
                while (i < values.size) {
                    testValue = values[i]
                    // Taking Time
                    timer.start()
                    facTimeResult = factorialR(testValue)
                    timer.stop()
                    // Getting Time
                    println(" (${testValue}) = ${timer.getElapsed()}")
                    i += 1
                }
            }
            3 -> {
                println("\nFibonacci Imperative:")
                // "Do-While" Loop Statement
                do {
                    testValue = values[i]
                    // Taking Time
                    timer.start()
                    fibTimeResult = fibonacciI(testValue)
                    timer.stop()
                    // Getting Time
                    println(" (${testValue}) = ${timer.getElapsed()}")
                    i++
                } while (i < values.size)
            }
            4 -> {
                println("\nFibonacci Recursive:")
                // "For Each" Loop Statement
                for (j in values) {
                    testValue = j
                    // Taking Time
                    timer.start()
                    fibTimeResult = fibonacciR(testValue)
                    timer.stop()
                    // Getting Time
                    println(" (${testValue}) = ${timer.getElapsed()}")
                }
            }
            else -> println("DONG!")
        }
    }
}

// Instance Class
// Instance Field
class InstanceFiborial(private var className : String) {
    // Instance Constructor
    this() : this("Instance Constructor") {
        println(this.className)
    }
    // Instance Method - Factorial Recursive
    fun factorialR(n : Int) : BigInteger? {
        // Calling Static Method
        return StaticFiborial.factorialR(n)
    }
    // Instance Method - Factorial Imperative
    fun factorialI(n : Int) : BigInteger? {
        // Calling Static Method
        return StaticFiborial.factorialI(n)
    }
    // Instance Method - Fibonacci Recursive
    fun fibonacciR(n : Int) : Long {
        // Calling Static Method
        return StaticFiborial.fibonacciR(n)
    }
    // Instance Method - Fibonacci Imperative
    fun fibonacciI(n : Int) : Long {
        // Calling Static Method
        return StaticFiborial.fibonacciI(n)
    }
}

fun main(args: Array<String>) {
    println("\n'Static' Class");
    // Calling 'Static' Class and Methods
    // No instantiation needed. Calling method directly from the class
    StaticFiborial.constructor()
    println("FacImp(5) = ${StaticFiborial.factorialI(5)}")
    println("FacRec(5) = ${StaticFiborial.factorialR(5)}")
    println("FibImp(11)= ${StaticFiborial.fibonacciI(11)}")
    println("FibRec(11)= ${StaticFiborial.fibonacciR(11)}")

    println("\nInstance Class");
    // Calling Instance Class and Methods
    // Need to instantiate before using. Call method from instantiated object
    val ff = InstanceFiborial()
    println("FacImp(5) = ${ff.factorialI(5)}")
    println("FacRec(5) = ${ff.factorialR(5)}")
    println("FibImp(11)= ${ff.fibonacciI(11)}")
    println("FibRec(11)= ${ff.fibonacciR(11)}")

    // Create a (generic) list of integer values to test
    // From 5 to 50 by 5
    val values = Array<Int>(11, {i -> i * 5})

    // Benchmarking Fibonacci
    // 1 = Factorial Imperative
    StaticFiborial.benchmarkAlgorithm(1, values)
    // 2 = Factorial Recursive
    StaticFiborial.benchmarkAlgorithm(2, values)

    // Benchmarking Factorial
    // 3 = Fibonacci Imperative
    StaticFiborial.benchmarkAlgorithm(3, values)
    // 4 = Fibonacci Recursive
    StaticFiborial.benchmarkAlgorithm(4, values)

    // Stop and exit
    println("Press any key to exit...")
    //val ins: Scanner = Scanner(System.in)
    //var line: String? = ins.nextLine()
    //ins.close()
}

And the Output is:

Printing the Factorial and Fibonacci Series

package com.series

import java.math.BigInteger
import java.lang.StringBuffer

object Fiborial {
    // Using a StringBuffer as a list of string elements
    fun getFactorialSeries(n : Int) : String? {
        val series = StringBuffer()
        // We begin by concatenating the number you want to calculate
        // in the following format: "!# ="
        series.append("!")
        series.append(n)
        series.append(" = ")
        // We iterate backwards through the elements of the series
        // Reversed ranges are not supported... using while instead
        //for (i in n..0) {
        var i : Int = n
        while (i > 0) {
            // and append it to the list
            series.append(i)
            if (i > 1)
                series.append(" * ")
            else
                series.append(" = ")
            i--
        }
        // Get the result from the Factorial Method
        // and append it to the end of the list
        series.append(factorial(n))
        return series.toString()
    }

    // Using a StringBuffer as a list of string elements
    fun getFibonnaciSeries(n : Int) : String? {
        // Create the String that will hold the list
        val series = StringBuffer()
        // We begin by concatenating the first 3 values which
        // are always constant
        series.append("0, 1, 1")
        // Then we calculate the Fibonacci of each element
        // and add append it to the list
        for (i in 2..n) {
            if (i < n)
                series.append(", ")
            else
                series.append(" = ")
            series.append(fibonacci(i))
        }
        // return the list as a string
        return series.toString()
    }

    fun factorial(n : Int) : BigInteger? {
        if (n == 1)
            return BigInteger.ONE
        else
            return BigInteger.valueOf(n.toLong())?.multiply(factorial(n - 1))
    }

    fun fibonacci(n : Int) : Long {
        if (n < 2)
            return 1
        else
            return fibonacci(n - 1) + fibonacci(n - 2)
    }
}

fun main(args : Array<String>) {
    // Printing Factorial Series
    println("")
    println(Fiborial.getFactorialSeries(5))
    println(Fiborial.getFactorialSeries(7))
    println(Fiborial.getFactorialSeries(9))
    println(Fiborial.getFactorialSeries(11))
    println(Fiborial.getFactorialSeries(40))
    // Printing Fibonacci Series
    println("")
    println(Fiborial.getFibonnaciSeries(5))
    println(Fiborial.getFibonnaciSeries(7))
    println(Fiborial.getFibonnaciSeries(9))
    println(Fiborial.getFibonnaciSeries(11))
    println(Fiborial.getFibonnaciSeries(40))
}

And the Output is:

Mixing Instance and Static Members in the same Class

Normally, instance classes can contain both, instance and static members such as: fields, getters, constructors/initializers, methods, etc. However, In Kotlin, unlike Java, classes do not have static methods, so it doesn't support mixing both of them on the same object or class. In the following code I had to create one Object and one Class to build this example.

package com.series

// 'Static' Class
object StaticFiborial {
    // 'Static' Field/Property
    private var _staticCount : Int = 0
    // 'Static' Read-Only Property
    public val StaticCount : Int
        get() {
            return _staticCount
        }
    // 'Static' Constructor
    //this() : this() {
    // No constructor support for Objects - failed to get descriptor for secondary constructor
    // using an explicit initializer method instead
    fun constructor() {
        println("\nStatic Constructor ${_staticCount}")
    }
    // 'Static' Method
    fun fibonacci(n : Int) {
        _staticCount += 1
        println("\nFibonacci(${n})")
    }
}

// Instance Class
// Instance Field/Property
class InstanceFiborial(private var _instanceCount : Int) {
    // Instance Read-Only Property
    public val InstanceCount : Int
        get() {
            return this._instanceCount
        }
    // Instance Constructor
    this() : this(0) {
        println("\nInstance Constructor ${this._instanceCount}")
    }
    // Instance Method
    fun factorial(n : Int) {
        this._instanceCount += 1
        println("\nFactorial(${n})")
    }
}

fun main(args : Array<String>) {
    // Calling Static Constructor and Methods
    // No need to instantiate
    StaticFiborial.constructor()
    StaticFiborial.fibonacci(5)

    // Calling Instance Constructor and Methods
    // Instance required
    val fib = InstanceFiborial()
    fib.factorial(5)

    StaticFiborial.fibonacci(15)
    fib.factorial(5)

    // Calling Instance Constructor and Methods
    // for a second object
    val fib2 = InstanceFiborial()
    fib2.factorial(5)

    println("")
    // Calling Static Property
    println("Static Count = ${StaticFiborial.StaticCount}")
    // Calling Instance Property of object 1 and 2
    println("Instance 1 Count = ${fib.InstanceCount}")
    println("Instance 2 Count = ${fib2.InstanceCount}")
}

And the Output is:

Factorial using java.lang.Long, java.lang.Double, java.math.BigInteger

package com.series

import java.math.BigInteger
import com.series.Stopwatch

// Long Factorial
fun factorialInt64(n : Int) : Long {
    if (n == 1)
        return 1
    else
        return n * factorialInt64(n - 1)
}

// Double Factorial
fun factorialDouble(n : Int) : Double {
    if (n == 1)
        return 1.0
    else
        return n * factorialDouble(n - 1)
}

// BigInteger Factorial
fun factorialBigInteger(n : Int) : BigInteger? {
    if (n == 1)
        return BigInteger.ONE
    else
        return BigInteger.valueOf(n.toLong())?.multiply(factorialBigInteger(n - 1))
}

fun main(args: Array<String>) {
    val timer = Stopwatch()
    var facIntResult : Long = 0
    var facDblResult : Double = 0.0
    var facBigResult = BigInteger.ZERO

    println("\nFactorial using Int64")
    // Benchmark Factorial using Int64
    var i = 5
    while (i < 55) {
        timer.start()
        facIntResult = factorialInt64(i)
        timer.stop()
        println(" (${i}) = ${timer.getElapsed()} : ${facIntResult}")
        i += 5
    }
    println("\nFactorial using Double")
    // Benchmark Factorial using Double
    i = 5
    while (i < 55) {
        timer.start()
        facDblResult = factorialDouble(i)
        timer.stop()
        println(" (${i}) = ${timer.getElapsed()} : ${facDblResult}")
        i += 5
    }
    println("\nFactorial using BigInteger")
    // Benchmark Factorial using BigInteger
    i = 5
    while (i < 55) {
        timer.start()
        facBigResult = factorialBigInteger(i)
        timer.stop()
        println(" (${i}) = ${timer.getElapsed()} : ${facBigResult}")
        i += 5
    }
}

And the Output is:

Kotlin - Basics by Example

2012-04-14T11:04:00.001-07:00

Extending my Basics by Example series to a new language :D. today's version of the post written in Kotlin.

You can copy and paste the code below in your favorite IDE/Editor and start playing and learning with it. This little "working" program will teach you the basics of the Programming Language.

There are some "comments" on the code added just to tell you what are or how are some features called. In case you want to review the theory, you can read my previous post, where I give a definition of each of the concepts mentioned on the code. You can find it here: http://carlosqt.blogspot.com/2010/08/new-series-languages-basics-by-example.html

Greetings Program - Verbose

// Kotlin Basics
package com.series.basics

import java.util.Calendar
import java.util.GregorianCalendar
import java.util.Scanner
import java.lang.System

// (Main) Constructor
public class Greet() {
    // Fields or Attributes are Properties
    private var _message: String = ""
    private var _name: String = ""
    private var _loopMessage: Int = 0
    // Properties
    public var Message : String
        get() {
            return this._message
        }
        set(value) {
            this._message = this.Capitalize(value)
        }
    public var Name : String
        get() {
            return this._name
        }
        set(value) {
            this._name = this.Capitalize(value)
        }
    public var LoopMessage : Int
        get() {
            return this._loopMessage
        }
        set(value) {
            this._loopMessage = value
        }
    // Overloaded/Secondary Constructor
    public this(val message: String, val name: String, val loopMessage: Int) : this() {
        this._message = message
        this._name = name
        this._loopMessage = loopMessage
    }
    // Method 1
    private fun Capitalize(val value: String) : String {
        // "if-then-else" statement
        if (value.length > 0)
            return value[0].toString().toUpperCase() + value.substring(1,value.length)
        else
            return ""
    }
    // Method 2
    public fun Salute() {
        // "for" statement
        for(i in 1..this._loopMessage) {
            println("${this._message} ${this._name}!")
        }
    }
    // Overloaded Method
    // No Overloaded Methods Support. New methods instead.
    // Method 2.1
    public fun Salute21(val message: String, val name: String, val loopMessage: Int) {
        // "while" statement
        var i: Int = 1
        while (i <= loopMessage) {
            println("${this.Capitalize(message)} ${this.Capitalize(name)}!")
            i++
        }
    }
    // Overloaded Method
    // No Overloaded Methods Support. New methods instead.
    // Method 2.2
    public fun Salute22(val name: String) {
        // "switch/case" statement is not supported
        // using match statement instead
        val dtNow: Calendar? = Calendar.getInstance()
        val t: Int? = dtNow?.get(Calendar.HOUR_OF_DAY)
        when (t) {
            6,7,8,9,10,11 -> this._message = "good morning,"
            12,13,14,15,16,17 -> this._message = "good afternoon,"
            18,19,20,21,22 -> this._message = "good evening,"
            23,0,1,2,3,4,5 -> this._message = "good night,"
            else -> this._message = "huh?"
        }
        println("${this.Capitalize(this._message)} ${this.Capitalize(name)}!")
    }
}

// Console Program
public fun main(val args: Array<String>) {
    // Define object of type Greet and Instantiate Greet. Call Constructor
    val g:Greet = Greet()
    // Call Set Properties
    g.Message = "hello"
    g.Name = "world"
    g.LoopMessage = 5
    // Call Method 2
    g.Salute()
    // Call Overloaded Method 2.1 and Get Properties
    g.Salute21(g.Message, "kotlin", g.LoopMessage)
    // Call Overloaded Method 2.2
    g.Salute22("carlos")
    // Stop and exit
    println("Press any key to exit...")
    // following code not working due to 'System.in' being considered as 'in' language keyword
    // Error message: Expecting an element
    //val ins: Scanner = Scanner(System.in)
    //var line: String? = ins.nextLine()
    //ins.close()
}

Greetings Program - Minimal

// Kotlin Basics
import java.util.Calendar
import java.util.GregorianCalendar
import java.util.Scanner
import java.lang.System

// (Main) Constructor
class Greet() {
    // Fields or Attributes are Properties
    private var _message: String = ""
    private var _name: String = ""
    private var _loopMessage: Int = 0
    // Properties
    var Message : String
        get() {
            return _message
        }
        set(value) {
            _message = Capitalize(value)
        }
    var Name : String
        get() {
            return _name
        }
        set(value) {
            _name = Capitalize(value)
        }
    var LoopMessage : Int
        get() {
            return _loopMessage
        }
        set(value) {
            _loopMessage = value
        }
    // Overloaded/Secondary Constructor
    this(message: String, name: String, loopMessage: Int) : this() {
        _message = message
        _name = name
        _loopMessage = loopMessage
    }
    // Method 1
    private fun Capitalize(value: String) : String {
        // "if-then-else" statement
        if (value.length > 0)
            return value[0].toString().toUpperCase() + value.substring(1,value.length)
        else
            return ""
    }
    // Method 2
    fun Salute() {
        // "for" statement
        for(i in 1.._loopMessage) {
            println("${_message} ${_name}!")
        }
    }
    // Overloaded Method
    // No Overloaded Methods Support. New methods instead.
    // Method 2.1
    fun Salute21(message: String, name: String, loopMessage: Int) {
        // "while" statement
        var i = 1
        while (i <= loopMessage) {
            println("${Capitalize(message)} ${Capitalize(name)}!")
            i++
        }
    }
    // Overloaded Method
    // No Overloaded Methods Support. New methods instead.
    // Method 2.2
    fun Salute22(name: String) {
        // "switch/case" statement is not supported
        // using match statement instead
        val dtNow = Calendar.getInstance()
        val t = dtNow?.get(Calendar.HOUR_OF_DAY)
        when (t) {
            6,7,8,9,10,11 -> _message = "good morning,"
            12,13,14,15,16,17 -> _message = "good afternoon,"
            18,19,20,21,22 -> _message = "good evening,"
            23,0,1,2,3,4,5 -> _message = "good night,"
            else -> _message = "huh?"
        }
        println("${Capitalize(_message)} ${Capitalize(name)}!")
    }
}

// Console Program
fun main(args: Array<String>) {
    // Define object of type Greet and Instantiate Greet. Call Constructor
    val g = Greet()
    // Call Set Properties
    g.Message = "hello"
    g.Name = "world"
    g.LoopMessage = 5
    // Call Method 2
    g.Salute()
    // Call Overloaded Method 2.1 and Get Properties
    g.Salute21(g.Message, "kotlin", g.LoopMessage)
    // Call Overloaded Method 2.2
    g.Salute22("carlos")
    // Stop and exit
    println("Press any key to exit...")
    // following code not working due to 'System.in' being considered as 'in' keyword
    // Error message: Expecting an element
    //val ins: Scanner = Scanner(System.in)
    //var line: String? = ins.nextLine()
    //ins.close()
}

And the Output is:

Auto-Implemented Properties in Kotlin

Auto-implemented properties enable you to quickly specify a property of a class without having to write code to Get and Set the property. In Kotlin, there's no way to declare a field. All you have is properties. Read/write properties are declared with the var keyword, and read-only ones – with val keyword.

// Kotlin Basics
class AutoImplementedProperties() {
    // Fields or Attributes are Properties
    var Message: String = ""
    var Name: String = ""
    var LoopMessage: Int = 0
    // Methods
    fun Salute() {
        println("${Message} ${Name} ${LoopMessage}!")
    }
}

// parameters of main constructor become properties of the class
class MainConstructorProperties(var Message: String, var Name: String, var LoopMessage: Int) {
    // Methods
    fun Salute() {
        println("${Message} ${Name} ${LoopMessage}!")
    }
}
// if you want private properties for the ones sent to the main constructor
// use the private modifier before each var/val declaration
/*class PropertiesFromConstructorParams(private var Message: String
                                      , private var Name: String
                                      , private var LoopMessage: Int) {
    // pass
}
*/

fun main(args: Array<String>) {
    val g = AutoImplementedProperties()
    // Call Set Properties
    g.Message = "hello"
    g.Name = "world"
    g.LoopMessage = 5
    // print them out
    g.Salute()
    // and print them again using Get Properties
    println("${g.Message} ${g.Name} ${g.LoopMessage}!")

    println()

    val p = MainConstructorProperties("bye","carlos",1)
    p.Salute()
    // Call Set Properties
    p.Message = "hello"
    p.Name = "world"
    p.LoopMessage = 5
    // print them out
    p.Salute()
    // and print them again using Get Properties
    println("${p.Message} ${p.Name} ${p.LoopMessage}!")

}

And the output is:

OO Hello World - Kotlin

2012-02-25T15:09:00.001-08:00

The OO Hello World in Kotlin, the "the new language from JetBrains for the JVM", is here!

Project Kotlin is a codename for a statically typed programming language compiled to JVM byte code and JavaScript.

You can see the OO Hello World series post here: http://carlosqt.blogspot.com/2010/06/oo-hello-world.html where I give some details on why these "oo hello world series" samples.

Version 1 (Minimal):

The minimum you need to type to get your program compiled and running.

class Greet(name : String) {
  val name : String = name[0].toString().toUpperCase() + name.substring(1, name.length);
  fun salute() {
    println("Hello, ${name}!");
  }
}

// Greet the world!
fun main(args : Array<string>) {
  val g = Greet("carlos");
  g.salute();
}

Version 2 (Verbose):

Explicitly adding instructions and keywords that are optional to the compiler.

package greetprogram;

public class Greet(name : String) {
  private val name : String = name[0].toString().toUpperCase() + name.substring(1, name.length);
  public fun salute() {
    println("Hello, ${this.name}!");
  }
}

public fun main(args : Array<string>) {
  val g = Greet("carlos");
  g.salute();
}

The Program Output:

Kotlin Info:

""Project Kotlin" is the codename of a statically-typed JVM-targeted programming language developed by JetBrains intended for industrial use. This is an object-oriented language” Taken from: ( http://confluence.jetbrains.net/display/Kotlin/Welcome )

Appeared:	2011
Current Version:	0.1 (latest version in "Languages" page)
Developed by:	JetBrains
Creator:	Andrey Breslav
Influenced by:	Groovy (Guillaume Laforge), C# (Anders Hejlsberg) Java (James Gosling), Scala (Martin Odersky)
Predecessor Language	N/A
Predecessor Appeared	N/A
Predecessor Creator	N/A
Runtime Target:	JVM
Latest Framework Target:	JDK 6
Mono Target:	No
Allows Unmanaged Code:	No
Source Code Extension:	“.kt”
Keywords:	31
Case Sensitive:	Yes
Free Version Available:	Yes
Open Source:	Yes
Standard:	N/A
Latest IDE Support:	Intellij IDEA https://github.com/JetBrains/kotlin/downloads
Language Reference:	http://confluence.jetbrains.net/display/Kotlin/Docs+Home
Extra Info:	http://blog.jetbrains.com/kotlin/ http://kotlin-demo.jetbrains.com/

OO Hello World - Ceylon

2012-02-25T13:42:00.000-08:00

Update 1: Porting code examples to Ceylon M5 - syntax changes on assignent operator, module definition and support for String Interpolation.

The OO Hello World in Ceylon, the "the new language from Red Hat for the JVM", is here!

Ceylon is a general-purpose, imperative, statically-typed, block-structured, object-oriented, higher-order language featuring a syntax similar to Java and C#, and a type system based on the notion of principal types.

You can see the OO Hello World series post here: http://carlosqt.blogspot.com/2010/06/oo-hello-world.html where I give some details on why these "oo hello world series" samples.

Version 1 (Minimal):

The minimum you need to type to get your program compiled and running.

class Greet(String name) {   
    String _name = name[0..0].uppercased + name[1...];  
    shared void salute() {  
        print("Hello, ``_name``!");  
    }
} 
  
// Greet the world!  
void run() {  
    value g = Greet("carlos");  
    g.salute();  
}

Version 2 (Verbose):

Explicitly adding instructions and keywords that are optional to the compiler.

shared class Greet(String name) {   
    variable String _name = name[0..0].uppercased + name[1...];  
    shared void salute() {  
        print("Hello, ``this._name``!");  
    }  
}  
  
// Greet the world!  
shared void run() {  
    value g = Greet("carlos");  
    g.salute();  
}

The Program Output:

Ceylon Info:

“Ceylon is a programming language for writing large programs in a team environment. The language is elegant, highly readable, extremely typesafe, and makes it easy to get things done. And it's easy to learn for programmers who are familiar with mainstream languages used in business computing. Ceylon has a full-featured Eclipse-based development environment, allowing developers to take best advantage of the powerful static type system. Programs written in Ceylon execute on any JVM.” Taken from: (http://www.ceylon-lang.org/ )

Appeared:	2011
Current Version:	0.1 M1 (latest version in "Languages" page)
Developed by:	Red Hat
Creator:	Gavin King
Influenced by:	Java (James Gosling), C# (Anders Hejlsberg)
Predecessor Language	N/A
Predecessor Appeared	N/A
Predecessor Creator	N/A
Runtime Target:	JVM
Latest Framework Target:	JDK 6
Mono Target:	No
Allows Unmanaged Code:	No
Source Code Extension:	“.ceylon”
Keywords:	35
Case Sensitive:	Yes
Free Version Available:	Yes
Open Source:	Yes
Standard:	N/A
Latest IDE Support:	Eclipse http://www.eclipse.org/downloads/
Language Reference:	http://www.ceylon-lang.org/documentation/reference/
Extra Info:	http://en.wikipedia.org/wiki/Ceylon_Project http://www.ceylon-lang.org/documentation/

Proof of Concept - Zonnon and WPF

2012-02-22T15:23:00.001-08:00

Proof of Concept (POC) or a proof of principle is a realization of a certain method or idea(s) to demonstrate its feasibility, or a demonstration in principle, whose purpose is to verify that some concept or theory has the potential of being used. A proof-of-concept is usually small and may or may not be complete. (Wikipedia: Proof of Concept)
Concept is an idea formed from inference.
Inference is the act or process of deriving logical conclusions from premises known or assumed to be true.

Eh voilà! I'm going to proof that you can use WPF and the .NET Framework 4.0 with the latest release of the ETH Zonnon compiler (2010-08-07: Zonnon Compiler 1.2.8) which officially runs on and targets .NET Framework 2.0, and to do that, I will show you some basic .NET hacking that I learned from the Cobra Programming Language guys :)

Let's start with the software you will need (in case you want to try it yourself) to follow this tutorial, then which files you will be using to reference, compile, decompile, edit and recompile, and finally, I will show step by step and with screenshots how to build a basic WPF program using Zonnon.

Software Requirements

Specific Assemblies

MSIL Disassembler for .NET 4.0

Ildasm.exe - version 4.0.30319.1

MSIL Assembler for .NET 4.0

Ilasm.exe - version 4.0.30319.1
fusion.dll - version 4.0.30319.1

WPF 4.0 Assemblies

PresentationCore.dll - version 4.0.30319.1
PresentationFramework.dll - version 4.0.30319.1
WindowsBase.dll - version 4.0.30319.1
System.Xaml.dll - version 4.0.30319.1

ETH Zonnon compiler 1.2.8

zc.exe - Compiler Launcher Program
ETH.Zonnon.dll - Zonnon Compiler

Step #1: Installing ETH Zonnon Compiler 1.2.8

You can download from the link above. I installed in "C:\Zonnon" for ease of use (less typing).
After installation you should have the following files installed:

Step #2: Project Directory

Create a new folder that will hold our source code and needed assemblies. Again, for ease of use, I created it within the Zonnon installation directoy "C:\Zonnon\wpfznn\" and copy all the assemblies listed in section "Specific Assemblies" except for the Zonnon Compiler assemblies (zc.exe and ETH.Zonnon.dll) which are located in the Zonnon folder.

At the end you should have something like the following:

Step #3: Writing Code

Using your favorite Text Editor, create a new Zonnon source code file for our program "wpfpoc.znn" and save it in our working directory we just created. Now type (or copy/paste) the following Zonnon source code on the file and save again.

module Main;
import 
    System.Byte as Byte,
    System.IO.Path as Path,
    System.Reflection.Assembly as Assembly,
    System.Reflection.AssemblyName as AssemblyName,
    (* WPF imports *)
    System.Xaml,
    System.Windows.Application as Application,
    System.Windows.Window as Window,
    System.Windows.Media.Color as Color,
    System.Windows.Media.SolidColorBrush as SolidColorBrush,    
    System.Windows.Controls.Button as Button,
    System.Windows.Controls.Label as Label,    
    System.Windows.Controls.StackPanel as StackPanel,
    System.Windows.SizeToContent as SizeToContent,
    System.Windows.Thickness as Thickness,
    System.Windows.Media.Brushes as Brushes,
    System.Windows.Media.Effects.DropShadowEffect as DropShadowEffect;
var        
    win: Window;    
    app: Application;
    c: Color;
    scb: SolidColorBrush;
    btn: Button;
    stk: StackPanel;
    asm : Assembly;
    asmn: AssemblyName;
    
procedure {public} onClick(sender: object; args: System.EventArgs);
var lbl: Label;
    msg: string;
begin
    msg := "Welcome to Zonnon!";
    lbl := new Label();
    lbl.FontSize := real(36);
    lbl.Foreground := Brushes.White;
    lbl.Content := msg;    
    stk.Children.Add(lbl);
    win.Height := lbl.Height;
    writeln(msg);
end onClick;
    
begin
    asm := Assembly.GetExecutingAssembly();
    asmn := asm.GetName();

    writeln;    
    writeln("Running Assembly: ", asm.Location:2);
    writeln("Assembly Name: ", asmn.Name:2);
    writeln;    

    win := new Window();
    win.Width := real(400);
    win.Height := real(150);
    win.SizeToContent := SizeToContent.Height;
    win.Title := "Hello Zonnon";        
    
    c.A := Byte(255); c.R := Byte(100); c.G := Byte(150); c.B := Byte(200);
    scb := new SolidColorBrush(c);
    win.Background := scb;
    
    stk := new StackPanel();
    stk.Margin := new Thickness(real(15));
    win.Content := stk;    
    
    btn := new Button();
    btn.Content := "Push Me";
    btn.FontSize := real(24);
    btn.Effect := new DropShadowEffect();
    
    btn.add_Click(onClick);
    stk.Children.Add(btn);
    
    app := new Application();
    app.Run(win);    
    
    (* Stop and exit *)  
    writeln;
    writeln("Press any key to exit...");  
    readln();    
end Main.

The code is very straightforward and even if it is not commented you can easily understand it... ok ok let's do a quick summary: The program is an executable Zonnon Module program unit. We then import several namespaces and classes from the WPF assemblies and we declare some variables to be used in our main body. The program creates a Window and set its properties. Next, a StackPanel container control is added to the Window's content. We add a Button into the StackPanel we just created and add a Click Event to it. This event calls the onClick procedure that what it does is create a new Label and push it into the Stack (and printing it to the Console) for every click you do to the Button. Finally we create an instance of the Application and call its Run method toshow up our WPF window! Once you close the Window control will be return to the Console Application and wait for any key to be pressed to exit.

For those who read programming books... Alright, yes, this program is a mix of a C# WPF example I found in one of my WPF books and another one from IronPython in Action plus some other stuff of my own :) CODE REUSE FTW ;)

Ok, let the fun begin!

Step #4: Compilation Completed Successfully - First Problem

We are ready to compile our program for the first time.
Assuming you copied/pasted the code above, let's see what we get by compiling our code into an EXE file.

Open a Windows Cmd window and navigate to our working folder. Then let's use the Zonnon Compiler with the following command line arguments to get our executable assembly.

Assuming you are using the same path structure than me you can copy/pase the following line:

C:\zonnon\zc.exe wpfpoc.znn /entry:Main /ref:PresentationCore.dll /ref:PresentationFramework.dll /ref:System.Xaml.dll /ref:WindowsBase.dll

If you have no syntax error in your code you should see the following result:

SUCCESS! We did not get any compilation error. Lets run it...

BEEP!

OK... that makes sense... when the program runs and it arrives to line 53 ( win := new Window(); ) it throws a BadImageFormatException. This is because the PresentationCore.dll and PresentationFramework.dll (where the Window class resides) target a newer .NET Framework than the one our program was compiled against. To fix that, we will change it by manually doing it on the zc.exe file.

Step #5: Let the Hacking Begin - Disassemble the zc.exe Assembly

We are going to make use of the Microsoft IL Dissasembler to change the target .NET Framework of the Zonnon Compiler launcher program from .NET 2.0 to 4.0.

Copy/pase the following command line into your console:

ildasm.exe C:\Zonnon\zc.exe /out=C:\Zonnon\zc.il

The ildasm program will decompile and extract the zc.exe assembly and give us a file containing all its Intermediate Language in a file ".il"

Step #6: Let the Hacking Begin - Change the Target .NET Framework

Open the zc.il file with any Text Editor. and locate the following 2 sections

.assembly extern mscorlib
.assembly extern System

Each of those 2 assemblies have a .ver 2:0:0:0
Change it to: .ver 4:0:0:0 and save.

If you compare the original zc.il and the one after the edit you should get:

Step #7: Let the Hacking Begin - Assemble the zc.exe Assembly

Now that the target Framework is changed, lets use the Microsoft IL Asembler to regenerate the zc.exe from the edited zc.il file.

Copy/pase the following command line into your console:

ilasm.exe C:\Zonnon\zc.il /EXE /out=C:\Zonnon\zc.exe

You should get an Operation completed successfully:

Step #8: Compilation Completed Successfully - Second Problem

Run the compiler command line that we used in Step #4

C:\zonnon\zc.exe wpfpoc.znn /entry:Main /ref:PresentationCore.dll /ref:PresentationFramework.dll /ref:System.Xaml.dll /ref:WindowsBase.dll

You should get the same Compilation completed successfully message.

Run your program again.

BEEP!

The problem now is that the UI application needs to run in a single Thread.
In C# apps you can solve this using the [STAThread] attribute to the program main method (the entry point) which indicates that the COM threading model for an application is single-threaded apartment (STA). However, it looks like there is no .NET Attributes support on Zonnon (or at least not documented).

I then tried using the Thread object and set the SetApartmentState property to ApartmentState.STA, but I failed because I was not able to convert an activity to a System.Threading.ThreadStart delegate object so I can succesfully instantiate a Thread.

For more details on the those 2 last paragraphs please have a look at this link: Why is STAThread required?
"When the STAThreadAttribute is applied, it changes the apartment state of the current thread to be single threaded. "

Step #9: The System.STAThreadAttribute

At the end, I decided to fix it with a dirty hack (IL) again.
To fix this we will be using exaclty the same method we used before, but this time we will change the Main method of our program, but first, let's see how I knew what to change.

I created a C# program that used the [STAThread] attribute.

class Program
{
    // Methods
    [STAThread]
    private static void Main(string[] args)
    {
        //pass
    }
}

I decompiled it using Reflector to see the generated IL code:

OK, what we see here is that within the Main method, which is the entrypoint method of our assembly, an instance of System.STAThreadAttribute is created. That's all we need to know to fix the problem with our WPF program we need to create that instance ourselves. Don't we?

Step #10: Fixing our WPF Program

Copy/pase the following command line into your console:

ildasm.exe wpfpoc.exe /out=wpfpoc.il

The ildasm program will decompile and extract the wpfpoc.exe assembly and give us a file containing all its Intermediate Language in a file ".il"

Open it in any text editor and go to the main method.

Wait a second... it already has the System.STAThreadAttribute on it! What's wrong then?

The answer is the .param [0] line just above it. To make it work we need to either move the .custom instance line over the .param [0] or just comment/remove the .param [0] line and save.

I was intrigued by this .param [0] and search about it on the Expert .NET 2.0 IL Assembler Apress book and found the following:

<param_const_def> ::= <b>.param</b> [<sequence>] = <const_type> [ (<value>) ]

is the parameter’s sequence number. This number should not be 0, because
a 0 sequence number corresponds to the return type, and a “default return value” does not
make sense.

So needed or not needed to avoid any risk I opted to move the System.STAThreadAttribute line on top of .param [0] (maybe an IL expert can explain why this behaviour?)

The code ends up like the following:

We are ready to re-build our program.

Copy/pase the following command line into your console:

ilasm.exe wpfpoc.il /EXE /out=wpfpoc.exe

You should see a "Operation completed successfully" message.

Step #11: Running the WPF Program

Execute the wpfpoc.exe program from the command line.

Our WPF window will pop up.

Every time you click on the Push Me button it will push a new Label to the StackPanel and resize the Window. At the same time, it prints the same text to the Console.

Summary

There you go. We finally have a .NET Framework 4.0 WPF program developed using the Zonnon Programming Language. This was just a proof of concept experiment just for fun. I think Zonnon is a very interesting programming language and hope that the people behind it ( ETH Zurich ) keep the good work and bring us a ETH Zonnon Compiler 1.2.9 soon with built in support for WPF and targets the .NET Framework 4.0.

And by the way, this little trick is the same I used in my previous post Factorial and Fibonacci in Zonnon to make use of System.Numerics.dll which is .NET 4.0 compatible only.

Factorial and Fibonacci in Zonnon

2012-02-10T10:42:00.000-08:00

Here below a little program in Zonnon that implements 2 classes (in fact, they are 3). There is the main class, called Fiborial (Fibo(nnacci)+(Facto)rial) that implements the Fibonacci and the Factorial algorithms in two ways, one Recursive (using recursion) and the other Imperative (using loops and states). The second class is just an instance class that does the same thing, but its there just to show the difference between static and instance classes, and finally the third one (which will not appear in other languages) is the Program class which has the static execution method "Main".

You can also find 3 more little examples at the bottom. One prints out the Factorial's Series and Fibonacci's Series, the second one just shows a class that mixes both: static and instance members, and finally the third one that uses different return types (including System.Numerics.BigInteger) for the Factorial method to compare the timing and result.

As with the previous posts, you can copy and paste the code below in your favorite IDE/Editor and start playing and learning with it. This little "working" program will teach you some more basics of the Programming Language.

There are some "comments" on the code added just to tell you what are or how are some features called. In case you want to review the theory, you can read my previous post, where I give a definition of each of the concepts mentioned on the code. You can find it here: http://carlosqt.blogspot.com/2011/01/new-series-factorial-and-fibonacci.html

The Fiborial Program

(* Factorial and Fibonacci in Zonnon *)

(* Module (Static Class) *)
module StaticFiborial;
import 
  System.Numerics.BigInteger as BigInteger, 
  System.Diagnostics.Stopwatch as Stopwatch;
(* Static Field *)
var {private} className: string;

  (* Static Method - Factorial Recursive *)
  procedure {public} factorialR(n: integer): BigInteger;
  begin
  if n < 1 then
    return BigInteger.One;
  else
    return BigInteger(n) * BigInteger(factorialR(n - 1));
  end;   
  end factorialR;

  (* Static Method - Factorial Imperative *)
  procedure {public} factorialI(n: integer): BigInteger;
  var i: integer;
    res: BigInteger;
  begin 
    res := BigInteger.One;
    for i := n to 1 by -1 do 
      res := res * BigInteger(i);
    end;    
    return res;
  end factorialI;

  (* Static Method - Fibonacci Recursive *)
  procedure {public} fibonacciR(n: integer): integer{64};
  begin
    if n < 2 then
      return 1;
    else
      return fibonacciR(n - 1) + fibonacciR(n - 2);
    end;
  end fibonacciR;

  (* Static Method - Fibonacci Imperative *)
  procedure {public} fibonacciI(n: integer): integer{64};
  var i, pre, cur, tmp: integer{64};
  begin
    pre := 1;
    cur := 1;
    tmp := 0;
    for i := 2 to n do
      tmp := cur + pre;    
      pre := cur;    
      cur := tmp; 
    end; 
    return cur;
  end fibonacciI;  

  (* Static Method - Benchmarking Algorithms *)
  procedure {public} benchmarkAlgorithm(algorithm: integer; var values: array * of integer);
  var timer: Stopwatch;
    testValue: integer;
    facTimeResult: BigInteger;
    i, fibTimeResult: integer{64};
  begin
    timer := new Stopwatch(); 
    i := 0;   
    testValue := 0;   
    facTimeResult := BigInteger.Zero;
    fibTimeResult := 0;  
    (* "Switch" Flow Control Statement *)  
    case algorithm of    
    1:         
      writeln("Factorial Imperative:");
      (* "For" Loop Statement *)
      for i := 0 to len(values)-1 do
        testValue := values[i];
        (* Taking Time *)
        timer.Start;
        facTimeResult := factorialI(testValue);
        timer.Stop;
        (* Getting Time *)
        writeln(" (" + string(testValue) + ") = {" + string(timer.Elapsed) + "}");
      end;      
    | 2:
      writeln("Factorial Recursive:");
      (* "While" Loop Statement *)      
      while i < len(values) do
        testValue := values[i];
        (* Taking Time *)
        timer.Start;
        facTimeResult := factorialR(testValue);
        timer.Stop;
        (* Getting Time *)
        writeln(" (" + string(testValue) + ") = {" + string(timer.Elapsed) + "}");
        i := i + 1;
      end;
    | 3:  
      writeln("Fibonacci Imperative:");
      (* "Repeat" Loop Statement *)
      repeat
        testValue := values[i];
        (* Taking Time *)
        timer.Start;
        fibTimeResult := fibonacciI(testValue);
        timer.Stop;
        (* Getting Time *)
        writeln(" (" + string(testValue) + ") = {" + string(timer.Elapsed) + "}");
        i := i + 1;
        until i = len(values);
    | 4:  
      writeln("Fibonacci Recursive:");
      (* "Loop" Loop Statement *)
      loop
        testValue := values[i];
        (* Taking Time *)
        timer.Start;
        fibTimeResult := fibonacciR(testValue);
        timer.Stop;
        (* Getting Time *)
        writeln(" (" + string(testValue) + ") = {" + string(timer.Elapsed) + "}");
        i := i + 1;
        if i = len(values) then exit end;
        end;
    else
      (* This code will never be reached. 
      So, I'm "using" fibTimeResult & facTimeResult to avoid compile error:
      Zonnon Compiler, Version 1.2.8.0    
      The variable 'fibTimeResult' is assigned but its value is never used.
      The variable 'facTimeResult' is assigned but its value is never used.*)
      writeln(fibTimeResult);      
      writeln(string(facTimeResult)); (* BigInteger not implicitly converted*)
      writeln("DONG!");  
    end;
  end benchmarkAlgorithm;

  (* funny work around for static init code *)
  procedure {public} init;
  begin  
    (* pass *)
  end init;

(* Contructor | Initializer *)  
begin
  className := "Static Constructor";
  writeln(className);
end StaticFiborial.

(* Instance Class *)
object {ref, public} InstanceFiborial;
import System.Numerics.BigInteger as BigInteger,
  StaticFiborial;
(* Instance Field *)
var {private} className: string;

  (* Instance Method - Factorial Recursive *)
  procedure {public} factorialR(n: integer): BigInteger;
  begin
    (* Calling Static Method *)
    return StaticFiborial.factorialR(n);
  end factorialR;

  (* Instance Method - Factorial Imperative *)
  procedure {public} factorialI(n: integer): BigInteger;
  begin 
    (* Calling Static Method *)
    return StaticFiborial.factorialI(n);
  end factorialI;

  (* Instance Method - Fibonacci Recursive *)
  procedure {public} fibonacciR(n: integer): integer{64};
  begin
    (* Calling Static Method *)
    return StaticFiborial.fibonacciR(n);
  end fibonacciR;

  (* Instance Method - Fibonacci Imperative *)
  procedure {public} fibonacciI(n: integer): integer{64};
  begin
    return StaticFiborial.fibonacciI(n);
  end fibonacciI;
  
(* Instance Contructor | Initializer *)  
begin
  self.className := "Instance Constructor";
  writeln(self.className);
end InstanceFiborial.

(* Console Program *)
module Main;
import StaticFiborial, InstanceFiborial;
const N = 10;
type TestArray = array N of integer;
var i,j: integer;
  ff: InstanceFiborial; 
  values: TestArray;
begin
  writeln;
  writeln("Static Class");  
  (* Calling Static Class and Methods 
  No instantiation needed. Calling method directly from the class *)
  (* calling StaticFiborial.init to execute the static constructor code 
  otherwise the string that is being printed there will appear the first
  time a static method is called. In this case will appear like: 
  FacImp(5) =Static Constructor\n120 *)
  StaticFiborial.init;
  writeln("FacImp(5) =", string(StaticFiborial.factorialI(5)));
  writeln("FacRec(5) =", string(StaticFiborial.factorialR(5)));  
  writeln("FibImp(11)=", string(StaticFiborial.fibonacciI(11)));
  writeln("FibRec(11)=", string(StaticFiborial.fibonacciR(11)));  

  writeln;  
  writeln("Instance Class");
  (* Calling Instance Class and Methods         
  Need to instantiate before using. Calling method from instantiated object *)
  ff := new InstanceFiborial();
  writeln("FacImp(5) =", string(ff.factorialI(5)));
  writeln("FacRec(5) =", string(ff.factorialR(5)));  
  writeln("FibImp(11)=", string(ff.fibonacciI(11)));
  writeln("FibRec(11)=", string(ff.fibonacciR(11)));  
  writeln;

  (* Create a list of integer values to test    
  From 5 to 50 by 5 *)
  j := 0;
  (*for i := 5 to 50 by 5 do *)
  for i := 5 to 50 by 5 do
    values[j] := i;
    j := j + 1;
  end; 

  (* Benchmarking Fibonacci *)
  (* 1 = Factorial Imperative *)
  StaticFiborial.benchmarkAlgorithm(1, values);
  writeln;
  (* 2 = Factorial Recursive *)
  StaticFiborial.benchmarkAlgorithm(2, values);
  writeln;
        
  (* Benchmarking Factorial *)
  (* 3 = Fibonacci Imperative *)
  StaticFiborial.benchmarkAlgorithm(3, values);
  writeln;
  (* 4 = Fibonacci Recursive *)
  StaticFiborial.benchmarkAlgorithm(4, values);
  writeln;

  (* Stop and exit *)
  writeln("Press any key to exit...");
  readln();  
end Main.

And the Output is:

Printing the Factorial and Fibonacci Series

  
module Main;
import
  System.Numerics.BigInteger as BigInteger, 
  System.Text.StringBuilder as StringBuilder;

  (* Using a StringBuilder as a list of string elements *)
  procedure {public} GetFactorialSeries(n: integer): string;
  var i: integer;
    series: StringBuilder;
  begin
    (* Create the String that will hold the list *)
    series := new StringBuilder();
    (* We begin by concatenating the number you want to calculate *)
    (* in the following format: "!# =" *)
    series.Append("!");  
    series.Append(n);  
    series.Append(" = ");  
    (* We iterate backwards through the elements of the series *)
    for i := n to 1 by -1 do
      (* and append it to the list *)
      series.Append(i);  
      if i > 1 then
        series.Append(" * ");  
      else   
        series.Append(" = ");   
    end;
    end;  
    (* Get the result from the Factorial Method *)
    (* and append it to the end of the list *)
    series.Append(string(Factorial(n)));
    (* return the list as a string *)
    return string(series);
  end GetFactorialSeries;

  (* Using a StringBuilder as a list of string elements *)
  procedure {public} GetFibonnaciSeries(n: integer): string;
  var i: integer;
    series: StringBuilder;
  begin
    (* Create the String that will hold the list *)  
    series := new StringBuilder();
    (* We begin by concatenating the first 3 values which 
    are always constant *)   
    series.Append("0, 1, 1"); 
    (* Then we calculate the Fibonacci of each element  
    and add append it to the list *)
    for i := 2 to n do 
      if i < n then
        series.Append(", ");  
      else  
        series.Append(" = ");  
      end;
      series.Append(string(Fibonacci(i)));  
    end;
    (* return the list as a string *)
    return string(series);
  end GetFibonnaciSeries;
  
  procedure {private} Factorial(n: integer): BigInteger;
  begin
    if n < 1 then
      return BigInteger.One;
    else
      return BigInteger(n) * BigInteger(Factorial(n - 1));
    end;   
  end Factorial;
  
  procedure {private} Fibonacci(n: integer): integer{64};
  begin
    if n < 2 then
      return 1;
    else
      return Fibonacci(n - 1) + Fibonacci(n - 2);
    end;
  end Fibonacci;
    
begin
  writeln;
  (* Printing Factorial Series *)
  writeln();  
  writeln(GetFactorialSeries(5));  
  writeln(GetFactorialSeries(7));  
  writeln(GetFactorialSeries(9));  
  writeln(GetFactorialSeries(11));  
  writeln(GetFactorialSeries(40));  
  (* Printing Fibonacci Series *)
  writeln();  
  writeln(GetFibonnaciSeries(5));  
  writeln(GetFibonnaciSeries(7));  
  writeln(GetFibonnaciSeries(9));  
  writeln(GetFibonnaciSeries(11));  
  writeln(GetFibonnaciSeries(40));  
  
end Main.

And the Output is:

Mixing Instance and Static Members in the same Class

Normally, instance classes can contain both, instance and static members such as: fields, getters, constructors/initializers, methods, etc. However, Zonnon doesn't support mixing both of them on the Module or Object unit types.

In the following code I had to create one Module and one Object to workaround this limitation.

 
(* Module (Static Class) 
  You cannot declare a variable of type ModuleName 
  If you try to do that you get a: 
  "'ModuleName' does not denote a type as expected."
*) 
module StaticFiborial;
(* Static Field *)
var {private} staticCount: integer;
  
  (* Static Read-Only Getter 
  You cannot reference your class members with the "self" 
  reference pointer since static members are not instantiated. *)
  procedure {public} StaticCount(): integer;
  begin
    return staticCount;
  end StaticCount;  
  
  (* Static Method *)
  procedure {public} Fibonacci(n: integer);
  begin
    staticCount := staticCount + 1;
    writeln;
    writeln("Fibonacci(" + string(n) + ")");
  end Fibonacci;
  
(* Static Constructor | Initializer *)  
begin
  staticCount := 0; 
  writeln("Static Constructor", staticCount:2);
end StaticFiborial.

(* Object (Instance Class) 
  You cannot try to call a method of ObjectName without an instance.
  If you try to do that you get a:
  "Cannot access to a member of 'ObjectName' 
  because it is object but not an instance of object" *)
object {ref, public} InstanceFiborial;
(* Instance Field *)
var {private} instanceCount: integer;

  (* Instance Read-Only Getter
  Within instance members, you can always use    
  the "self" reference pointer to access your (instance) members. *) 
  procedure {public} InstanceCount(): integer;
  begin
    return self.instanceCount;
  end InstanceCount;

  (* Instance Method *)
  procedure {public} Factorial(n: integer);
  begin
    self.instanceCount := self.instanceCount + 1;
    writeln;
    writeln("Factorial(" + string(n) + ")");
  end Factorial;
  
(* Instance Contructor | Initializer *)  
begin
  self.instanceCount := 0; 
  writeln("Instance Constructor", self.instanceCount:2);
end InstanceFiborial.

module Main;
import StaticFiborial, InstanceFiborial;
var fib, fib2: InstanceFiborial;  
begin  
  writeln;
  (* Calling Static Constructor and Methods 
  No need to instantiate *)  
  StaticFiborial.Fibonacci(5);

  (* Calling Instance Constructor and Methods  
  instance required *)
  fib := new InstanceFiborial();
  fib.Factorial(5);

  StaticFiborial.Fibonacci(15);
  fib.Factorial(5);  

  (* Calling Instance Constructor and Methods  
  for a second object *)
  fib2 := new InstanceFiborial();  
  fib2.Factorial(5);  

  writeln;
  (* Calling Static Getter *)
  writeln("Static Count =", StaticFiborial.StaticCount:2);  
  (* Calling Instance Getter of object 1 and 2 *)
  writeln("Instance 1 Count =", fib.InstanceCount:2);  
  writeln("Instance 2 Count =", fib2.InstanceCount:2);  

end Main.

And the Output is:

Factorial using System.Int64/integer{64}, System.Double/real{64}, System.Numerics.BigInteger

The Factorial of numbers over 20 are massive!
For instance: !40 = 815915283247897734345611269596115894272000000000!
Because of this, the previous version of this program was giving the "wrong" result
!40 = -70609262346240000 when using "long" (System.Int64) type, but it was on my previous post in VB.NET that I realized about this faulty code, because instead of giving me a wrong value, VB.NET execution thrown an Overflow Exception when using the "Long" (System.Int64) type.

My first idea was to use ulong and ULong, but both failed for "big" numbers. I then used Double (double floating point) type and got no more exception/wrong result. The result of the factorial was now correct !40 = 1.1962222086548E+56, but still I wanted to show the Integer value of it, so I did some research and found that there is a new System::Numerics::BigInteger class in the .NET Framework 4.0. Adding the reference to the project and using this new class as the return type of the Factorial methods, I was able to get the result I was expecting.
!40 = 815915283247897734345611269596115894272000000000

What I also found was that using different types change the time the algorithm takes to finish:
System.Int64 < System.Double < System.Numerics.BigInteger
Almost by double!

To illustrate what I just tried to say, lets have a look at the following code and the output we get.

  
module Main;
import System.Numerics.BigInteger as BigInteger, 
  System.Diagnostics.Stopwatch as Stopwatch;
var 
  timer: Stopwatch;
  facIntResult: integer{64};
  facDblResult: real{64};
  facBigResult: BigInteger;
  i: integer;  
  
  (* Long Factorial *)
  procedure FactorialInt64(n: integer): integer{64}; 
  begin
    if n = 1 then
      return 1{64};
    else  
      return n * FactorialInt64(n - 1);  
    end;
  end FactorialInt64;

  (* Double Factorial *)
  procedure FactorialDouble(n: integer): real{64};
  begin
    if n = 1 then
      return 1.0{64};  
    else  
      return real(n) * FactorialDouble(n - 1);
    end;
  end FactorialDouble;
  
  (* BigInteger Factorial *)
  procedure FactorialBigInteger(n: integer): BigInteger;
  begin
    if n = 1 then
      return BigInteger.One;  
    else  
      return BigInteger(n) * BigInteger(FactorialBigInteger(n - 1));  
    end;
  end FactorialBigInteger;
  
begin
  timer := new Stopwatch();  
  facIntResult := 0{64};
  facDblResult := 0.0{64};  
  facBigResult := BigInteger.Zero;  
  
  writeln;
  writeln("Factorial using Int64");  
  (* Benchmark Factorial using Int64 *)
  (* Overflow Exception!!! *)
  do
    for i:= 5 to 50 by 5 do    
      timer.Start;
      facIntResult := FactorialInt64(i);
      timer.Stop;
      writeln(" (" + string(i) + ") = " + string(timer.Elapsed) + " : " 
     + string(facIntResult));
    end;  
  on exception do
    (* built-in function reason doesn't work:
 Compile Error: Entity 'reason' is not declared*)
    writeln("Oops!","OverflowException");
  on termination do
    writeln("Oops!","Exception Termination");
  end;

  writeln;
  writeln("Factorial using Double");  
  (* Benchmark Factorial using Double *)
  for i:= 5 to 50 by 5 do    
    timer.Start;
    facDblResult := FactorialDouble(i);
    timer.Stop;
    writeln(" (" + string(i) + ") = " + string(timer.Elapsed) + " : " 
   + string(facDblResult));
  end;
  
  writeln;
  writeln("Factorial using BigInteger");  
  (* Benchmark Factorial using BigInteger *)
  for i:= 5 to 50 by 5 do    
    timer.Start;
    facBigResult := FactorialBigInteger(i);
    timer.Stop;
    writeln(" (" + string(i) + ") = " + string(timer.Elapsed) + " : " 
   + string(facBigResult));
  end;
end Main.

And the Output is:

NOTE: you need to manually add a reference to the System.Numerics assembly to your project so you can add it to your code.

Factorial and Fibonacci in Fantom

2012-02-08T14:22:00.000-08:00

Here below a little program in Fantom that implements 2 classes (in fact, they are 3 + an extra utility Stopwatch class from my previous post http://carlosqt.blogspot.com/2011/05/stopwatch-class-for-java.html). There is the main class, called Fiborial (Fibo(nnacci)+(Facto)rial) that implements the Fibonacci and the Factorial algorithms in two ways, one Recursive (using recursion) and the other Imperative (using loops and states). The second class is just an instance class that does the same thing, but its there just to show the difference between static and instance classes, and finally the third one (which will not appear in other languages) is the Program class which has the static execution method "main".

You can also find 3 more little examples at the bottom. One prints out the Factorial's Series and Fibonacci's Series, the second one just shows a class that mixes both: static and instance members, and finally the third one that uses different return types (including java.math.BigInteger) for the Factorial method to compare the timing and result.

As with the previous posts, you can copy and paste the code below in your favorite IDE/Editor and start playing and learning with it. This little "working" program will teach you some more basics of the Programming Language.

There are some "comments" on the code added just to tell you what are or how are some features called. In case you want to review the theory, you can read my previous post, where I give a definition of each of the concepts mentioned on the code. You can find it here: http://carlosqt.blogspot.com/2011/01/new-series-factorial-and-fibonacci.html

The Fiborial Program

// Factorial and Fibonacci in Fantom

using [java] com.carlosqt.util::Stopwatch
using [java] java.math::BigInteger

// static is not a valid class modifier
// Instanced Class
class StaticFiborial 
{
  // (Constant) Static Field  - Static fields must be const - this ensures thread safety  
  private const static Str className
  // Class/Static Constructor/Initializer
  // It is permissible to have multiple static initializers; they run in order of declaration
  static 
  {      
    className = "Static Constructor"  
    echo(className)  
  }
  // Static Method - Factorial Recursive
  static BigInteger factorialR(Int n)      
  {      
    if (n == 1)      
      return BigInteger.ONE  
    else      
      return BigInteger.valueOf(n).multiply(factorialR(n - 1))  
  }
  // Static Method - Factorial Imperative      
  static BigInteger factorialI(Int n)      
  {      
    BigInteger res := BigInteger.ONE  
    for (i := n; i >= 1; i--)      
    {                      
      res = res.multiply(BigInteger.valueOf(i))  
    }      
    return res  
  }
  // Static Method - Fibonacci Recursive      
  static Int fibonacciR(Int n)      
  {      
    if (n < 2)      
      return 1  
    else      
      return fibonacciR(n - 1) + fibonacciR(n - 2)  
  }      
  // Static Method - Fibonacci Imperative      
  static Int fibonacciI(Int n)      
  {                  
    Int pre := 1  
    Int cur := 1  
    Int tmp := 0   
    for (i := 2; i <= n; i++)  
    {      
      tmp = cur + pre  
      pre = cur  
      cur = tmp  
    }      
    return cur    
  }          
  // Class/Static Method - Benchmarking Algorithms      
  static Void benchmarkAlgorithm(Int algorithm, List values)      
  {                  
    Stopwatch timer := Stopwatch()  
    Int testValue := 0 
    BigInteger facTimeResult := BigInteger.ZERO  
    Int fibTimeResult := 0
    // "Switch" Flow Control Statement
    switch (algorithm)    
    {    
      case 1:    
        echo("\nFactorial Imperative:")    
        // "For" Loop Statement    
        for (i := 0; i < values.size; i++)    
        {                            
          testValue = values.get(i)    
          // Taking Time    
          timer.start()    
          facTimeResult = factorialI(testValue)    
          timer.stop()
          // Getting Time    
          echo(" ($testValue) = ${timer.getElapsed()}")    
        }
      case 2:    
        echo("\nFactorial Recursive:")    
        // "While" Loop Statement
        Int i := 0
        while (i < values.size)    
        {                            
          testValue = values.get(i)   
          // Taking Time    
          timer.start()    
          facTimeResult = factorialR(testValue)
          timer.stop()
          // Getting Time    
          echo(" ($testValue) = ${timer.getElapsed()}")    
          i++
        }    
      case 3:    
        echo("\nFibonacci Imperative:")    
        // "While" Loop Statement
        Int i := 0
        while (i < values.size)    
        {
          testValue = values.get(i)    
          // Taking Time    
          timer.start()    
          fibTimeResult = fibonacciI(testValue)    
          timer.stop()    
          // Getting Time    
          echo(" ($testValue) = ${timer.getElapsed()}")    
          i++    
        }    
      case 4:    
        echo("\nFibonacci Recursive:")      
        // "For" Loop Statement    
        for (i := 0; i < values.size; i++)    
        {    
          testValue = values.get(i)
          // Taking Time    
          timer.start()    
          fibTimeResult = fibonacciR(testValue)   
          timer.stop()   
          // Getting Time    
          echo(" ($testValue) = ${timer.getElapsed()}")    
        }    
        default:    
          echo("DONG!")    
    }                    
  }
}


// Instance Class      
class InstanceFiborial      
{      
  // Instance Field      
  private Str className  
  // Instance Constructor      
  new make()      
  {      
      this.className = "Instance Constructor"  
      echo(this.className)  
  }      
  // Instance Method - Factorial Recursive      
  BigInteger factorialR(Int n)      
  {      
      // Calling Static Method      
      return StaticFiborial.factorialR(n)  
  }      
  // Instance Method - Factorial Imperative      
  BigInteger factorialI(Int n)
  {      
      // Calling Static Method      
      return StaticFiborial.factorialI(n)      
  }      
  // Instance Method - Fibonacci Recursive  
  Int fibonacciR(Int n)  
  {      
      // Calling Static Method      
      return StaticFiborial.fibonacciR(n)  
  }      
  // Instance Method - Factorial Imperative      
  Int fibonacciI(Int n)  
  {      
      // Calling Static Method      
      return StaticFiborial.fibonacciI(n)  
  }      
}    

// Console Program  
public class FiborialApp    
{    
  public static Void main()    
  {
    echo("\nStatic Class")      
    // Calling Static Class and Methods  
    // No instantiation needed. Calling method directly from the class      
    echo("FacImp(5) = ${StaticFiborial.factorialI(5)}")  
    echo("FacRec(5) = ${StaticFiborial.factorialR(5)}")     
    echo("FibImp(11)= ${StaticFiborial.fibonacciI(11)}")      
    echo("FibRec(11)= ${StaticFiborial.fibonacciR(11)}")  
      
    echo("\nInstance Class")      
    // Calling Instance Class and Methods       
    // Need to instantiate before using. Calling method from instantiated object      
    InstanceFiborial ff := InstanceFiborial.make()  
    echo("FacImp(5) = ${ff.factorialI(5)}")  
    echo("FacRec(5) = ${ff.factorialR(5)}")  
    echo("FibImp(11)= ${ff.fibonacciI(11)}")  
    echo("FibRec(11)= ${ff.fibonacciR(11)}")  
      
    // Create a list of integer values to test  
    // From 5 to 50 by 5      
    Int[] values := Int[,]  
    for(i := 5; i <= 50; i += 5)
        values.add(i)
            
    // Benchmarking Fibonacci                           
    // 1 = Factorial Imperative                  
    StaticFiborial.benchmarkAlgorithm(1, values)  
    // 2 = Factorial Recursive      
    StaticFiborial.benchmarkAlgorithm(2, values)  
      
    // Benchmarking Factorial                  
    // 3 = Fibonacci Imperative      
    StaticFiborial.benchmarkAlgorithm(3, values)  
    // 4 = Fibonacci Recursive      
    StaticFiborial.benchmarkAlgorithm(4, values) 
    
    // Stop and exit      
    echo("Press any key to exit...")  
    console := Env.cur  
    userInput := console.in.readLine  
  }
}

And the Output is:

Printing the Factorial and Fibonacci Series

using [java] java.math::BigInteger    
using [java] java.lang::StringBuffer  
    
class Fiborial
{    
  // Using a StringBuffer as a list of string elements
  // because of the following compile error: 
  // Ambiguous call append(sys::Str) FiborialSeries.fan ... Fantom Problem
  // I had to use StringBuffer.apend(s, 0, s.length) instead of just StringBuffer.apend(CharSequence s) 
  static Str getFactorialSeries(Int n)    
  {    
    // Create the String that will hold the list    
    StringBuffer series := StringBuffer()  
    // We begin by concatenating the number you want to calculate    
    // in the following format: "!# ="    
    series.append("!", 0, "!".size)  
    series.append(n.toStr, 0, n.toStr.size)  
    series.append(" = ", 0, 3)
    // We iterate backwards through the elements of the series    
    for (i := n; i <= n && i > 0; i--)   
    {
      // and append it to the list    
      series.append(i.toStr, 0, i.toStr.size)
      if (i > 1)  
        series.append(" * ", 0, 3)  
      else     
        series.append(" = ", 0, 3)
    }  
    // Get the result from the Factorial Method    
    // and append it to the end of the list
    Str fac := factorial(n).toStr
    series.append(fac, 0, fac.size)    
    // return the list as a string    
    return series.toStr  
  }    
  
  // Using a StringBuffer as a list of string elements    
  static Str getFibonnaciSeries(Int n)    
  {    
    // Create the String that will hold the list    
    StringBuffer series := StringBuffer()    
    // We begin by concatenating the first 3 values which    
    // are always constant    
    series.append("0, 1, 1", 0, 7)  
    // Then we calculate the Fibonacci of each element    
    // and add append it to the list
    Str fib := ""
    for (i := 2; i <= n; i++)
    {    
      if (i < n)    
        series.append(", ", 0, 2)
      else    
        series.append(" = ", 0, 3)
      
      fib = fibonacci(i).toStr
      series.append(fib, 0, fib.size)  
    }    
    // return the list as a string    
    return series.toStr
  }    
  
  static BigInteger factorial(Int n)    
  {    
    if (n == 1)      
      return BigInteger.ONE
    else      
      return BigInteger.valueOf(n).multiply(factorial(n - 1))  
  }            
  
  static Int fibonacci(Int n)    
  {    
    if (n < 2)
      return 1  
    else      
      return fibonacci(n - 1) + fibonacci(n - 2)  
  }       
}    
  
// Console Program  
public class FiborialSeriesApp    
{    
  public static Void main()    
  {  
    // Printing Factorial Series    
    echo("")  
    echo(Fiborial.getFactorialSeries(5))   
    echo(Fiborial.getFactorialSeries(7)) 
    echo(Fiborial.getFactorialSeries(9)) 
    echo(Fiborial.getFactorialSeries(11)) 
    echo(Fiborial.getFactorialSeries(40))  
    // Printing Fibonacci Series    
    echo("")  
    echo(Fiborial.getFibonnaciSeries(5)) 
    echo(Fiborial.getFibonnaciSeries(7)) 
    echo(Fiborial.getFibonnaciSeries(9)) 
    echo(Fiborial.getFibonnaciSeries(11))  
    echo(Fiborial.getFibonnaciSeries(40)) 
  }
}

And the Output is:

Mixing Instance and Static Members in the same Class

Instance classes can contain both, instance and static members such as: fields, getters, constructors/initializers, methods, etc.

// Instance Class  
class Fiborial
{  
  // Instance Field  
  private Int instanceCount  
  // Static Field
  // Static field 'staticCount' must be const
  private const static Int staticCount
  // Instance Read-Only Property   
  Int InstanceCount
  {
    get { return &instanceCount }  
  }  
  // Static Fields need to be const. A static const cannot have getter
  // using Static Read-Only Getter instead  
  // As with Static Methods, you cannot reference your class members  
  // with the "this" reference pointer since static members are not  
  // instantiated.  
  /*static Int StaticCount
  {    
    get { return &staticCount }    
  }*/
  static Int getStaticCount() 
  {
    return staticCount
  }
  // Instance Constructor  
  new make() 
  {  
    this.instanceCount = 0  
    echo("\nInstance Constructor ${this.instanceCount}")  
  }  
  // Static Constructor
  // Static constructors are methods executed to initialize the class itself. 
  // They are typically used to initialize static fields.
  static  
  {    
    staticCount = 0    
    echo("\nStatic Constructor $staticCount")
  }      
  // Instance Method  
  Void factorial(Int n) 
  {  
    this.instanceCount += 1  
    echo("\nFactorial($n)")  
  }  
  // Static Method  
  static Void fibonacci(Int n) 
  {  
    // Error: 
    // Cannot set const static field 'staticCount' outside of static initializer 
    // (static constructor) so we cannot increment staticCount
    // staticCount += 1  
    echo("\nFibonacci($n)")  
  }  
}

public class FiborialExtrasApp    
{    
  public static Void main()    
  {  
    // Calling Static Constructor and Methods  
    // No need to instantiate  
    Fiborial.fibonacci(5)  
      
    // Calling Instance Constructor and Methods  
    // Instance required  
    Fiborial fib := Fiborial()  
    fib.factorial(5)  
      
    Fiborial.fibonacci(15)  
    fib.factorial(5)  
      
    // Calling Instance Constructor and Methods  
    // for a second object  
    Fiborial fib2 := Fiborial()
    fib2.factorial(5)
      
    echo("")  
    // Calling Static Property  
    echo("Static Count = ${Fiborial.getStaticCount}")  
    // Calling Instance Property of object 1 and 2  
    echo("Instance 1 Count = ${fib.InstanceCount}")  
    echo("Instance 2 Count = ${fib2.InstanceCount}")   
  }
}

And the Output is:

Factorial using java.lang.Long/sys::Int, java.lang.Double/sys::Float, java.math.BigInteger

using [java] com.carlosqt.util::Stopwatch
using [java] java.math::BigInteger

public class FiborialTypesApp    
{    
  public static Void main()    
  {     
    Stopwatch timer := Stopwatch()    
    Int facIntResult := 0
    Float facDblResult := 0f    
    BigInteger facBigResult := BigInteger.ZERO 
    
    echo("\nFactorial using Int64")  
    // Benchmark Factorial using Int64    
    for (i := 5; i <= 50; i += 5)    
    {    
      timer.start
      facIntResult = factorialInt64(i)    
      timer.stop    
      echo(" ($i) = ${timer.getElapsed} : $facIntResult")  
    }    
    echo("\nFactorial using Float/Double")
    // Benchmark Factorial using Double    
    for (i := 5; i <= 50; i += 5)    
    {    
      timer.start    
      facDblResult = factorialDouble(i)    
      timer.stop                
      echo(" ($i) = ${timer.getElapsed} : $facDblResult")  
    }    
    echo("\nFactorial using BigInteger")    
    // Benchmark Factorial using BigInteger    
    for (i := 5; i <= 50; i += 5)    
    {    
      timer.start();    
      facBigResult = factorialBigInteger(i);    
      timer.stop();    
      echo(" ($i) = ${timer.getElapsed} : $facBigResult")
    }            
  }  
      
  // Int64 Factorial    
  static Int factorialInt64(Int n)    
  {    
    if (n == 1)    
      return 1
    else    
      return n * factorialInt64(n - 1)  
  }  
    
  // Float Factorial  
  static Float factorialDouble(Int n)    
  {    
    if (n == 1)    
      return 1f
    else    
      return n * factorialDouble(n - 1)  
  }  
    
  // BigInteger Factorial   
  static BigInteger factorialBigInteger(Int n)    
  {    
    if (n == 1)    
      return BigInteger.ONE  
    else    
      return BigInteger.valueOf(n).multiply(factorialBigInteger(n - 1))
  }
}

And the Output is:

Factorial and Fibonacci in Gosu

2012-02-05T03:29:00.000-08:00

Here below a little program in Gosu that implements 2 classes (in fact, they are 3 + an extra utility Stopwatch class from my previous post http://carlosqt.blogspot.com/2011/05/stopwatch-class-for-java.html). There is the main class, called Fiborial (Fibo(nnacci)+(Facto)rial) that implements the Fibonacci and the Factorial algorithms in two ways, one Recursive (using recursion) and the other Imperative (using loops and states). The second class is just an instance class that does the same thing, but its there just to show the difference between static and instance classes, and finally the third one (which will not appear in other languages) is the Program class which has the static execution method "main".

You can also find 3 more little examples at the bottom. One prints out the Factorial's Series and Fibonacci's Series, the second one just shows a class that mixes both: static and instance members, and finally the third one that uses different return types (including java.math.BigInteger) for the Factorial method to compare the timing and result.

As with the previous posts, you can copy and paste the code below in your favorite IDE/Editor and start playing and learning with it. This little "working" program will teach you some more basics of the Programming Language.

There are some "comments" on the code added just to tell you what are or how are some features called. In case you want to review the theory, you can read my previous post, where I give a definition of each of the concepts mentioned on the code. You can find it here: http://carlosqt.blogspot.com/2011/01/new-series-factorial-and-fibonacci.html

The Fiborial Program

// Factorial and Fibonacci in Gosu
package com.series
uses com.series.Stopwatch
uses java.math.BigInteger
uses java.util.Scanner
uses java.lang.System

// static class
static class StaticFiborial {
  // Static Field
  private static var className: String = "Static Constructor"
  //  no available static constructor support
  // you can initialize your static fields instead
  /*static construct() {  // error: constructors cannot be static
    className = "Static Constructor";
    print(className)
  }*/
  // Static Method - Factorial Recursive
  static function factorialR( n : int ) : BigInteger {
    if (n == 1) {
      return BigInteger.ONE
    }
    else {
      return BigInteger.valueOf(n).multiply(factorialR(n - 1))
    }
  }
  // Class/Static Method - Factorial Imperative
  static function factorialI( n : int ) : BigInteger {
    var res = BigInteger.ONE
    while (n > 1) {
      res = res.multiply(BigInteger.valueOf(n))
      n -= 1
    }
    return res
  }
  // Static Method - Fibonacci Recursive
  static function fibonacciR( n : int ) : long {
    if (n < 2) {
      return 1
    }
    else {
      return fibonacciR(n - 1) + fibonacciR(n - 2)
    }
  }
  // Static Method - Fibonacci Imperative
  static function fibonacciI( n : int ) : long {
    var pre : long = 1
    var cur : long = 1
    var tmp : long = 0
    for ( i in 2..n ) {
      tmp = cur + pre
      pre = cur
      cur = tmp
    }
    return cur
  }
  // Static Method - Benchmarking Algorithms
  static function benchmarkAlgorithm( algorithm : int, values : List<int>) {
    var timer = new Stopwatch()
    var testValue = 0
    var facTimeResult : BigInteger = BigInteger.ZERO
    var fibTimeResult : long = 0
    // "Switch" Flow Control Statement
    switch (algorithm)
    {
      case 1:
          print("\nFactorial Imperative:")
          // "For" Loop Statement
          for (i in 0..values.size()-1) {
            testValue = values.get(i).intValue()
            // Taking Time
            timer.start()
            facTimeResult = factorialI(testValue)
            timer.stop()
            // Getting Time
            print(" (${testValue}) = ${timer.getElapsed()}")
          }
          break
      case 2:
          print("\nFactorial Recursive:")
          // "While" Loop Statement
          var i = 0
          while ( i < values.size() ) {
            testValue = values.get(i).intValue()
            // Taking Time
            timer.start()
            facTimeResult = factorialR(testValue)
            timer.stop()
            // Getting Time
            print(" (${testValue}) = ${timer.getElapsed()}")
            i++
          }
          break
      case 3:
          print("\nFibonacci Imperative:")
          // "Do-While" Loop Statement
          var i = 0
          do {
            testValue = values.get(i).intValue()
            // Taking Time
            timer.start()
            fibTimeResult = fibonacciI(testValue)
            timer.stop()
            // Getting Time
            print(" (${testValue}) = ${timer.getElapsed()}")
            i++
          } while (i < values.size());
          break
      case 4:
          print("\nFibonacci Recursive:")
          // "For Each" Loop Statement
          for (item in values) {
            testValue = item
            // Taking Time
            timer.start()
            facTimeResult = fibonacciR(testValue)
            timer.stop()
            // Getting Time
            print(" (${testValue}) = ${timer.getElapsed()}")
          }
          break
    }
  }
}

// Instance Class
class InstanceFiborial {
  // Instance Field
  private var className : String
  // Instance Constructor
  construct() {
    this.className = "Instance Constructor"
    print(this.className)
  }
  // Instance Method - Factorial Recursive
  function factorialR( n : int ) : BigInteger {
    // Calling Static Method
    return StaticFiborial.factorialR(n)
  }
  // Instance Method - Factorial Imperative
  function factorialI( n : int ) : BigInteger {
    // Calling Static Method
    return StaticFiborial.factorialI(n)
  }
  // Instance Method - Fibonacci Recursive
  function fibonacciR( n : int ) : long {
    // Calling Static Method
    return StaticFiborial.fibonacciR(n)
  }
  // Instance Method - Factorial Imperative
  function fibonacciI( n : int ) : long {
    // Calling Static Method
    return StaticFiborial.fibonacciI(n)
  }
}

// Console Program
print("Static Class")
//Calling Static Class and Methods
//No instantiation needed. Calling method directly from the class
print("FacImp(5) = " + StaticFiborial.factorialI(5))
print("FacRec(5) = " + StaticFiborial.factorialR(5))
print("FibImp(11)= " + StaticFiborial.fibonacciI(11))
print("FibRec(11)= " + StaticFiborial.fibonacciR(11))

print("\nInstance Class")
//Calling Instance Class and Methods
//Need to instantiate before using. Calling method from instantiated object
var ff = new InstanceFiborial()
print("FacImp(5) = ${ff.factorialI(5)}")
print("FacRec(5) = ${ff.factorialR(5)}")
print("FibImp(11)= ${ff.fibonacciI(11)}")
print("FibRec(11)= ${ff.fibonacciR(11)}")

//Create a (generic) list of values to test
//From 5 to 50 by 5
var values = new List<int>()
var i = 5
while (i < 55) {
  values.add(i)
  i+=5
}

// Benchmarking Fibonacci
// 1 = Factorial Imperative
StaticFiborial.benchmarkAlgorithm(1, values)
// 2 = Factorial Recursive
StaticFiborial.benchmarkAlgorithm(2, values)

// Benchmarking Factorial
// 3 = Fibonacci Imperative
StaticFiborial.benchmarkAlgorithm(3, values)
// 4 = Fibonacci Recursive
StaticFiborial.benchmarkAlgorithm(4, values)

// Stop and exit
var sin = new Scanner(System.in)
var line = sin.nextLine()
sin.close()

And the Output is:

Printing the Factorial and Fibonacci Series

package com.series
uses java.math.BigInteger
uses java.lang.StringBuffer

static class Fiborial {
  // Using a StringBuffer as a list of string elements
  static function getFactorialSeries( n : int ) : String {
    // Create the String that will hold the list
    var series = new StringBuffer()
    // We begin by concatenating the number you want to calculate
    // in the following format: "!# ="
    series.append("!")
    series.append(n)
    series.append(" = ")
    // We iterate backwards through the elements of the series
    for (i in n..0){
      // and append it to the list
      series.append(i)
      if (i > 1)
        series.append(" * ")
      else
        series.append(" = ")
    }
    // Get the result from the Factorial Method
    // and append it to the end of the list
    series.append(factorial(n).toString())
    // return the list as a string
    return series.toString()
  }

  // Using a StringBuffer as a list of string elements
  static function getFibonnaciSeries( n : int ) : String {
    // Create the String that will hold the list
    var series = new StringBuffer()
    // We begin by concatenating the first 3 values which
    // are always constant
    series.append("0, 1, 1")
    // Then we calculate the Fibonacci of each element
    // and add append it to the list
    for (i in 2..n) {
      if (i < n)
        series.append(", ")
      else
        series.append(" = ")
      series.append(fibonacci(i))
    }
    // return the list as a string
    return series.toString()
  }

  static function factorial( n : int  ) : BigInteger {
    if (n == 1)
      return BigInteger.ONE
    else
      return BigInteger.valueOf(n).multiply(factorial(n - 1))
  }

  static function fibonacci( n : int ) : long {
    if (n < 2)
      return 1
    else
      return fibonacci(n - 1) + fibonacci(n - 2)
  }
}

// Printing Factorial Series
print("")
print(Fiborial.getFactorialSeries(5))
print(Fiborial.getFactorialSeries(7))
print(Fiborial.getFactorialSeries(9))
print(Fiborial.getFactorialSeries(11))
print(Fiborial.getFactorialSeries(40))
// Printing Fibonacci Series
print("")
print(Fiborial.getFibonnaciSeries(5))
print(Fiborial.getFibonnaciSeries(7))
print(Fiborial.getFibonnaciSeries(9))
print(Fiborial.getFibonnaciSeries(11))
print(Fiborial.getFibonnaciSeries(40))

And the Output is:

Mixing Instance and Static Members in the same Class

Instance classes can contain both, instance and static members such as: fields, properties, constructors/initializers, methods, etc.

// Fiborial.gs
package com.series

// Instance Class
class Fiborial {
  // Instance Field
  private var _instanceCount : int
  // Static Field - no static constructor so it needs to be initialized here
  private static var _staticCount : int = 0
  // Instance Read-Only Property
  // Within instance members, you can always use
  // the "this" reference pointer to access your (instance) members.
  property get InstanceCount() : int {
    return this._instanceCount
  }
  // Static Read-Only Getter
  // As with Static Methods, you cannot reference your class members
  // with the "this" reference pointer since static members are not
  // instantiated.
  static property get StaticCount() : int {
    return _staticCount
  }
  // Instance Constructor
  construct() {
    this._instanceCount = 0
    print("\nInstance Constructor ${this.instanceCount}")
  }
  // Static Constructor
  // not supported in Gosu. Constructor cannot be static.
  /*static construct() {
    staticCount = 0;
    print("\nStatic Constructor $staticCount")
  }
  */
  // Instance Method
  function factorial( n : int ) {
    this._instanceCount += 1
    print("\nFactorial(${n})")
  }
  // Static Method
  static function fibonacci( n : int ) {
    _staticCount += 1
    print("\nFibonacci(${n})")
  }
}

// FiborialExtrasApp.gsp
package com.series

// Calling Static Constructor and Methods
// No need to instantiate
Fiborial.fibonacci(5)

// Calling Instance Constructor and Methods
// Instance required
var fib = new Fiborial()
fib.factorial(5)

Fiborial.fibonacci(15)
fib.factorial(5)

// Calling Instance Constructor and Methods
// for a second object
var fib2 = new Fiborial()
fib2.factorial(5)

print("")
// Calling Static Property
print("Static Count = ${Fiborial.getStaticCount()}")
// Calling Instance Property of object 1 and 2
print("Instance 1 Count = ${fib.getInstanceCount()}")
print("Instance 2 Count = ${fib2.getInstanceCount()}")

And the Output is:

Factorial using java.lang.Long, java.lang.Double, java.math.BigInteger

package com.series
uses java.math.BigInteger
uses com.series.Stopwatch

// Long Factorial
function factorialInt64( n : int ) : long
{
  if (n == 1)
    return 1
  else
    return n * factorialInt64(n - 1)
}

// Double Factorial
function factorialDouble( n : int ) : double
{
  if (n == 1)
    return 1
  else
    return n * factorialDouble(n - 1)
}

// BigInteger Factorial
function factorialBigInteger( n : int ) : BigInteger
{
  if (n == 1)
    return BigInteger.ONE
  else
    return BigInteger.valueOf(n).multiply(factorialBigInteger(n - 1))
}

var timer = new Stopwatch()
var facIntResult : long = 0
var facDblResult : double = 0
var facBigResult = BigInteger.ZERO

print("\nFactorial using Int64")
// Benchmark Factorial using Int64
var i = 5
while (i < 55) {
  timer.start()
  facIntResult = factorialInt64(i)
  timer.stop()
  print(" (${i}) = ${timer.getElapsed()} : ${facIntResult}")
  i += 5
}
print("\nFactorial using Double")
// Benchmark Factorial using Double
i = 5
while (i < 55) {
  timer.start()
  facDblResult = factorialDouble(i)
  timer.stop()
  print(" (${i}) = ${timer.getElapsed()} : ${facDblResult}")
  i += 5
}
print("\nFactorial using BigInteger")
// Benchmark Factorial using BigInteger
i = 5
while (i < 55) {
  timer.start()
  facBigResult = factorialBigInteger(i)
  timer.stop()
  print(" (${i}) = ${timer.getElapsed()} : ${facBigResult}")
  i += 5
}

And the Output is:

Factorial and Fibonacci in Groovy

2012-01-20T15:47:00.000-08:00

Here below a little program in Groovy that implements 2 classes (in fact, they are 3 + an extra utility Stopwatch class from my previous post http://carlosqt.blogspot.com/2011/05/stopwatch-class-for-java.html). There is the main class, called Fiborial (Fibo(nnacci)+(Facto)rial) that implements the Fibonacci and the Factorial algorithms in two ways, one Recursive (using recursion) and the other Imperative (using loops and states). The second class is just an instance class that does the same thing, but its there just to show the difference between static and instance classes, and finally the third one (which will not appear in other languages) is the Program class which has the static execution method "main".

You can also find 3 more little examples at the bottom. One prints out the Factorial's Series and Fibonacci's Series, the second one just shows a class that mixes both: static and instance members, and finally the third one that uses different return types (including java.math.BigInteger) for the Factorial method to compare the timing and result.

As with the previous posts, you can copy and paste the code below in your favorite IDE/Editor and start playing and learning with it. This little "working" program will teach you some more basics of the Programming Language.

There are some "comments" on the code added just to tell you what are or how are some features called. In case you want to review the theory, you can read my previous post, where I give a definition of each of the concepts mentioned on the code. You can find it here: http://carlosqt.blogspot.com/2011/01/new-series-factorial-and-fibonacci.html

The Fiborial Program

// Factorial and Fibonacci in Groovy  
package com.series  
import java.math.BigInteger  
  
// Instance Class  
class StaticFiborial    
{      
    // Static Field      
    private static className  
    // Class/Static Constructor/Initializer    
    static    
    {      
        className = "Static Constructor"  
        println className  
    }      
    // Class/Static Method - Factorial Recursive      
    static factorialR(int n)      
    {      
        if (n == 1)      
            return BigInteger.ONE  
        else      
            return n * factorialR(n - 1)  
    }      
    // Class/Static Method - Factorial Imperative      
    static factorialI(int n)      
    {      
        def res = BigInteger.ONE  
        for (int i = n; i >= 1; i--)      
        {                      
            res *= i  
        }      
        return res  
    }      
    // Class/Static Method - Fibonacci Recursive      
    static fibonacciR(int n)      
    {      
        if (n < 2)      
            return 1  
        else      
            return fibonacciR(n - 1) + fibonacciR(n - 2)  
    }      
    // Class/Static Method - Fibonacci Imperative      
    static fibonacciI(int n)      
    {                  
        def pre, cur, tmp = 0  
        pre = cur = 1          
        for (i in 2..n)  
        {      
            tmp = cur + pre  
            pre = cur  
            cur = tmp  
        }      
        return cur    
    }          
    // Class/Static Method - Benchmarking Algorithms      
    static benchmarkAlgorithm(algorithm, values)      
    {                  
        def timer = new Stopwatch()  
        def i, testValue  
        def facTimeResult = BigInteger.ZERO  
        def fibTimeResult = 0  
        i = testValue = 0              
              
        // "Switch" Flow Control Statement      
        switch (algorithm)      
        {      
            case 1:      
                println "\nFactorial Imperative:"  
                // "For" Loop Statement      
                for (i = 0; i < values.size(); i++)      
                {                              
                    testValue = ((Integer)values.get(i)).intValue()  
                    // Taking Time      
                    timer.start()  
                    facTimeResult = factorialI(testValue)  
                    timer.stop()      
                    // Getting Time      
                    println " ($testValue) = ${timer.getElapsed()}"  
                }                          
                break      
            case 2:      
                println "\nFactorial Recursive:"  
                // "While" Loop Statement      
                while (i < values.size())      
                {                              
                    testValue = ((Integer)values.get(i)).intValue()  
                    // Taking Time      
                    timer.start()  
                    facTimeResult = factorialR(testValue)  
                    timer.stop()  
                    // Getting Time      
                    println " ($testValue) = ${timer.getElapsed()}"  
                    i++  
                }      
                break     
            case 3:      
                println "\nFibonacci Imperative:"  
                // "For" Loop Statement      
                for (j in 0..values.size()-1)  
                {   
                    testValue = ((Integer)values.get(j)).intValue()  
                    // Taking Time  
                    timer.start()  
                    fibTimeResult = fibonacciI(testValue)  
                    timer.stop()  
                    // Getting Time      
                    println " ($testValue) = ${timer.getElapsed()}"                      
                }                  
                break  
            case 4:      
                println "\nFibonacci Recursive:"  
                // "For Each" Loop Statement                      
                for (item in values)  
                {      
                    testValue = item  
                    // Taking Time      
                    timer.start()    
                    fibTimeResult = fibonacciR(testValue)  
                    timer.stop()  
                    // Getting Time  
                    println " ($testValue) = ${timer.getElapsed()}"  
                }   
                break  
            default:      
                println "DONG!"  
                break  
        }   
    }      
}  
  
// Instance Class      
class InstanceFiborial      
{      
    // Instance Field      
    private def className  
    // Instance Constructor      
    def InstanceFiborial()      
    {      
        this.className = "Instance Constructor"  
        println this.className  
    }      
    // Instance Method - Factorial Recursive      
    def factorialR(n)      
    {      
        // Calling Static Method      
        return StaticFiborial.factorialR(n)  
    }      
    // Instance Method - Factorial Imperative      
    def factorialI(n)      
    {      
        // Calling Static Method      
        return StaticFiborial.factorialI(n)      
    }      
    // Instance Method - Fibonacci Recursive  
    def fibonacciR(n)      
    {      
        // Calling Static Method      
        return StaticFiborial.fibonacciR(n)  
    }      
    // Instance Method - Factorial Imperative      
    def fibonacciI(n)      
    {      
        // Calling Static Method      
        return StaticFiborial.fibonacciI(n)  
    }      
}    
  
  
println "\nStatic Class"      
// Calling Static Class and Methods  
// No instantiation needed. Calling method directly from the class      
println "FacImp(5) = ${StaticFiborial.factorialI(5)}"  
println "FacRec(5) = ${StaticFiborial.factorialR(5)}"      
println "FibImp(11)= ${StaticFiborial.fibonacciI(11)}"      
println "FibRec(11)= ${StaticFiborial.fibonacciR(11)}"  
  
println "\nInstance Class"      
// Calling Instance Class and Methods       
// Need to instantiate before using. Calling method from instantiated object      
def ff = new InstanceFiborial()  
println "FacImp(5) = ${ff.factorialI(5)}"  
println "FacRec(5) = ${ff.factorialR(5)}"  
println "FibImp(11)= ${ff.fibonacciI(11)}"  
println "FibRec(11)= ${ff.fibonacciR(11)}"  
  
// Create a list of integer values to test  
// From 5 to 50 by 5      
def values = []  
5.step(55, 5) {  
    values.add(it)  
}  
  
// Benchmarking Fibonacci                           
// 1 = Factorial Imperative                  
StaticFiborial.benchmarkAlgorithm(1, values)  
// 2 = Factorial Recursive      
StaticFiborial.benchmarkAlgorithm(2, values)  
  
// Benchmarking Factorial                  
// 3 = Fibonacci Imperative      
StaticFiborial.benchmarkAlgorithm(3, values)  
// 4 = Fibonacci Recursive      
StaticFiborial.benchmarkAlgorithm(4, values)  
  
// Stop and exit      
println "Press any key to exit..."    
def sin = new Scanner(System.in)    
def line = sin.nextLine()    
sin.close()

And the Output is:

Printing the Factorial and Fibonacci Series

package com.series  
import java.math.BigInteger    
import java.lang.StringBuffer  
    
class Fiborial    
{    
    // Using a StringBuffer as a list of string elements    
    static getFactorialSeries(n)    
    {    
        // Create the String that will hold the list    
        def series = new StringBuffer()  
        // We begin by concatenating the number you want to calculate    
        // in the following format: "!# ="    
        series.append("!")  
        series.append(n)  
        series.append(" = ")  
        // We iterate backwards through the elements of the series    
        for (i in n..0)  
        {    
            // and append it to the list    
            series.append(i)  
            if (i > 1)  
                series.append(" * ")  
            else     
                series.append(" = ")  
        }  
        // Get the result from the Factorial Method    
        // and append it to the end of the list    
        series.append(factorial(n))    
        // return the list as a string    
        return series
    }    
    
    // Using a StringBuffer as a list of string elements    
    static getFibonnaciSeries(n)    
    {    
        // Create the String that will hold the list    
        def series = new StringBuffer();    
        // We begin by concatenating the first 3 values which    
        // are always constant    
        series.append("0, 1, 1")  
        // Then we calculate the Fibonacci of each element    
        // and add append it to the list    
        for (i in 2..n)  
        {    
            if (i < n)    
                series.append(", ")  
            else    
                series.append(" = ")  
                
            series.append(fibonacci(i))  
        }    
        // return the list as a string    
        return series    
    }    
    
    static factorial(n)    
    {    
        if (n == 1)      
            return BigInteger.ONE  
        else      
            return n * factorial(n - 1)  
    }            
    
    static fibonacci(n)    
    {    
        if (n < 2)      
            return 1  
        else      
            return fibonacci(n - 1) + fibonacci(n - 2)  
    }       
}    
  
  
// Printing Factorial Series    
println ""
println Fiborial.getFactorialSeries(5)    
println Fiborial.getFactorialSeries(7)  
println Fiborial.getFactorialSeries(9)  
println Fiborial.getFactorialSeries(11)  
println Fiborial.getFactorialSeries(40)  
// Printing Fibonacci Series    
println ""  
println Fiborial.getFibonnaciSeries(5)  
println Fiborial.getFibonnaciSeries(7)  
println Fiborial.getFibonnaciSeries(9)  
println Fiborial.getFibonnaciSeries(11)  
println Fiborial.getFibonnaciSeries(40)

And the Output is:

Mixing Instance and Static Members in the same Class

Instance classes can contain both, instance and static members such as: fields, getters/setters, constructors/initializers, methods, etc.

package com.series

// Instance Class    
class Fiborial    
{    
    // Instance Field    
    private def instanceCount    
    // Static Field    
    private static staticCount
    // Instance Read-Only Getter    
    // Within instance members, you can always use      
    // the "this" reference pointer to access your (instance) members.    
    def getInstanceCount()  
    {    
        return this.instanceCount     
    }    
    // Static Read-Only Getter        
    // As with Static Methods, you cannot reference your class members    
    // with the "this" reference pointer since static members are not    
    // instantiated.            
    static getStaticCount()  
    {    
        return staticCount    
    }    
    // Instance Constructor    
    def Fiborial()    
    {    
        this.instanceCount = 0
        println "\nInstance Constructor ${this.instanceCount}"
    }    
    // Static Constructor    
    static
    {    
        staticCount = 0;    
        println "\nStatic Constructor $staticCount"    
    }    
  
    // Instance Method    
    def factorial(n)    
    {    
        this.instanceCount += 1
        println "\nFactorial($n)"
    }    
  
    // Static Method    
    static fibonacci(n)    
    {    
        staticCount += 1    
        println "\nFibonacci($n)"
    }                    
}  

// Calling Static Constructor and Methods    
// No need to instantiate    
Fiborial.fibonacci(5)

// Calling Instance Constructor and Methods
// Instance required    
def fib = new Fiborial()
fib.factorial(5)           

Fiborial.fibonacci(15)
fib.factorial(5)

// Calling Instance Constructor and Methods    
// for a second object    
def fib2 = new Fiborial()
fib2.factorial(5)

println ""
// Calling Static Property    
println "Static Count = ${Fiborial.getStaticCount()}}"
// Calling Instance Property of object 1 and 2    
println "Instance 1 Count = ${fib.getInstanceCount()}"
println "Instance 2 Count = ${fib2.getInstanceCount()}"

And the Output is:

Factorial using java.lang.Long, java.lang.Double, java.math.BigInteger

package com.series    
import java.math.BigInteger  
      
// Long Factorial      
long factorialInt64(n)      
{      
    if (n == 1)      
        return 1    
    else      
        return n * factorialInt64(n - 1)    
}    
  
// Double Factorial    
double factorialDouble(n)      
{      
    if (n == 1)      
        return 1  
    else      
        return n * factorialDouble(n - 1)  
}    
  
// BigInteger Factorial     
BigInteger factorialBigInteger(n)      
{      
    if (n == 1)      
        return BigInteger.ONE  
    else      
        return n * factorialBigInteger(n - 1)
}    
  
def timer = new Stopwatch()  
long facIntResult = 0     
double facDblResult = 0  
def facBigResult = BigInteger.ZERO      
  
println "\nFactorial using Int64"  
// Benchmark Factorial using Int64      
for (i in (5..50).step(5)) {      
    timer.start()  
    facIntResult = factorialInt64(i)  
    timer.stop()      
    println " ($i) = ${timer.getElapsed()} : ${facIntResult}"    
}      
println "\nFactorial using Double"  
// Benchmark Factorial using Double      
for (i in (5..50).step(5)) {      
    timer.start()  
    facDblResult = factorialDouble(i)  
    timer.stop()  
    println " ($i) = ${timer.getElapsed()} : ${facDblResult}"  
}      
println "\nFactorial using BigInteger"  
// Benchmark Factorial using BigInteger      
for (i in (5..50).step(5)) {      
    timer.start()  
    facBigResult = factorialBigInteger(i)  
    timer.stop()  
    println " ($i) = ${timer.getElapsed()} : ${facBigResult}"              
}

And the Output is:

2012-01-10T23:37:00.000-08:00

Hi Everyone! Happy and successful 2012 to all of you!

Last couple of months I haven't been active on this blog, I had a busy end of year plus December holidays on where I hardly touched the keyboard :) anyway, I have noticed, thanks to google analytics, that many people had visited this blog from all around the world since I created it (2009-Today) (see below).

Note: The number of visits from Belgium is not real... that is more because I visit it often hehe.

Now, to me, this means that I have some public, and that what I'm doing is not meaningless so, this year, I will try to become more active and continue adding more code examples on the current languages and the new ones that appeared during last year and the ones that will show up this year.

So, here are my priorities concerning this blog:

Finilize the "Factorial and Fibonacci Series" in Groovy, Gosu, Zonnon, Fantom
Adding Xtend, Ceylon (and Kotlin once released) to the blog posts "OO Hello World", "Basics by Example" and "Factorial and Fibonacci Series"
I'm still considering including Oxygene (ObjectPascal/Delphi for the JVM) as a separate language. Since it is exactly the same than Delphi Prism (aka Embarcadero Prism)... I think I won't do it.
JavaFX Script was deprecated as a language on 2011. I won't post about it any more.
Will continue updating the Languages Page with the latest releases and languages.

Voilà! that's it!

Regards!
Carlos

Factorial and Fibonacci in JRuby

2011-10-21T12:53:00.000-07:00

Here below a little program in JRuby that implements 2 classes. There is the main class, called Fiborial (Fibo(nnacci)+(Facto)rial) that implements the Fibonacci and the Factorial algorithms in two ways, one Recursive (using recursion) and the other Imperative (using loops and states). The second class is just an instance class that does the same thing, but its there just to show the difference between static and instance classes, and finally a main function called as module level code.

You can also find 3 more little examples at the bottom. One prints out the Factorial's Series and Fibonacci's Series, the second one just shows a class that mixes both: static and instance members, and finally the third one that uses different return types for the Factorial method to compare the timing and result.

As with the previous posts, you can copy and paste the code below in your favorite IDE/Editor and start playing and learning with it. This little "working" program will teach you some more basics of the Programming Language.

There are some "comments" on the code added just to tell you what are or how are some features called. In case you want to review the theory, you can read my previous post, where I give a definition of each of the concepts mentioned on the code. You can find it here: http://carlosqt.blogspot.com/2011/01/new-series-factorial-and-fibonacci.html

WARNING: the code that you will see below is not following ruby guidelines/idiomatic coding, I did it in purpose to compare ruby's syntax and features side by side with other programming languages... For instance, instead of using a ruby bignum I imported and used java.math.BigInteger instead. Other examples, naming convention and so on, so bear with me!

I'm using the same Stopwatch java class that I used in the Java version of this post. I just added the .class into a 'target' folder and added it to the classpath. then I java_imported it. http://carlosqt.blogspot.com/2011/05/stopwatch-class-for-java.html

The Fiborial Program

# Factorial and Fibonacci in JRuby  
require "java"    
$CLASSPATH << "target"
java_import 'Stopwatch'
import java.lang.System
import java.math.BigInteger
    
module FiborialRb  
    # Static Class  
    # static classes are not supported in Ruby  
    class StaticFiborial  
        # Static Field  
        @@class_name = ""  
        # no builtin static constructor/initializer support    
        # you can initialize field at this point and even add extra code           
        @@class_name = "Static Constructor"  
        puts @@class_name  
        # Static Method - Factorial Recursive  
        def self.factorial_r(n)  
            if n < 2  
                BigInteger.new('1')
            else                
                BigInteger.new(n.to_s).multiply(self.factorial_r(n-1))
            end  
        end  
        # Static Method - Factorial Imperative  
        def self.factorial_i(n)  
            res = BigInteger.new('1')
            while n > 1                    
                res = BigInteger.new(res.multiply(n).to_s)
                n -= 1  
            end  
            res  
        end  
        # Static Method - Fibonacci Recursive     
        def self.fibonacci_r(n)  
            if n < 2  
                1  
            else  
                self.fibonacci_r(n - 1) + self.fibonacci_r(n - 2)  
            end  
        end  
        # Static Method - Fibonacci Imperative  
        def self.fibonacci_i(n)  
            pre = 1  
            cur = 1  
            tmp = 0  
            for i in 2..n
                tmp = cur + pre  
                pre = cur  
                cur = tmp  
            end  
            cur  
        end  
        # Static Method - Benchmarking Algorithms  
        def self.benchmark_algorithm(algorithm, values)  
            timer = Stopwatch.new    
            i = 0  
            testValue = 0      
            facTimeResult = BigInteger::ZERO    
            fibTimeResult = 0             
            # "case/switch" Flow Control Statement  
            case algorithm  
            when 1  
                puts "\nFactorial Imperative:"  
                # "For in range" Loop Statement  
                for i in 0..values.size - 1 do  
                    testValue = values[i]                      
                    # Taking Time  
                    timer.start  
                    facTimeResult = self.factorial_i(testValue)      
                    timer.stop  
                    # Getting Time  
                    puts " (#{testValue}) = #{timer.elapsed}"                      
                end  
            when 2  
                puts "\nFactorial Recursive:"  
                # "While" Loop Statement  
                while i < values.size do  
                    testValue = values[i]  
                    # Taking Time  
                    timer.start  
                    facTimeResult = self.factorial_r(testValue)      
                    timer.stop  
                    # Getting Time  
                    puts " (#{testValue}) = #{timer.elapsed}"  
                    i += 1  
                end  
            when 3  
                puts "\nFibonacci Imperative:"  
                # "until" Loop Statement  
                until i == values.size do                      
                    testValue = values[i]  
                    # Taking Time  
                    timer.start  
                    fibTimeResult = self.fibonacci_i(testValue)      
                    timer.stop  
                    # Getting Time  
                    puts " (#{testValue}) = #{timer.elapsed}"  
                    i += 1  
                end  
            when 4  
                puts "\nFibonacci Recursive:"  
                # "For each?" Statement  
                values.each do |testValue|  
                    # Taking Time  
                    timer.start  
                    fibTimeResult = self.fibonacci_r(testValue)      
                    timer.stop  
                    # Getting Time  
                    puts " (#{testValue}) = #{timer.elapsed}"  
                end  
            else  
                puts "DONG!"  
            end  
        end  
    end  
      
    # Instance Class  
    class InstanceFiborial  
        # Instance Field  
        @class_name = ""  
        # Instance Constructor/Initializer  
        def initialize  
            @class_name = "Instance Constructor"  
            puts @class_name  
        end  
        # Instance Method - Factorial Recursive      
        def factorial_r(n)    
            # Calling Static Method      
            StaticFiborial::factorial_r(n)  
        end  
        # Instance Method - Factorial Imperative      
        def factorial_i(n)  
            # Calling Static Method      
            StaticFiborial::factorial_i(n)      
        end  
        # Instance Method - Fibonacci Recursive        
        def fibonacci_r(n)  
            # Calling Static Method      
            StaticFiborial::fibonacci_r(n)      
        end  
        # Instance Method - Fibonacci Imperative      
        def fibonacci_i(n)  
            # Calling Static Method      
            StaticFiborial::fibonacci_i(n)  
        end  
    end  
    
    # Console Program    
    puts "Static Class"      
    # Calling Static Class and Methods      
    # No instantiation needed. Calling method directly from the class      
    puts "FacImp(5) = #{StaticFiborial::factorial_i(5)}"  
    puts "FacRec(5) = #{StaticFiborial::factorial_r(5)}"   
    puts "FibImp(11)= #{StaticFiborial::fibonacci_i(11)}"   
    puts "FibRec(11)= #{StaticFiborial::fibonacci_r(11)}"   
      
    puts "\nInstance Class"  
    # Calling Instance Class and Methods      
    # Need to instantiate before using. Calling method from instantiated object      
    ff = InstanceFiborial.new  
    puts "FacImp(5) = #{ff.factorial_i(5)}"  
    puts "FacRec(5) = #{ff.factorial_r(5)}"  
    puts "FibImp(11)= #{ff.fibonacci_i(11)}"  
    puts "FibRec(11)= #{ff.fibonacci_r(11)}"  
          
    # Create a (Ruby) list of values to test        
    # From 5 to 50 by 5      
    values = []  
    for i in (5..50).step(5)  
        values << i  
    end  
  
    # Benchmarking Fibonacci      
    # 1 = Factorial Imperative     
    StaticFiborial::benchmark_algorithm(1,values)  
     # 2 = Factorial Recursive  
    StaticFiborial::benchmark_algorithm(2,values)  
    # Benchmarking Factorial      
    # 3 = Fibonacci Imperative   
    StaticFiborial::benchmark_algorithm(3,values)  
    # 4 = Fibonacci Recursive   
    StaticFiborial::benchmark_algorithm(4,values)  
      
    # Stop and exit    
    puts "Press any key to exit..."    
    gets    
end

And the Output is:

Printing the Factorial and Fibonacci Series

require 'java'
import java.lang.StringBuffer
import java.math.BigInteger

module FiborialSeriesRb

    class Fiborial  
         # Using a StringBuffer as a list of string elements    
         def self.get_factorial_series(n)  
            # Create the String to hold the list        
            series = StringBuffer.new      
            # We begin by concatenating the number you want to calculate        
            # in the following format: "!# ="        
            series.append("!")
            series.append(n)  
            series.append(" = ")  
            # We iterate backwards through the elements of the series  
            i = n  
            while i >= 1  
                # and append it to the list        
                series.append(i)      
                if i > 1       
                    series.append(" * ")        
                else  
                    series.append(" = ")      
                end  
                i -= 1  
            end  
            # Get the result from the Factorial Method        
            # and append it to the end of the list        
            series.append(self.factorial(n).to_s)  
            # return the list as a string  
            series.to_s  
         end  
           
         # Using a StringBuffer as a list of string elements  
         def self.get_fibonnaci_series(n)  
            # Create the String that will hold the list        
            series = StringBuffer.new  
            # We begin by concatenating the first 3 values which        
            # are always constant  
            series.append("0, 1, 1")        
            # Then we calculate the Fibonacci of each element        
            # and add append it to the list        
            for i in 2..n      
                if i < n      
                    series.append(", ")       
                else   
                    series.append(" = ")  
                end  
                series.append(self.fibonacci(i))  
            end  
            # return the list as a string        
            series.to_s    
         end  
           
        def self.factorial(n)  
            if n < 2  
                BigInteger.new('1')
            else  
                BigInteger.new(n.to_s).multiply(self.factorial(n-1))
            end  
        end  
          
        def self.fibonacci(n)
            if n < 2  
                1  
            else  
                self.fibonacci(n - 1) + self.fibonacci(n - 2)  
            end  
        end  
    end  
      
    # Printing Factorial Series        
    puts ""      
    puts Fiborial::get_factorial_series(5)      
    puts Fiborial::get_factorial_series(7)      
    puts Fiborial::get_factorial_series(9)      
    puts Fiborial::get_factorial_series(11)      
    puts Fiborial::get_factorial_series(40)      
    # Printing Fibonacci Series        
    puts ""      
    puts Fiborial::get_fibonnaci_series(5)      
    puts Fiborial::get_fibonnaci_series(7)      
    puts Fiborial::get_fibonnaci_series(9)      
    puts Fiborial::get_fibonnaci_series(11)      
    puts Fiborial::get_fibonnaci_series(40)   
      
    # Stop and exit    
    puts "Press any key to exit..."    
    gets    
end

And the Output is:

Mixing Instance and Static Members in the same Class

Instance classes can contain both, instance and static members such as: fields, properties, constructors, methods, etc.

require 'java'
 
# Instance Class    
class Fiborial  
    # Instance Field      
    @instance_count = 0  
    # Static Field  
    @@static_count = 0      
    # Instance Read-Only Getter  
    def get_instance_count()       
        @instance_count      
    end      
    # Static Read-Only Getter  
    def self.get_static_count()
        @@static_count  
    end      
    # Instance Constructor/Initializer  
    def initialize()    
        @instance_count = 0  
        puts "\nInstance Constructor #{@instance_count}"  
    end  
    # No Static Constructor/Initializer  
    # You can do a self.initialize() static method, but it will not be called  
    #def self.initialize()  
    #    @@static_count = 0    
    #    puts "\nStatic Constructor #{@@static_count}"  
    # Instance Method  
    def factorial(n)    
        @instance_count += 1       
        puts "\nFactorial(#{n.to_s})"  
    end  
    # Static Method     
    def self.fibonacci(n)  
        @@static_count += 1      
        puts "\nFibonacci(#{n.to_s})"  
    end          
    
    # Calling Static Constructor and Methods        
    # No need to instantiate        
    Fiborial::fibonacci(5)      
          
    # Calling Instance Constructor and Methods        
    # Instance required        
    fib = Fiborial.new        
    fib.factorial(5)  
    
    Fiborial::fibonacci(15)      
    fib.factorial(5)  
          
    # Calling Instance Constructor and Methods        
    # for a second object        
    fib2 = Fiborial.new     
    fib2.factorial(5)      
          
    puts ""  
    # Calling Static Getter      
    puts "Static Count = #{Fiborial::get_static_count}"   
    # Calling Instance Property of object 1 and 2        
    puts "Instance 1 Count = #{fib.get_instance_count}"  
    puts "Instance 2 Count = #{fib2.get_instance_count}"  
          
    gets  
end

And the Output is:

Factorial using int, float, System.Numerics.BigInteger

So, it looks like integers in ruby can hold big integers (they are handled as bignum), so using JRuby int/long or java.math.BigInteger is the same so not much to say here.

require 'java'
$CLASSPATH << "target"
java_import 'Stopwatch'
import java.math.BigInteger
      
# Int/Long Factorial      
def factorial_int(n)  
    if n == 1  
        1.to_i  
    else      
        (n * factorial_int(n - 1)).to_i  
    end  
end  
# double/float Factorial  
def factorial_float(n)  
    if n == 1    
        1.0
    else  
        (n * factorial_float(n - 1)).to_f  
    end  
end  
# BigInteger Factorial         
def factorial_bigint(n)  
    if n == 1    
        BigInteger.new('1')  
    else            
        BigInteger.new(n.to_s).multiply(factorial_bigint(n-1))
    end  
end  
  
timer = Stopwatch.new  
facIntResult = 0    
facDblResult = 0.0      
facBigResult = BigInteger.new('0')  
i = 0      
          
puts "\nFactorial using Int/Long"  
# Benchmark Factorial using Int64        
for i in (5..50).step(5)  
    timer.start   
    facIntResult = factorial_int(i)  
    timer.stop  
    puts " (#{i.to_s}) = #{timer.elapsed} : #{facIntResult}"  
end  
puts "\nFactorial using Float/Double"  
# Benchmark Factorial using Double  
for i in (5..50).step(5)  
    timer.start      
    facDblResult = factorial_float(i)      
    timer.stop  
    puts " (#{i.to_s}) = #{timer.elapsed.to_s} : #{facDblResult.to_s}"  
end          
puts "\nFactorial using BigInteger"      
# Benchmark Factorial using BigInteger      
for i in (5..50).step(5)  
    timer.start  
    facBigResult = factorial_bigint(i)  
    timer.stop  
    puts " (#{i.to_s}) = #{timer.elapsed.to_s} : #{facBigResult.to_s}"  
end  
  
gets

And the Output is:

Factorial and Fibonacci in Scala

2011-10-15T16:04:00.000-07:00

Update 1: Porting code examples to Scala 2.10.1 - support for String Interpolation.

WARNING! I know that Scala is intended to be use in a very Functional way, however, my goal is to show its Imperative and OO language features, so it can be compared with other 19 OO languages. Said that, if you know how to do something on the examples below in a more Functional style you can add it in a comment :)

Here below a little program in Scala that implements 2 classes (in fact, they are 3). There is the main class, called Fiborial (Fibo(nnacci)+(Facto)rial) that implements the Fibonacci and the Factorial algorithms in two ways, one Recursive (using recursion) and the other Imperative (using loops and states). The second class is just an instance class that does the same thing, but its there just to show the difference between static and instance classes, and finally the third one (which will not appear in other languages) is the Program class which has the static execution method "Main".

You can also find 3 more little examples at the bottom. One prints out the Factorial's Series and Fibonacci's Series, the second one just shows a class that mixes both: static and instance members, and finally the third one that uses different return types (including System.Numerics.BigInteger) for the Factorial method to compare the timing and result.

As with the previous posts, you can copy and paste the code below in your favorite IDE/Editor and start playing and learning with it. This little "working" program will teach you some more basics of the Programming Language.

There are some "comments" on the code added just to tell you what are or how are some features called. In case you want to review the theory, you can read my previous post, where I give a definition of each of the concepts mentioned on the code. You can find it here: http://carlosqt.blogspot.com/2011/01/new-series-factorial-and-fibonacci.html

I'm using the same Stopwatch java class that I used in the Java version of this post. I just added the .java file in the same scala-eclipse project. http://carlosqt.blogspot.com/2011/05/stopwatch-class-for-java.html

The Fiborial Program

package com.series
import scala.math.BigInt._  
import java.util.Scanner
import blog.series.lib.Stopwatch

// Instance (Singleton) Class that works as a Module/Utils class             
// static is not a class modifier in Scala    
object StaticFiborial  
{  
    // 'Static' Field  
    // 'Static' Constructor/Initializer  
    private var _message:String = "'Static' Constructor"  
    println(_message)  
    // 'Static' Method - Factorial Recursive    
    def factorialR(n:Int):BigInt = {  
        if(n==1)  
            BigInt(1)  
        else  
            BigInt(n) * factorialR(n - 1)  
    }  
    // 'Static' Method - Factorial Imperative  
    def factorialI(n:Int):BigInt = {  
        var res:BigInt = 1        
        for (i <- n until 1 by -1) {  
            res = res * i  
        }        
        res  
    }  
    // 'Static' Method - Fibonacci Recursive   
    def fibonacciR(n:Int):Long = {  
        if(n<2)  
            1  
        else  
            fibonacciR(n - 1) + fibonacciR(n - 2)  
    }  
    // 'Static' Method - Fibonacci Imperative  
    def fibonacciI(n:Int):Long = {  
        var pre:Long = 1  
        var cur:Long = 1  
        var tmp:Long = 0  
        for(i <- 2 to n) {  
            tmp = cur + pre  
            pre = cur  
            cur = tmp  
        }  
        cur  
    }  
    // Static Method - Benchmarking Algorithms   
    def benchmarkAlgorithm(algorithm:Int, values:List[Int]) = {        
        val timer = new Stopwatch  
        var (i:Int, testValue:Int) = (0, 0)  
        var facTimeResult:BigInt = 0  
        var fibTimeResult:Long = 0  
        
        algorithm match {    
            case 1 =>   
                println("\nFactorial Imperative:")  
                // "For" Loop Statement  
                for (i <- 0 to values.size - 1) {  
                    testValue = values(i)  
                    // Taking Time      
                    timer.start()      
                    facTimeResult = factorialI(testValue)      
                    timer.stop()  
                    // Getting Time  
                    println(s" ($testValue) = ${timer.getElapsed}")  
                }  
            case 2 =>   
                println("\nFactorial Recursive:")  
                // "While" Loop Statement  
                while (i < values.size) {  
                    testValue = values(i)  
                    // Taking Time      
                    timer.start()      
                    facTimeResult = factorialR(testValue)      
                    timer.stop()  
                    // Getting Time  
                    println(s" ($testValue) = ${timer.getElapsed}")  
                    i += 1  
                }  
            case 3 =>  
                println("\nFibonacci Imperative:")  
                // "For" Loop Statement  
                for (i <- 0 to values.size - 1) {  
                    testValue = values(i)  
                    // Taking Time      
                    timer.start()      
                    fibTimeResult = fibonacciI(testValue)  
                    timer.stop()  
                    // Getting Time  
                    println(s" ($testValue) = ${timer.getElapsed}")  
                }  
            case 4 =>   
                println("\nFibonacci Recursive:")  
                // "For" Loop Statement  
                for (i <- 0 to values.size - 1) {  
                    testValue = values(i)  
                    // Taking Time      
                    timer.start()      
                    fibTimeResult = fibonacciR(testValue)  
                    timer.stop()  
                    // Getting Time  
                    println(s" ($testValue) = ${timer.getElapsed}")  
                }  
            case _ =>   
                println("DONG!")  
        }    
    }      
}  
  
class InstanceFiborial(message:String) {  
    // Instance Field  
    private var _message:String = message  
    // Instance Constructor      
    def this() = {  
        this("Instance Constructor")  
        println(_message)  
    }      
    // Instance Method - Factorial Recursive    
    def factorialR(n:Int):BigInt = {  
        // Calling 'Static' Method  
        StaticFiborial.factorialR(n)  
    }  
    // Instance Method - Factorial Imperative  
    def factorialI(n:Int):BigInt = {  
        // Calling 'Static' Method        
        StaticFiborial.factorialI(n)  
    }  
    // Instance Method - Fibonacci Recursive   
    def fibonacciR(n:Int):Long = {  
        // Calling 'Static' Method        
        StaticFiborial.fibonacciR(n)  
    }  
    // Instance Method - Fibonacci Imperative  
    def fibonacciI(n:Int):Long = {  
        // Calling 'Static' Method        
        StaticFiborial.fibonacciI(n)  
    }  
}  
  
object Program {  
    def main(args: Array[String]): Unit = {  
        // Calling 'Static' Class and Methods      
        // No instantiation needed. Calling method directly from the class      
        println(s"FacImp(5) = ${StaticFiborial.factorialI(5)}")      
        println(s"FacRec(5) = ${StaticFiborial.factorialR(5)}")      
        println(s"FibImp(11)= ${StaticFiborial.fibonacciI(11)}")      
        println(s"FibRec(11)= ${StaticFiborial.fibonacciR(11)}")   
          
        println("\nInstance Class")      
        // Calling Instance Class and Methods       
        // Need to instantiate before using. Call method from instantiated object      
        val ff = new InstanceFiborial()      
        println(s"FacImp(5) = ${ff.factorialI(5)}")      
        println(s"FacRec(5) = ${ff.factorialR(5)}")      
        println(s"FibImp(11)= ${ff.fibonacciI(11)}")      
        println(s"FibRec(11)= ${ff.fibonacciR(11)}")  
          
        // Create a (generic) list of integer values to test      
        // From 5 to 50 by 5  
        var values:List[Int] = Nil  
        for(i <- 5 until 55 by 5)  
            values = values ::: List(i)  
  
        // Benchmarking Fibonacci  
        // 1 = Factorial Imperative                  
        StaticFiborial.benchmarkAlgorithm(1, values)      
        // 2 = Factorial Recursive      
        StaticFiborial.benchmarkAlgorithm(2, values)      
    
        // Benchmarking Factorial                  
        // 3 = Fibonacci Imperative      
        StaticFiborial.benchmarkAlgorithm(3, values)      
        // 4 = Fibonacci Recursive      
        StaticFiborial.benchmarkAlgorithm(4, values)  
  
        println("Press any key to exit...")      
        val in = new Scanner(System.in)      
        in.nextLine()      
        in.close()           
    }  
}

And the Output is:

Printing the Factorial and Fibonacci Series

import scala.math.BigInt._
import scala.collection.mutable.StringBuilder._

object Fiborial {
    // Using a StringBuilder as a list of string elements
    def getFactorialSeries(n:Int):String = {
        // Create the String that will hold the list
        val series:StringBuilder = new StringBuilder
        // We begin by concatenating the number you want to calculate
        // in the following format: "!# ="
        series.append("!")
        series.append(n)
        series.append(" = ")
        // We iterate backwards through the elements of the series
        for (i <- n until 0 by -1) {
            // and append it to the list
            series.append(i)
            if (i > 1)
                series.append(" * ")
            else 
                series.append(" = ")
        }
        // Get the result from the Factorial Method
        // and append it to the end of the list
        series.append(factorial(n))
        // return the list as a string
        series.toString
    }

    // Using a StringBuilder as a list of string elements
    def getFibonnaciSeries(n:Int):String = {
        // Create the String that will hold the list
        val series:StringBuilder = new StringBuilder
        // We begin by concatenating the first 3 values which
        // are always constant
        series.append("0, 1, 1")
        // Then we calculate the Fibonacci of each element
        // and add append it to the list
        for (i <- 2 to n) {
            if (i < n)
                series.append(", ")
            else
                series.append(" = ")
            
            series.append(fibonacci(i))
        }
        // return the list as a string
        series.toString
    }

    def factorial(n:Int):BigInt = {
        if(n==1)
            BigInt(1)
        else
            BigInt(n) * factorial(n - 1)
    }

    def fibonacci(n:Int):Long = {
        if (n < 2)
            1  
        else  
            fibonacci(n - 1) + fibonacci(n - 2)  
    }
}

object FiborialProgram {
    def main(args:Array[String]) {
        // Printing Factorial Series  
        println("")
        println(Fiborial.getFactorialSeries(5))
        println(Fiborial.getFactorialSeries(7))  
        println(Fiborial.getFactorialSeries(9))  
        println(Fiborial.getFactorialSeries(11))  
        println(Fiborial.getFactorialSeries(40))  
        // Printing Fibonacci Series  
        println("")  
        println(Fiborial.getFibonnaciSeries(5))  
        println(Fiborial.getFibonnaciSeries(7))  
        println(Fiborial.getFibonnaciSeries(9))  
        println(Fiborial.getFibonnaciSeries(11))  
        println(Fiborial.getFibonnaciSeries(40))  
    }
}

And the Output is:

Mixing Instance and Static Members in the same Class

There are no static classes in Scala, instead you can define an object which in fact is an instance singleton class that can be used as a static class. It is possible to mix 'static' and instance members into the same class. You do that by creating a class (instance members) and an object ('static' members)

package com.series
// To mix Instance and 'Static' methods in Scala you define a Class (instance)   
// and and object (static) with the same Name  
  
// Instance Class  
class Fiborial(init:Int) {  
    // Instance Field  
    private var _instanceCount:Int = init  
    // Instance Read-Only Getter  
    def InstanceCount = _instanceCount  
    // Instance Constructor  
    def this() = {  
        this(0)  
        println(s"\nInstance Constructor ${_instanceCount}")  
    }      
    // Instance Method   
    def factorial(n:Int) = {  
        _instanceCount += 1      
        println(s"\nFactorial($n)")  
    }  
}  
// 'Static' Class  
object Fiborial {  
    // 'Static' Field  
    private var _staticCount:Int = 0  
    // Instance Read-Only Getter  
    def StaticCount = _staticCount  
    // 'Static' Constructor/Initializer  
    println(s"\nStatic Constructor ${_staticCount}")  
    // 'Static' Method   
    def fibonacci(n:Int) = {  
        _staticCount += 1      
        println(s"\nFactorial($n)")  
    }  
}  
  
object Program {  
    def main(args: Array[String]) = {  
        // Calling Static Constructor and Methods  
        // No need to instantiate      
        Fiborial.fibonacci(5)                  
    
        // Calling Instance Constructor and Methods      
        // Instance required      
        val fib = new Fiborial      
        fib.factorial(5)    
    
        Fiborial.fibonacci(15)                  
        fib.factorial(5)      
    
        // Calling Instance Constructor and Methods      
        // for a second object      
        val fib2 = new Fiborial      
        fib2.factorial(5)      
              
        println("")  
        // Calling Static Property      
        println(s"Static Count = ${Fiborial.StaticCount}")      
        // Calling Instance Getter of object 1 and 2      
        println(s"Instance 1 Count = ${fib.InstanceCount}")      
        println(s"Instance 2 Count = ${fib2.InstanceCount}")     
    }  
}

And the Output is:

Factorial using scala.Long, scala.Double, scala.math.BigInt

import scala.math.BigInt._
import blog.series.lib.Stopwatch

object Program {

    def main(args: Array[String]): Unit = {
        val timer = new Stopwatch()  
        var facLngResult:Long = 0  
        var facDblResult:Double = 0  
        var facBigResult:BigInt = BigInt(0)  
            
        println("\nFactorial using Long")    
        // Benchmark Factorial using Long  
        for(i <- 5 until 55 by 5) {            
            timer.start   
            facLngResult = factorialLong(i)    
            timer.stop  
            println(s" ($i) = ${timer.getElapsed} : $facLngResult")    
        }  
        println("\nFactorial using Double")  
        // Benchmark Factorial using Double    
        for(i <- 5 until 55 by 5) {            
            timer.start    
            facDblResult = factorialDouble(i)    
            timer.stop    
            println(s" ($i) = ${timer.getElapsed} : $facDblResult")  
        }  
        println("\nFactorial using BigInteger")  
        // Benchmark Factorial using BigInteger  
        for(i <- 5 until 55 by 5) {            
            timer.start    
            facBigResult = factorialBigInt(i)    
            timer.stop    
            println(s" ($i) = ${timer.getElapsed} : $facBigResult")  
        }  
    }  
    // Long Factorial   
    def factorialLong(n:Int):Long = {      
        if(n==1)  
            1.toLong  
        else  
            n.toLong * factorialLong(n - 1)  
    }  
    // Double Factorial   
    def factorialDouble(n:Int):Double = {  
        if(n==1)  
            1.toDouble  
        else  
            n.toDouble * factorialDouble(n - 1)  
    }  
    // BigInteger Factorial     
    def factorialBigInt(n:Int):BigInt = {       
        if(n==1)  
            BigInt(1)  
        else  
            BigInt(n) * factorialBigInt(n - 1)  
    }  

}

And the Output is:

Factorial and Fibonacci in Jython

2011-10-02T06:00:00.000-07:00

Here below a little program in Jython that implements 2 classes. There is the main class, called Fiborial (Fibo(nnacci)+(Facto)rial) that implements the Fibonacci and the Factorial algorithms in two ways, one Recursive (using recursion) and the other Imperative (using loops and states). The second class is just an instance class that does the same thing, but its there just to show the difference between static and instance classes, and finally a main function called as module level code.

You can also find 3 more little examples at the bottom. One prints out the Factorial's Series and Fibonacci's Series, the second one just shows a class that mixes both: static and instance members, and finally the third one that uses different return types for the Factorial method to compare the timing and result.

As with the previous posts, you can copy and paste the code below in your favorite IDE/Editor and start playing and learning with it. This little "working" program will teach you some more basics of the Programming Language.

There are some "comments" on the code added just to tell you what are or how are some features called. In case you want to review the theory, you can read my previous post, where I give a definition of each of the concepts mentioned on the code. You can find it here: http://carlosqt.blogspot.com/2011/01/new-series-factorial-and-fibonacci.html

WARNING: the code that you will see below is not following python(ic) guidelines/idiomatic coding, I did it in purpose to compare python's syntax and features side by side with other programming languages... For instance, instead of using a python int or long I imported and used System.Numerics.BigInteger instead. Other examples, naming convention and so on, so bear with me!

I'm using the same Stopwatch java class that I used in the Java version of this post. I just added the .class in the python paths. http://carlosqt.blogspot.com/2011/05/stopwatch-class-for-java.html

The Fiborial Program

# Factorial and Fibonacci in Jython
import java
from java.util import Scanner
from java.math import BigInteger
from java.lang import System 
import Stopwatch

# Instance Class
# static classes are not supported in Python
class StaticFiborial:
    # Static Field
    __className = ''
    # no builtin static constructor/initializer support
    # you can initialize field at this point and even add extra code
    __className = 'Static Initializer'
    print __className
    # Static Method - Factorial Recursive  
    @staticmethod
    def factorialR(n):
        if n == 1:
            return BigInteger.ONE
        else:            
            return BigInteger.valueOf(n).multiply(StaticFiborial.factorialR(n-1))            
    # Static Method - Factorial Imperative
    @staticmethod
    def factorialI(n):
        res = BigInteger.ONE
        for i in range(n, 1, -1):            
            res = res.multiply(BigInteger.valueOf(i))
        return res
    # Static Method - Fibonacci Recursive 
    @staticmethod
    def fibonacciR(n):
        if n < 2:
            return 1
        else:
            return StaticFiborial.fibonacciR(n - 1) + StaticFiborial.fibonacciR(n - 2)
    # Static Method - Fibonacci Imperative
    @staticmethod
    def fibonacciI(n):
        pre, cur, tmp = 0, 0, 0
        pre, cur = 1, 1
        for i in range(2, n + 1):  
            tmp = cur + pre  
            pre = cur  
            cur = tmp  
        return cur 
    # Static Method - Benchmarking Algorithms 
    @staticmethod
    def benchmarkAlgorithm(algorithm, values):
        timer = Stopwatch()
        i = 0  
        testValue = 0  
        facTimeResult = BigInteger.valueOf(0)
        fibTimeResult = 0    
          
        # 'if-elif-else' Flow Control Statement    
        if algorithm == 1:  
            print '\nFactorial Imperative:'  
            # 'For in range' Loop Statement   
            for i in range(len(values)):
                testValue = values[i]  
                # Taking Time    
                timer.start()  
                facTimeResult = StaticFiborial.factorialI(testValue)  
                timer.stop()                            
                # Getting Time    
                print ' (' + str(testValue) + ') = ', timer.elapsed  
        elif algorithm == 2:  
            print '\nFactorial Recursive:'  
            # 'While' Loop Statement  
            while i < len(values):  
                testValue = values[i]  
                # Taking Time    
                timer.start()  
                facTimeResult = StaticFiborial.factorialR(testValue)  
                timer.stop()                            
                # Getting Time    
                print ' (' + str(testValue) + ') = ', timer.elapsed
                i += 1  
        elif algorithm == 3:  
            print '\nFibonacci Imperative:'   
            # 'For in List' Loop Statement               
            for item in values:
                testValue = item  
                # Taking Time  
                timer.start()  
                fibTimeResult = StaticFiborial.fibonacciI(testValue)  
                timer.stop()  
                # Getting Time  
                print ' (' + str(testValue) + ') = ', timer.elapsed                  
        elif algorithm == 4:
            print '\nFibonacci Recursive:'  
            # 'For in List' Loop Statement   
            for item in values:  
                testValue = item  
                # Taking Time  
                timer.start()  
                fibTimeResult = StaticFiborial.fibonacciR(testValue)  
                timer.stop()  
                # Getting Time                
                print ' (' + str(testValue) + ') = ', timer.elapsed
        else:  
            print 'DONG!'

# Instance Class  
class InstanceFiborial(object):
    # Instances Field  
    __className = ''
    # Instance Constructor  
    def __init__(self):  
        self.__className = 'Instance Constructor'
        print self.__className  
    # Instance Method - Factorial Recursive  
    def factorialR(self, n):
        # Calling Static Method  
        return StaticFiborial.factorialR(n)  
    # Instance Method - Factorial Imperative  
    def factorialI(self, n):  
        # Calling Static Method  
        return StaticFiborial.factorialI(n)  
    # Instance Method - Fibonacci Recursive    
    def fibonacciR(self, n):
        # Calling Static Method  
        return StaticFiborial.fibonacciR(n)  
    # Instance Method - Fibonacci Imperative  
    def fibonacciI(self, n):  
        # Calling Static Method  
        return StaticFiborial.fibonacciI(n)  


# Console Program  
def main():
    print 'Static Class'  
    # Calling Static Class and Methods  
    # No instantiation needed. Calling method directly from the class  
    print 'FacImp(5) = ', StaticFiborial.factorialI(5)
    print 'FacRec(5) = ', StaticFiborial.factorialR(5)
    print 'FibImp(11)= ', StaticFiborial.fibonacciI(11)
    print 'FibRec(11)= ', StaticFiborial.fibonacciR(11)
  
    print '\nInstance Class'  
    # Calling Instance Class and Methods  
    # Need to instantiate before using. Calling method from instantiated object  
    ff = InstanceFiborial()
    print 'FacImp(5) = ', ff.factorialI(5)
    print 'FacRec(5) = ', ff.factorialR(5)
    print 'FibImp(11)= ', ff.fibonacciI(11)
    print 'FibRec(11)= ', ff.fibonacciR(11)
  
    # Create a (Python) list of values to test    
    # From 5 to 50 by 5  
    values = []
    for i in range(5,55,5):
        values.append(i)

    # Benchmarking Fibonacci  
    # 1 = Factorial Imperative  
    StaticFiborial.benchmarkAlgorithm(1, values)  
    # 2 = Factorial Recursive  
    StaticFiborial.benchmarkAlgorithm(2, values) 
    # Benchmarking Factorial  
    # 3 = Fibonacci Imperative  
    StaticFiborial.benchmarkAlgorithm(3, values)  
    # 4 = Fibonacci Recursive  
    StaticFiborial.benchmarkAlgorithm(4, values)
    
    # Stop and exit
    sin = Scanner(System.in)    
    line = sin.nextLine()    
    sin.close()
  
if __name__ == '__main__':
    main()

And the Output is:

Humm, looks like Fibonnaci's algorithm implemented using recursion is definitively more complex than the others 3 right? I will grab these results for this and each of the upcoming posts to prepare a comparison of time execution between all the programming languages, then we will be able to talk about the algorithm's complexity as well.

Printing the Factorial and Fibonacci Series

import java
from java.util import Scanner
from java.math import BigInteger
from java.lang import System, StringBuffer

class Fiborial:  
    # Using a StringBuffer as a list of string elements    
    @staticmethod
    def getFactorialSeries(n):
        # Create the String that will hold the list    
        series = StringBuffer()   
        # We begin by concatenating the number you want to calculate    
        # in the following format: "!# ="    
        series.append("!")  
        series.append(n)  
        series.append(" = ")
        # We iterate backwards through the elements of the series    
        for i in range(n, 0, -1):
            # and append it to the list    
            series.append(i)  
            if i > 1:   
                series.append(" * ")    
            else:     
                series.append(" = ")  
        # Get the result from the Factorial Method    
        # and append it to the end of the list    
        series.append(Fiborial.factorial(n).toString())
        # return the list as a string    
        return series.toString()  
  
    # Using a StringBuffer as a list of string elements    
    @staticmethod
    def getFibonnaciSeries(n):  
        # Create the String that will hold the list    
        series = StringBuffer()
        # We begin by concatenating the first 3 values which    
        # are always constant    
        series.append("0, 1, 1")    
        # Then we calculate the Fibonacci of each element    
        # and add append it to the list    
        for i in range(2, n+1):  
            if i < n:  
                series.append(", ")   
            else:  
                series.append(" = ")    
            series.append(Fiborial.fibonacci(i))  
        # return the list as a string    
        return series.toString()  
    @staticmethod      
    def factorial(n):
        if n == 1:
            return BigInteger.ONE
        else:
            return BigInteger.valueOf(n).multiply(Fiborial.factorial(n-1))
    @staticmethod  
    def fibonacci(n):  
        if n < 2:  
            return 1    
        else:    
            return Fiborial.fibonacci(n - 1) + Fiborial.fibonacci(n - 2)  
  
def main():
    # Printing Factorial Series    
    print ""  
    print Fiborial.getFactorialSeries(5)  
    print Fiborial.getFactorialSeries(7)  
    print Fiborial.getFactorialSeries(9)  
    print Fiborial.getFactorialSeries(11)  
    print Fiborial.getFactorialSeries(40)  
    # Printing Fibonacci Series    
    print ""  
    print Fiborial.getFibonnaciSeries(5)  
    print Fiborial.getFibonnaciSeries(7)  
    print Fiborial.getFibonnaciSeries(9)  
    print Fiborial.getFibonnaciSeries(11)  
    print Fiborial.getFibonnaciSeries(40)  
      
    sin = Scanner(System.in)    
    line = sin.nextLine()    
    sin.close()
  
if __name__ == '__main__':
    main()

And the Output is:

Mixing Instance and Static Members in the same Class

Instance classes can contain both, instance and static members such as: fields, properties, constructors, methods, etc.

import java
from java.util import Scanner
from java.lang import System
    
# Instance Class
class Fiborial:
    # Instance Field  
    __instanceCount = 0
    # Static Field      
    __staticCount = 0    
    print "\nStatic Constructor", __staticCount
    # Instance Read-Only Property    
    # Within instance members, you can always use      
    # the "self" reference pointer to access your (instance) members.              
    def getInstanceCount(self):   
        return self.__instanceCount  
    InstanceCount = property(getInstanceCount, None, None)
    # Static Property
    # looks like it is not supported even if the code identify it as such    
    @staticmethod
    def getStaticCount():        
        return Fiborial.__staticCount        
    #StaticCount = property(getStaticCount, None, None)
    # The problem seems to be the use of: property(getStaticCount,..)
    # it requires an instance method and not a static one (Test.getStaticCount)    
    # Instance Constructor    
    def __init__(self):
        self.__instanceCount = 0    
        print "\nInstance Constructor", self.__instanceCount
    # No Static Constructor    
    #@staticmethod
    #def __init__():
    #    Fiborial.__staticCount = 0
    #    print "\nStatic Constructor", Fiborial.__staticCount
    # Instance Method
    def factorial(self, n):
        self.__instanceCount += 1   
        print "\nFactorial(" + str(n) + ")"
    # Static Method
    @staticmethod    
    def fibonacci(n):
        Fiborial.__staticCount += 1  
        print "\nFibonacci(" + str(n) + ")"

def main():
    # Calling Static Constructor and Methods    
    # No need to instantiate    
    Fiborial.fibonacci(5)  
      
    # Calling Instance Constructor and Methods    
    # Instance required    
    fib = Fiborial()    
    fib.factorial(5)  

    Fiborial.fibonacci(15)  
    fib.factorial(5)  
      
    # Calling Instance Constructor and Methods    
    # for a second object    
    fib2 = Fiborial()  
    fib2.factorial(5)  
      
    print ""  
    # Calling Static Property
    # using the static method referenced by the property
    #print "Static Count =", Fiborial.StaticCount
    print "Static Count =", Fiborial.getStaticCount()
    # Calling Instance Property of object 1 and 2    
    print "Instance 1 Count =", fib.InstanceCount
    print "Instance 2 Count =", fib2.InstanceCount
      
    sin = Scanner(System.in)    
    line = sin.nextLine()    
    sin.close()
  
if __name__ == '__main__':
    main()

And the Output is:

Factorial using int, float, java.math.BigInteger

So, it looks like integers in python can hold big integers, so using Jython int/long or java.math.BigInteger is the same so not much to say here.

import java
from java.util import Scanner
from java.math import BigInteger
from java.lang import System 
import Stopwatch

# Int/Long Factorial  
def factorial_int(n):  
    if n == 1:
        return int(1)
    else:  
        return int(n * factorial_int(n - 1))
      
# double/float Factorial
def factorial_float(n):
    if n == 1:
        return float(1.0)
    else:  
        return float(n * factorial_float(n - 1))

# BigInteger Factorial     
def factorial_bigint(n):
    if n == 1:
        return BigInteger.ONE
    else:
        return BigInteger.valueOf(n).multiply(factorial_bigint(n-1))
  
timer = Stopwatch()  
facIntResult = 0
facDblResult = 0.0  
facBigResult = BigInteger.valueOf(0)
i = 0  
      
print "\nFactorial using Int/Long"
# Benchmark Factorial using Int64    

for i in range(5,55,5):  
    timer.start()
    facIntResult = factorial_int(i)
    timer.stop()          
    print " (" + str(i) + ") =", timer.elapsed, " :", facIntResult  
      
print "\nFactorial using Float/Double"  
# Benchmark Factorial using Double  
for i in range(5,55,5):
    timer.start()  
    facDblResult = factorial_float(i)  
    timer.stop()          
    print " (" + str(i) + ") =", timer.elapsed, " :", facDblResult
      
print "\nFactorial using BigInteger"  
# Benchmark Factorial using BigInteger  
for i in range(5,55,5):  
    timer.start()
    facBigResult = factorial_bigint(i)  
    timer.stop()
    print " (" + str(i) + ") =", timer.elapsed, " :", facBigResult    

sin = Scanner(System.in)    
line = sin.nextLine()    
sin.close()

And the Output is:

Factorial and Fibonacci in IronRuby

2011-07-17T09:54:00.000-07:00

Here below a little program in IronRuby that implements 2 classes. There is the main class, called Fiborial (Fibo(nnacci)+(Facto)rial) that implements the Fibonacci and the Factorial algorithms in two ways, one Recursive (using recursion) and the other Imperative (using loops and states). The second class is just an instance class that does the same thing, but its there just to show the difference between static and instance classes, and finally a main function called as module level code.

You can also find 3 more little examples at the bottom. One prints out the Factorial's Series and Fibonacci's Series, the second one just shows a class that mixes both: static and instance members, and finally the third one that uses different return types for the Factorial method to compare the timing and result.

As with the previous posts, you can copy and paste the code below in your favorite IDE/Editor and start playing and learning with it. This little "working" program will teach you some more basics of the Programming Language.

There are some "comments" on the code added just to tell you what are or how are some features called. In case you want to review the theory, you can read my previous post, where I give a definition of each of the concepts mentioned on the code. You can find it here: http://carlosqt.blogspot.com/2011/01/new-series-factorial-and-fibonacci.html

WARNING: the code that you will see below is not following ruby guidelines/idiomatic coding, I did it in purpose to compare ruby's syntax and features side by side with other programming languages... For instance, instead of using a ruby bignum I imported and used System.Numerics.BigInteger instead. Other examples, naming convention and so on, so bear with me!

The Fiborial Program

# Factorial and Fibonacci in IronRuby
require "mscorlib"  
require "System"
require "System.Numerics"

include System::Collections::Generic
include System::Diagnostics
include System::Numerics
  
module FiborialRb
    # Static Class
    # static classes are not supported in Ruby
    class StaticFiborial
        # Static Field
        @@class_name = ""
        # no builtin static constructor/initializer support  
        # you can initialize field at this point and even add extra code         
        @@class_name = "Static Constructor"
        puts @@class_name
        # Static Method - Factorial Recursive
        def self.factorial_r(n)
            if n < 2
                BigInteger.One
            else
                BigInteger.Multiply(BigInteger.new(n), self.factorial_r(n - 1))                
            end
        end
        # Static Method - Factorial Imperative
        def self.factorial_i(n)
            res = BigInteger.One
            while n > 1
                res = BigInteger.Multiply(res, BigInteger.new(n))
                n -= 1
            end
            res
        end
        # Static Method - Fibonacci Recursive   
        def self.fibonacci_r(n)
            if n < 2
                1
            else
                self.fibonacci_r(n - 1) + self.fibonacci_r(n - 2)
            end
        end
        # Static Method - Fibonacci Imperative
        def self.fibonacci_i(n)
            pre = 1
            cur = 1
            tmp = 0
            for i in 2..n
                tmp = cur + pre
                pre = cur
                cur = tmp
            end
            cur
        end
        # Static Method - Benchmarking Algorithms
        def self.benchmark_algorithm(algorithm, values)
            timer = Stopwatch.new  
            i = 0
            testValue = 0    
            facTimeResult = BigInteger.Zero  
            fibTimeResult = 0           
            # "case/switch" Flow Control Statement
            case algorithm
            when 1
                puts "\nFactorial Imperative:"
                # "For in range" Loop Statement
                for i in 0..values.size - 1 do
                    testValue = values[i]                    
                    # Taking Time
                    timer.Start
                    facTimeResult = self.factorial_i(testValue)    
                    timer.Stop
                    # Getting Time
                    puts " (#{testValue}) = #{timer.Elapsed}"                    
                end
            when 2
                puts "\nFactorial Recursive:"
                # "While" Loop Statement
                while i < values.size do
                    testValue = values[i]
                    # Taking Time
                    timer.Start
                    facTimeResult = self.factorial_r(testValue)    
                    timer.Stop
                    # Getting Time
                    puts " (#{testValue}) = #{timer.Elapsed}"
                    i += 1
                end
            when 3
                puts "\nFibonacci Imperative:"
                # "until" Loop Statement
                until i == values.size do                    
                    testValue = values[i]
                    # Taking Time
                    timer.Start
                    fibTimeResult = self.fibonacci_i(testValue)    
                    timer.Stop
                    # Getting Time
                    puts " (#{testValue}) = #{timer.Elapsed}"
                    i += 1
                end
            when 4
                puts "\nFibonacci Recursive:"
                # "For each?" Statement
                values.each do |testValue|
                    # Taking Time
                    timer.Start
                    fibTimeResult = self.fibonacci_r(testValue)    
                    timer.Stop
                    # Getting Time
                    puts " (#{testValue}) = #{timer.Elapsed}"
                end
            else
                puts "DONG!"
            end
        end
    end
    
    # Instance Class
    class InstanceFiborial
        # Instance Field
        @class_name = ""
        # Instance Constructor/Initializer
        def initialize
            @class_name = "Instance Constructor"
            puts @class_name
        end
        # Instance Method - Factorial Recursive    
        def factorial_r(n)  
            # Calling Static Method    
            StaticFiborial::factorial_r(n)
        end
        # Instance Method - Factorial Imperative    
        def factorial_i(n)
            # Calling Static Method    
            StaticFiborial::factorial_i(n)    
        end
        # Instance Method - Fibonacci Recursive      
        def fibonacci_r(n)
            # Calling Static Method    
            StaticFiborial::fibonacci_r(n)    
        end
        # Instance Method - Fibonacci Imperative    
        def fibonacci_i(n)
            # Calling Static Method    
            StaticFiborial::fibonacci_i(n)
        end
    end
  
    # Console Program  
    puts "Static Class"    
    # Calling Static Class and Methods    
    # No instantiation needed. Calling method directly from the class    
    puts "FacImp(5) = #{StaticFiborial::factorial_i(5)}"
    puts "FacRec(5) = #{StaticFiborial::factorial_r(5)}" 
    puts "FibImp(11)= #{StaticFiborial::fibonacci_i(11)}" 
    puts "FibRec(11)= #{StaticFiborial::fibonacci_r(11)}" 
    
    puts "\nInstance Class"
    # Calling Instance Class and Methods    
    # Need to instantiate before using. Calling method from instantiated object    
    ff = InstanceFiborial.new
    puts "FacImp(5) = #{ff.factorial_i(5)}"
    puts "FacRec(5) = #{ff.factorial_r(5)}"
    puts "FibImp(11)= #{ff.fibonacci_i(11)}"
    puts "FibRec(11)= #{ff.fibonacci_r(11)}"
        
    # Create a (Ruby) list of values to test      
    # From 5 to 50 by 5    
    values = []
    for i in (5..50).step(5)
        values << i
    end

    # Benchmarking Fibonacci    
    # 1 = Factorial Imperative   
    StaticFiborial::benchmark_algorithm(1,values)
     # 2 = Factorial Recursive
    StaticFiborial::benchmark_algorithm(2,values)
    # Benchmarking Factorial    
    # 3 = Fibonacci Imperative 
    StaticFiborial::benchmark_algorithm(3,values)
    # 4 = Fibonacci Recursive 
    StaticFiborial::benchmark_algorithm(4,values)
    
    # Stop and exit  
    puts "Press any key to exit..."  
    gets  
end

And the Output is:

require "mscorlib"  
require "System"
require "System.Numerics"

include System::Text
include System::Numerics
  
module FiborialSeriesRb    
    
    class Fiborial
         # Using a StringBuilder as a list of string elements  
         def self.get_factorial_series(n)
            # Create the String that will hold the list      
            series = StringBuilder.new    
            # We begin by concatenating the number you want to calculate      
            # in the following format: "!# ="      
            series.Append("!")
            series.Append(n)
            series.Append(" = ")
            # We iterate backwards through the elements of the series
            i = n
            while i >= 1
                # and append it to the list      
                series.Append(i)    
                if i > 1     
                    series.Append(" * ")      
                else
                    series.Append(" = ")    
                end
                i -= 1
            end
            # Get the result from the Factorial Method      
            # and append it to the end of the list      
            series.Append(self.factorial(n).to_s)
            # return the list as a string
            series.to_s
         end
         
         # Using a StringBuilder as a list of string elements
         def self.get_fibonnaci_series(n)
            # Create the String that will hold the list      
            series = StringBuilder.new
            # We begin by concatenating the first 3 values which      
            # are always constant
            series.Append("0, 1, 1")      
            # Then we calculate the Fibonacci of each element      
            # and add append it to the list      
            for i in 2..n    
                if i < n    
                    series.Append(", ")     
                else 
                    series.Append(" = ")
                end
                series.Append(self.fibonacci(i))
            end
            # return the list as a string      
            series.to_s  
         end
         
        def self.factorial(n)
            if n < 2
                BigInteger.One
            else
                BigInteger.Multiply(BigInteger.new(n), self.factorial(n - 1))                
            end
        end
        
        def self.fibonacci(n)
            if n < 2
                1
            else
                self.fibonacci(n - 1) + self.fibonacci(n - 2)
            end
        end
    end
    
    # Printing Factorial Series      
    puts ""    
    puts Fiborial::get_factorial_series(5)    
    puts Fiborial::get_factorial_series(7)    
    puts Fiborial::get_factorial_series(9)    
    puts Fiborial::get_factorial_series(11)    
    puts Fiborial::get_factorial_series(40)    
    # Printing Fibonacci Series      
    puts ""    
    puts Fiborial::get_fibonnaci_series(5)    
    puts Fiborial::get_fibonnaci_series(7)    
    puts Fiborial::get_fibonnaci_series(9)    
    puts Fiborial::get_fibonnaci_series(11)    
    puts Fiborial::get_fibonnaci_series(40) 
    
    # Stop and exit  
    puts "Press any key to exit..."  
    gets  
end

And the Output is:

Mixing Instance and Static Members in the same Class Instance classes can contain both, instance and static members such as: fields, properties, constructors, methods, etc.

require "mscorlib"  

# Instance Class  
class Fiborial
    # Instance Field    
    @instance_count = 0
    # Static Field
    @@static_count = 0    
    # Instance Read-Only Getter
    def get_instance_count()     
        @instance_count    
    end    
    # Static Read-Only Getter
    def self.get_static_count()          
        @@static_count
    end    
    # Instance Constructor/Initializer
    def initialize()  
        @instance_count = 0
        puts "\nInstance Constructor #{@instance_count}"
    end
    # No Static Constructor/Initializer
    # You can do a self.initialize() static method, but it will not be called
    #def self.initialize()
    #    @@static_count = 0  
    #    puts "\nStatic Constructor #{@@static_count}"
    # Instance Method
    def factorial(n)  
        @instance_count += 1     
        puts "\nFactorial(#{n.to_s})"
    end
    # Static Method   
    def self.fibonacci(n)
        @@static_count += 1    
        puts "\nFibonacci(#{n.to_s})"
    end        
  
    # Calling Static Constructor and Methods      
    # No need to instantiate      
    Fiborial::fibonacci(5)    
        
    # Calling Instance Constructor and Methods      
    # Instance required      
    fib = Fiborial.new      
    fib.factorial(5)
  
    Fiborial::fibonacci(15)    
    fib.factorial(5)
        
    # Calling Instance Constructor and Methods      
    # for a second object      
    fib2 = Fiborial.new   
    fib2.factorial(5)    
        
    puts ""
    # Calling Static Getter    
    puts "Static Count = #{Fiborial::get_static_count}" 
    # Calling Instance Property of object 1 and 2      
    puts "Instance 1 Count = #{fib.get_instance_count}"
    puts "Instance 2 Count = #{fib2.get_instance_count}"
        
    gets
end

And the Output is:

Factorial using int, float, System.Numerics.BigInteger
So, it looks like integers in python can hold big integers, so using (Iron)Ruby int/long or System.Numerics.BigInteger is the same so not much to say here. NOTE: as with the previous scripts you need to manually add a reference to the System.Numerics.dll assembly to your project or SearchPath + require so you can add it to your code.

require "mscorlib"
require "System"
require "System.Numerics.dll"

include System::Numerics
include System::Diagnostics
    
# Int/Long Factorial    
def factorial_int(n)
    if n == 1
        1.to_i
    else    
        (n * factorial_int(n - 1)).to_i
    end
end
# double/float Factorial
def factorial_float(n)
    if n == 1  
        1.0
    else
        (n * factorial_float(n - 1)).to_f
    end
end
# BigInteger Factorial       
def factorial_bigint(n)
    if n == 1  
        BigInteger.One
    else          
        BigInteger.Multiply(BigInteger.new(n), factorial_bigint(n-1))  
    end
end

timer = Stopwatch.new
facIntResult = 0  
facDblResult = 0.0    
facBigResult = BigInteger.Zero  
i = 0    
        
puts "\nFactorial using Int/Long"
# Benchmark Factorial using Int64      
for i in (5..50).step(5)
    timer.Start 
    facIntResult = factorial_int(i)
    timer.Stop
    puts " (#{i.to_s}) = #{timer.Elapsed} : #{facIntResult}"
end
puts "\nFactorial using Float/Double"
# Benchmark Factorial using Double
for i in (5..50).step(5)
    timer.Start    
    facDblResult = factorial_float(i)    
    timer.Stop
    puts " (#{i.to_s}) = #{timer.Elapsed.to_s} : #{facDblResult.to_s}"
end        
puts "\nFactorial using BigInteger"    
# Benchmark Factorial using BigInteger    
for i in (5..50).step(5)
    timer.Start
    facBigResult = factorial_bigint(i)
    timer.Stop
    puts " (#{i.to_s}) = #{timer.Elapsed.to_s} : #{facBigResult.to_s}"
end

gets

And the Output is:

Factorial and Fibonacci in IronPython

2011-07-11T15:40:00.000-07:00

Here below a little program in IronPython that implements 2 classes. There is the main class, called Fiborial (Fibo(nnacci)+(Facto)rial) that implements the Fibonacci and the Factorial algorithms in two ways, one Recursive (using recursion) and the other Imperative (using loops and states). The second class is just an instance class that does the same thing, but its there just to show the difference between static and instance classes, and finally a main function called as module level code.

You can also find 3 more little examples at the bottom. One prints out the Factorial's Series and Fibonacci's Series, the second one just shows a class that mixes both: static and instance members, and finally the third one that uses different return types for the Factorial method to compare the timing and result.

As with the previous posts, you can copy and paste the code below in your favorite IDE/Editor and start playing and learning with it. This little "working" program will teach you some more basics of the Programming Language.

There are some "comments" on the code added just to tell you what are or how are some features called. In case you want to review the theory, you can read my previous post, where I give a definition of each of the concepts mentioned on the code. You can find it here: http://carlosqt.blogspot.com/2011/01/new-series-factorial-and-fibonacci.html

WARNING: the code that you will see below is not following python(ic) guidelines/idiomatic coding, I did it in purpose to compare python's syntax and features side by side with other programming languages... For instance, instead of using a python int or long I imported and used System.Numerics.BigInteger instead. Other examples, naming convention and so on, so bear with me!

The Fiborial Program

# Factorial and Fibonacci in IronPython
import clr
clr.AddReference('System.Numerics.dll')
from System.Numerics import BigInteger
from System import Console
from System.Diagnostics import Stopwatch

# Instance Class
# static classes are not supported in Python
class StaticFiborial:
    # Static Field
    __className = ''
    # no builtin static constructor/initializer support
    # you can initialize field at this point and even add extra code
    __className = 'Static Initializer'
    print __className
    # Static Method - Factorial Recursive  
    @staticmethod
    def factorialR(n):
        if n == 1:
            return BigInteger.One            
        else:            
            return BigInteger.Multiply(BigInteger(n), StaticFiborial.factorialR(n-1))            
    # Static Method - Factorial Imperative
    @staticmethod
    def factorialI(n):
        res = BigInteger.One        
        for i in range(n, 1, -1):
            res = BigInteger.Multiply(res, BigInteger(i))
        return res
    # Static Method - Fibonacci Recursive 
    @staticmethod
    def fibonacciR(n):
        if n < 2:
            return 1
        else:
            return StaticFiborial.fibonacciR(n - 1) + StaticFiborial.fibonacciR(n - 2)
    # Static Method - Fibonacci Imperative
    @staticmethod
    def fibonacciI(n):
        pre, cur, tmp = 0, 0, 0
        pre, cur = 1, 1
        for i in range(2, n + 1):  
            tmp = cur + pre  
            pre = cur  
            cur = tmp  
        return cur 
    # Static Method - Benchmarking Algorithms 
    @staticmethod
    def benchmarkAlgorithm(algorithm, values):
        timer = Stopwatch()
        i = 0  
        testValue = 0  
        facTimeResult = BigInteger.Zero
        fibTimeResult = 0    
          
        # 'if-elif-else' Flow Control Statement    
        if algorithm == 1:  
            print '\nFactorial Imperative:'  
            # 'For in range' Loop Statement   
            for i in range(values.Count):                  
                testValue = values[i]  
                # Taking Time    
                timer.Start()  
                facTimeResult = StaticFiborial.factorialI(testValue)  
                timer.Stop()                            
                # Getting Time    
                print ' (' + str(testValue) + ') = ', timer.Elapsed  
        elif algorithm == 2:  
            print '\nFactorial Recursive:'  
            # 'While' Loop Statement  
            while i < len(values):  
                testValue = values[i]  
                # Taking Time    
                timer.Start()  
                facTimeResult = StaticFiborial.factorialR(testValue)  
                timer.Stop()                            
                # Getting Time    
                print ' (' + str(testValue) + ') = ', timer.Elapsed
                i += 1  
        elif algorithm == 3:  
            print '\nFibonacci Imperative:'   
            # 'For in List' Loop Statement               
            for item in values:
                testValue = item  
                # Taking Time  
                timer.Start()  
                fibTimeResult = StaticFiborial.fibonacciI(testValue)  
                timer.Stop()  
                # Getting Time  
                print ' (' + str(testValue) + ') = ', timer.Elapsed                  
        elif algorithm == 4:
            print '\nFibonacci Recursive:'  
            # 'For in List' Loop Statement   
            for item in values:  
                testValue = item  
                # Taking Time  
                timer.Start()  
                fibTimeResult = StaticFiborial.fibonacciR(testValue)  
                timer.Stop()  
                # Getting Time                
                print ' (' + str(testValue) + ') = ', timer.Elapsed
        else:  
            print 'DONG!'

# Instance Class  
class InstanceFiborial(object):
    # Instances Field  
    __className = ''
    # Instance Constructor  
    def __init__(self):  
        self.__className = 'Instance Constructor'
        print self.__className  
    # Instance Method - Factorial Recursive  
    def factorialR(self, n):
        # Calling Static Method  
        return StaticFiborial.factorialR(n)  
    # Instance Method - Factorial Imperative  
    def factorialI(self, n):  
        # Calling Static Method  
        return StaticFiborial.factorialI(n)  
    # Instance Method - Fibonacci Recursive    
    def fibonacciR(self, n):
        # Calling Static Method  
        return StaticFiborial.fibonacciR(n)  
    # Instance Method - Fibonacci Imperative  
    def fibonacciI(self, n):  
        # Calling Static Method  
        return StaticFiborial.fibonacciI(n)  


# Console Program  
def main():
    print 'Static Class'  
    # Calling Static Class and Methods  
    # No instantiation needed. Calling method directly from the class  
    print 'FacImp(5) = ', StaticFiborial.factorialI(5)
    print 'FacRec(5) = ', StaticFiborial.factorialR(5)
    print 'FibImp(11)= ', StaticFiborial.fibonacciI(11)
    print 'FibRec(11)= ', StaticFiborial.fibonacciR(11)
  
    print '\nInstance Class'  
    # Calling Instance Class and Methods  
    # Need to instantiate before using. Calling method from instantiated object  
    ff = InstanceFiborial()
    print 'FacImp(5) = ', ff.factorialI(5)
    print 'FacRec(5) = ', ff.factorialR(5)
    print 'FibImp(11)= ', ff.fibonacciI(11)
    print 'FibRec(11)= ', ff.fibonacciR(11)
  
    # Create a (Python) list of values to test    
    # From 5 to 50 by 5  
    values = []
    for i in range(5,55,5):
        values.append(i)

    # Benchmarking Fibonacci  
    # 1 = Factorial Imperative  
    StaticFiborial.benchmarkAlgorithm(1, values)  
    # 2 = Factorial Recursive  
    StaticFiborial.benchmarkAlgorithm(2, values) 
    # Benchmarking Factorial  
    # 3 = Fibonacci Imperative  
    StaticFiborial.benchmarkAlgorithm(3, values)  
    # 4 = Fibonacci Recursive  
    StaticFiborial.benchmarkAlgorithm(4, values)
    
    # Stop and exit
    Console.Read()  
  
if __name__ == '__main__':
    main()

And the Output is:

import clr
clr.AddReference('System.Numerics.dll')
from System.Numerics import BigInteger
from System.Text import StringBuilder
from System import Console

class Fiborial:  
    # Using a StringBuilder as a list of string elements    
    @staticmethod
    def getFactorialSeries(n):
        # Create the String that will hold the list    
        series = StringBuilder()   
        # We begin by concatenating the number you want to calculate    
        # in the following format: "!# ="    
        series.Append("!")  
        series.Append(n)  
        series.Append(" = ")
        # We iterate backwards through the elements of the series    
        for i in range(n, 0, -1):
            # and append it to the list    
            series.Append(i)  
            if i > 1:   
                series.Append(" * ")    
            else:     
                series.Append(" = ")  
        # Get the result from the Factorial Method    
        # and append it to the end of the list    
        series.Append(Fiborial.factorial(n).ToString())
        # return the list as a string    
        return series.ToString()  
  
    # Using a StringBuilder as a list of string elements    
    @staticmethod
    def getFibonnaciSeries(n):  
        # Create the String that will hold the list    
        series = StringBuilder()
        # We begin by concatenating the first 3 values which    
        # are always constant    
        series.Append("0, 1, 1")    
        # Then we calculate the Fibonacci of each element    
        # and add append it to the list    
        for i in range(2, n+1):  
            if i < n:  
                series.Append(", ")   
            else:  
                series.Append(" = ")    
            series.Append(Fiborial.fibonacci(i))  
        # return the list as a string    
        return series.ToString()  
    @staticmethod      
    def factorial(n):
        if n == 1:
            return BigInteger.One
        else:            
            return BigInteger.Multiply(BigInteger(n), Fiborial.factorial(n-1))
    @staticmethod  
    def fibonacci(n):  
        if n < 2:  
            return 1    
        else:    
            return Fiborial.fibonacci(n - 1) + Fiborial.fibonacci(n - 2)  
  
def main():
    # Printing Factorial Series    
    print ""  
    print Fiborial.getFactorialSeries(5)  
    print Fiborial.getFactorialSeries(7)  
    print Fiborial.getFactorialSeries(9)  
    print Fiborial.getFactorialSeries(11)  
    print Fiborial.getFactorialSeries(40)  
    # Printing Fibonacci Series    
    print ""  
    print Fiborial.getFibonnaciSeries(5)  
    print Fiborial.getFibonnaciSeries(7)  
    print Fiborial.getFibonnaciSeries(9)  
    print Fiborial.getFibonnaciSeries(11)  
    print Fiborial.getFibonnaciSeries(40)  
      
    Console.Read()  
  
if __name__ == '__main__':
    main()

And the Output is:

Mixing Instance and Static Members in the same Class

Instance classes can contain both, instance and static members such as: fields, properties, constructors, methods, etc.

from System import Console
    
# Instance Class
class Fiborial:
    # Instance Field  
    __instanceCount = 0
    # Static Field      
    __staticCount = 0    
    print "\nStatic Constructor", __staticCount
    # Instance Read-Only Property    
    # Within instance members, you can always use      
    # the "self" reference pointer to access your (instance) members.              
    def getInstanceCount(self):   
        return self.__instanceCount  
    InstanceCount = property(getInstanceCount, None, None)
    # Static Property
    # looks like it is not supported even if the code identify it as such    
    @staticmethod
    def getStaticCount():        
        return Fiborial.__staticCount        
    #StaticCount = property(getStaticCount, None, None)
    # The problem seems to be the use of: property(getStaticCount,..)
    # it requires an instance method and not a static one (Test.getStaticCount)    
    # Instance Constructor    
    def __init__(self):
        self.__instanceCount = 0    
        print "\nInstance Constructor", self.__instanceCount
    # No Static Constructor    
    #@staticmethod
    #def __init__():
    #    Fiborial.__staticCount = 0
    #    print "\nStatic Constructor", Fiborial.__staticCount
    # Instance Method
    def factorial(self, n):
        self.__instanceCount += 1   
        print "\nFactorial(" + str(n) + ")"
    # Static Method
    @staticmethod    
    def fibonacci(n):
        Fiborial.__staticCount += 1  
        print "\nFibonacci(" + str(n) + ")"

def main():
    # Calling Static Constructor and Methods    
    # No need to instantiate    
    Fiborial.fibonacci(5)  
      
    # Calling Instance Constructor and Methods    
    # Instance required    
    fib = Fiborial()    
    fib.factorial(5)  

    Fiborial.fibonacci(15)  
    fib.factorial(5)  
      
    # Calling Instance Constructor and Methods    
    # for a second object    
    fib2 = Fiborial()  
    fib2.factorial(5)  
      
    print ""  
    # Calling Static Property
    # using the static method referenced by the property
    #print "Static Count =", Fiborial.StaticCount
    print "Static Count =", Fiborial.getStaticCount()
    # Calling Instance Property of object 1 and 2    
    print "Instance 1 Count =", fib.InstanceCount
    print "Instance 2 Count =", fib2.InstanceCount
      
    Console.Read()  
  
if __name__ == '__main__':
    main()

And the Output is:

Factorial using int, float, System.Numerics.BigInteger

So, it looks like integers in python can hold big integers, so using (Iron)Python int/long or System.Numerics.BigInteger is the same so not much to say here.

NOTE: as with the previous scripts you need to manually add a reference to the System.Numerics.dll assembly to your project or SearchPath + clr.AddReference so you can add it to your code.

import clr
clr.AddReference('System.Numerics.dll')
from System.Numerics import BigInteger
from System import Console
from System.Diagnostics import Stopwatch
  
# Int/Long Factorial  
def factorial_int(n):  
    if n == 1:
        return int(1)
    else:  
        return int(n * factorial_int(n - 1))
      
# double/float Factorial
def factorial_float(n):
    if n == 1:
        return float(1.0)
    else:  
        return float(n * factorial_float(n - 1))

# BigInteger Factorial     
def factorial_bigint(n):
    if n == 1:
        return BigInteger.One            
    else:            
        return BigInteger.Multiply(BigInteger(n), factorial_bigint(n-1))
  
timer = Stopwatch()  
facIntResult = 0
facDblResult = 0.0  
facBigResult = BigInteger.Zero
i = 0  
      
print "\nFactorial using Int/Long"
# Benchmark Factorial using Int64    

for i in range(5,55,5):  
    timer.Start()
    facIntResult = factorial_int(i)
    timer.Stop()          
    print " (" + str(i) + ") =", timer.Elapsed, " :", facIntResult  
      
print "\nFactorial using Float/Double"  
# Benchmark Factorial using Double  
for i in range(5,55,5):
    timer.Start()  
    facDblResult = factorial_float(i)  
    timer.Stop()          
    print " (" + str(i) + ") =", timer.Elapsed, " :", facDblResult
      
print "\nFactorial using BigInteger"  
# Benchmark Factorial using BigInteger  
for i in range(5,55,5):  
    timer.Start()
    facBigResult = factorial_bigint(i)  
    timer.Stop()
    print " (" + str(i) + ") =", timer.Elapsed, " :", facBigResult    

Console.Read()

And the Output is:

Factorial and Fibonacci in Cobra

2011-06-02T07:10:00.000-07:00

Here below a little program in Cobra that implements 2 classes (in fact, they are 3). There is the main class, called Fiborial (Fibo(nnacci)+(Facto)rial) that implements the Fibonacci and the Factorial algorithms in two ways, one Recursive (using recursion) and the other Imperative (using loops and states). The second class is just an instance class that does the same thing, but its there just to show the difference between static and instance classes, and finally the third one (which will not appear in other languages) is the Program class which has the static execution method "Main".

You can also find 3 more little examples at the bottom. One prints out the Factorial's Series and Fibonacci's Series, the second one just shows a class that mixes both: static and instance members, and finally the third one that uses different return types (including System.Numerics.BigInteger) for the Factorial method to compare the timing and result.

As with the previous posts, you can copy and paste the code below in your favorite IDE/Editor and start playing and learning with it. This little "working" program will teach you some more basics of the Programming Language.

There are some "comments" on the code added just to tell you what are or how are some features called. In case you want to review the theory, you can read my previous post, where I give a definition of each of the concepts mentioned on the code. You can find it here: http://carlosqt.blogspot.com/2011/01/new-series-factorial-and-fibonacci.html

The Fiborial Program

# Factorial and Fibonacci in Cobra  
use System.Collections.Generic  
use System.Diagnostics  
use System.Numerics  

namespace FiborialCobra
  
    # Static Class
    class StaticFiborial is public
        shared
            # Static Field  
            var __className as String  
            # Static Constructor  
            cue init
                __className = 'Static Constructor'
                print '[__className]'
            # Static Method - Factorial Recursive    
            def factorialR(n as int) as BigInteger is public
                if n == 1 
                    return BigInteger.one
                else                        
                    return BigInteger.multiply(BigInteger(n), .factorialR(n - 1))
            # Static Method - Factorial Imperative    
            def factorialI(n as int) as BigInteger is public                
                res as BigInteger = BigInteger.one
                for i as int in n:0:-1
                    res = BigInteger.multiply(res, BigInteger(i))
                return res
            # Static Method - Fibonacci Recursive    
            def fibonacciR(n as int) as int64 is public
                if n < 2  
                    return 1
                else    
                    return .fibonacciR(n - 1) + .fibonacciR(n - 2)  
            # Static Method - Fibonacci Imperative  
            def fibonacciI(n as int) as int64 is public  
                pre as int64 = 1  
                cur as int64 = 1  
                tmp as int64 = 0  
                for i as int in 2:n+1
                    tmp = cur + pre
                    pre = cur  
                    cur = tmp  
                    i=i # ignore compiler warning
                return cur
            # Static Method - Benchmarking Algorithms  
            def benchmarkAlgorithm(algorithm as int, values as List<of int>) is public  
                timer as Stopwatch = Stopwatch()  
                i as int = 0
                testValue as int = 0  
                facTimeResult as BigInteger = BigInteger.zero                
                fibTimeResult as int64 = 0
                facTimeResult = facTimeResult
                fibTimeResult = fibTimeResult
                
                # "if-elif-else" Flow Control Statement
                if algorithm == 1  
                    print '\nFactorial Imperative:'
                    # "For in range" Loop Statement   
                    for i as int in values.count                  
                        testValue = values[i]
                        # Taking Time    
                        timer.start  
                        facTimeResult = .factorialI(testValue)  
                        timer.stop
                        # Getting Time    
                        print ' ([testValue]) = [timer.elapsed]'
                else if algorithm == 2  
                    print '\nFactorial Recursive:'
                    # "While" Loop Statement  
                    while i < values.count
                        testValue = values[i]  
                        # Taking Time    
                        timer.start
                        facTimeResult = .factorialR(testValue)
                        timer.stop
                        # Getting Time    
                        print ' ([testValue]) = [timer.elapsed]'
                        i += 1  
                else if algorithm == 3
                    print "\nFibonacci Imperative:"   
                    # "Do-While" Loop Statement  
                    post while i < values.count
                        testValue = values[i]  
                        # Taking Time  
                        timer.start
                        fibTimeResult = .fibonacciI(testValue)  
                        timer.stop  
                        # Getting Time  
                        print ' ([testValue]) = [timer.elapsed]'
                        i += 1  
                else if algorithm == 4  
                    print "\nFibonacci Recursive:"  
                    # "For in List" Loop Statement   
                    for i as int in values.count
                        testValue = values[i]
                        # Taking Time  
                        timer.start 
                        fibTimeResult = .fibonacciR(testValue)  
                        timer.stop
                        # Getting Time  
                        print ' ([testValue]) = [timer.elapsed]'
                else  
                    print 'DONG!'

    # Instance Class  
    class InstanceFiborial is public
        # Instances Field  
        var __className as String  
        # Instance Constructor  
        cue init  
            base.init
            __className = "Instance Constructor"  
            print __className  
        # Instance Method - Factorial Recursive  
        def factorialR(n as int) as BigInteger is public 
            # Calling Static Method  
            return StaticFiborial.factorialR(n)  
        # Instance Method - Factorial Imperative  
        def factorialI(n as int) as BigInteger is public 
            # Calling Static Method  
            return StaticFiborial.factorialI(n)  
        # Instance Method - Fibonacci Recursive    
        def fibonacciR(n as int) as int64 is public
            # Calling Static Method  
            return StaticFiborial.fibonacciR(n)  
        # Instance Method - Fibonacci Imperative  
        def fibonacciI(n as int) as int64 is public  
            # Calling Static Method  
            return StaticFiborial.fibonacciI(n)  
                    
    # Console Program  
    class Program is public  
        def main is shared 
            print '\nStatic Class'  
            # Calling Static Class and Methods  
            # No instantiation needed. Calling method directly from the class  
            print 'FacImp(5) = [StaticFiborial.factorialI(5)]'  
            print 'FacRec(5) = [StaticFiborial.factorialR(5)]'  
            print 'FibImp(11)= [StaticFiborial.fibonacciI(11)]'  
            print 'FibRec(11)= [StaticFiborial.fibonacciR(11)]'  
          
            print '\nInstance Class'  
            # Calling Instance Class and Methods  
            # Need to instantiate before using. Call method from instantiated obj  
            ff as InstanceFiborial = InstanceFiborial()
            print 'FacImp(5) = [ff.factorialI(5)]'  
            print 'FacRec(5) = [ff.factorialR(5)]'  
            print 'FibImp(11)= [ff.fibonacciI(11)]'  
            print 'FibRec(11)= [ff.fibonacciR(11)]'  
          
            # Create a List of integer values to test  
            # From 5 to 50 by 5  
            values as List<of int> = List<of int>()  
            for i as int in 5:55:5
                values.add(i)

            # Benchmarking Fibonacci  
            # 1 = Factorial Imperative  
            StaticFiborial.benchmarkAlgorithm(1, values)  
            # 2 = Factorial Recursive  
            StaticFiborial.benchmarkAlgorithm(2, values)  
            # Benchmarking Factorial  
            # 3 = Fibonacci Imperative  
            StaticFiborial.benchmarkAlgorithm(3, values)  
            # 4 = Fibonacci Recursive  
            StaticFiborial.benchmarkAlgorithm(4, values)
          
            # Stop and Exit  
            Console.read

And the Output is:

use System.Text  
use System.Numerics  

namespace FiborialSeries   
    # Instance Class    
    class Fiborial is public
        shared
            # Using a StringBuilder as a list of string elements    
            def getFactorialSeries(n as int) as String is public
                # Create the String that will hold the list    
                series as StringBuilder = StringBuilder()   
                # We begin by concatenating the number you want to calculate    
                # in the following format: '!# ='    
                series.append('!')  
                series.append(n)  
                series.append(' = ')  
                # We iterate backwards through the elements of the series    
                for i as int in n:0:-1  
                    # and append it to the list    
                    series.append(i)  
                    if i > 1   
                        series.append(' * ')    
                    else  
                        series.append(' = ')  
                # Get the result from the Factorial Method    
                # and append it to the end of the list    
                series.append(.factorial(n))  
                # return the list as a string    
                return series.toString 
          
            # Using a StringBuilder as a list of string elements    
            def getFibonnaciSeries(n as int) as String is public
                # Create the String that will hold the list
                series as StringBuilder = StringBuilder()   
                # We begin by concatenating the first 3 values which    
                # are always constant    
                series.append('0, 1, 1')    
                # Then we calculate the Fibonacci of each element    
                # and add append it to the list    
                for i as int in 2:n+1
                    if i < n  
                        series.append(', ')   
                    else
                        series.append(' = ')    
                    series.append(.fibonacci(i))  
                # return the list as a string    
                return series.toString 
                  
            def factorial(n as int) as BigInteger is public
                if n == 1
                    return BigInteger.one
                else
                    return BigInteger.multiply(BigInteger(n), .factorial(n - 1))
              
            def fibonacci(n as int) as int64 is public
                if n < 2
                    return 1    
                else    
                    return .fibonacci(n - 1) + .fibonacci(n - 2)  
      
    # Console Program  
    class Program is public  
        def main is shared 
            # Printing Factorial Series    
            print ''  
            print Fiborial.getFactorialSeries(5)  
            print Fiborial.getFactorialSeries(7)  
            print Fiborial.getFactorialSeries(9)  
            print Fiborial.getFactorialSeries(11)  
            print Fiborial.getFactorialSeries(40)  
            # Printing Fibonacci Series    
            print ''  
            print Fiborial.getFibonnaciSeries(5)  
            print Fiborial.getFibonnaciSeries(7)  
            print Fiborial.getFibonnaciSeries(9)  
            print Fiborial.getFibonnaciSeries(11)  
            print Fiborial.getFibonnaciSeries(40)  
              
            Console.read

And the Output is:

Mixing Instance and Static Members in the same Class

Instance classes can contain both, instance and static members such as: fields, properties, constructors, methods, etc.

namespace FiborialExtrasCobra2  
      
    # Instance Classes can have both: static and instance members.
          
    # Instance Class    
    class Fiborial is public  
        # Instance Field  
        var __instanceCount as int
        # Static Field  
        var __staticCount as int is shared 
        # Instance Read-Only Property            
        pro instanceCount as int is public  
            get  
                return __instanceCount          
        # Static Read-Only Property    
        # Remeber that Properties are Methods to the CLR, so, 
        # you can also define static properties for static fields.             
        pro staticCount as int is shared, public
            get    
                return __staticCount    
        # Instance Constructor    
        cue init
            base.init
            __instanceCount = 0
            print '\nInstance Constructor [__instanceCount]'  
        # Static Constructor    
        cue init is shared        
            __staticCount = 0    
            print '\nStatic Constructor [__staticCount]'
        # Instance Method  
        def factorial(n as int) is public
            __instanceCount += 1   
            print '\nFactorial([n])'   
        # Static Method    
        def fibonacci(n as int) is shared, public
            __staticCount += 1  
            print '\nFibonacci([n])'   
      
    # Console Program  
    class Program is public
        def main is shared     
            # Calling Static Constructor and Methods    
            # No need to instantiate    
            Fiborial.fibonacci(5)  
              
            # Calling Instance Constructor and Methods    
            # Instance required    
            fib as Fiborial = Fiborial()    
            fib.factorial(5)  
              
            Fiborial.fibonacci(15)  
            fib.factorial(5)  
              
            # Calling Instance Constructor and Methods    
            # for a second object    
            fib2 as Fiborial = Fiborial()  
            fib2.factorial(5)  
              
            print ''  
            # Calling Static Property    
            print 'Static Count = [Fiborial.staticCount]'  
            # Calling Instance Property of object 1 and 2    
            print 'Instance 1 Count = [fib.instanceCount]'  
            print 'Instance 2 Count = [fib2.instanceCount]'  
            Console.read

And the Output is:

Factorial using System.Int64, System.Double/Float, System.Numerics.BigInteger

The Factorial of numbers over 20 are massive!
For instance: !40 = 815915283247897734345611269596115894272000000000!
Because of this, the previous version of this program was giving the "wrong" result
!40 = -70609262346240000 when using "long" (System.Int64) type, but it was not until I did the Fiborial version in VB.NET that I realized about this faulty code, because instead of giving me a wrong value, VB.NET, JScript.NET, Boo execution thrown an Overflow Exception when using the "Long/long" (System.Int64) type.

My first idea was to use ulong and ULong, but both failed for "big" numbers. I then used Double (double floating point) type and got no more exception/wrong result. The result of the factorial was now correct !40 = 1.1962222086548E+56, but still I wanted to show the Integer value of it, so I did some research and found that there is a new System.Numerics.BigInteger class in the .NET Framework 4.0. Adding the reference to the project and using this new class as the return type of the Factorial methods, I was able to get the result I was expecting.
!40 = 815915283247897734345611269596115894272000000000

What I also found was that using different types change the time the algorithm takes to finish:
System.Int64 < System.Double < System.Numerics.BigInteger
Almost by double!

To illustrate what I just "tried" to say, lets have a look at the following code and the output we get.

use System.Diagnostics  
use System.Numerics  

namespace FiborialExtrasCobra3  

    class FiborialExtrasProgram 
        shared            

            def main
                timer as Stopwatch = Stopwatch()  
                facIntResult as int64 = 0  
                facDblResult as float = 0  
                facBigResult as BigInteger = BigInteger.zero
                i as int = 0
                  
                print '\nFactorial using Int64'  
                # Benchmark Factorial using Int64                    
                for i as int in 5:55:5  
                    timer.start
                    facIntResult = .factorialInt64(i)  
                    timer.stop         
                    print ' ([i]) = [timer.elapsed] : [facIntResult]'  
                  
                print '\nFactorial using Float'  
                # Benchmark Factorial using float  
                for i as int in 5:55:5  
                    timer.start
                    facDblResult = .factorialFloat(i)  
                    timer.stop         
                    print ' ([i]) = [timer.elapsed] : [facDblResult]'  
                  
                print '\nFactorial using BigInteger'  
                # Benchmark Factorial using BigInteger  
                for i as int in 5:55:5  
                    timer.start
                    facBigResult = .factorialBigInteger(i)  
                    timer.stop         
                    print ' ([i]) = [timer.elapsed] : [facBigResult]'  
                  
                Console.read
                
            # Long Factorial  
            def factorialInt64(n as int) as int64
                if n == 1  
                    return 1  
                else  
                    return n * .factorialInt64(n - 1)  
                  
            # float/Number Factorial     
            def factorialFloat(n as int) as float
                if n == 1  
                    return 1  
                else  
                    return n * .factorialFloat(n - 1)  
               
            # BigInteger Factorial     
            def factorialBigInteger(n as int) as BigInteger   
                if n == 1  
                    return BigInteger.one  
                else  
                    return BigInteger.multiply(BigInteger(n), .factorialBigInteger(n - 1))

NOTE: you need to manually add a reference to the System.Numerics.dll assembly to your project so you can add it to your code.

And the Output is:

Stopwatch class for Java

2011-05-15T15:56:00.001-07:00

In order to continue with my next "Factorial and Fibonacci" posts in some Java/JVM languages; I was looking for an official Java version of the .NET Timer class "Stopwatch" (System.Diagnostics.Stopwatch), so I can measure and display the elapsed time results in the same way I had been doing it in my previous posts.

Let's show some C# code of what I meant before continuing.

using System;
using System.Numerics;
using System.Diagnostics;

namespace CSStopwatchApp
{
    class StopwatchApp
    {
        static void Main(string[] args)
        {
            Stopwatch timer = new Stopwatch();
            timer.Start();
            Fibonacci(50);
            timer.Stop();

            Console.WriteLine("Elapsed time in ticks: {0}", 
                timer.Elapsed.Ticks);
            Console.WriteLine("Elapsed time in milliseconds: {0}", 
                timer.Elapsed.Milliseconds);
            Console.WriteLine("Elapsed time in seconds: {0}", 
                timer.Elapsed.Seconds);
            Console.WriteLine("Elapsed time in minutes: {0}", 
                timer.Elapsed.Minutes);
            Console.WriteLine("Elapsed time in hours: {0}", 
                timer.Elapsed.Hours);
            Console.WriteLine("Elapsed time with format: {0}", 
                timer.Elapsed);
        }
                
        private static BigInteger Fibonacci(int n)
        {
            if (n < 2)
                return 1;
            else
                return Fibonacci(n - 1) + Fibonacci(n - 2);
        }
    }
}

And the result:

However, looks like there isn't one, instead, there are 2 methods used to measure time in Java: System.nanoTime() and System.currentTimeMillis() being the first one more precise when timing code execution.

currentTimeMillis

public static long currentTimeMillis()

Returns the current time in milliseconds. Note that while the unit of time of the return value is a millisecond, the granularity of the value depends on the underlying operating system and may be larger. For example, many operating systems measure time in units of tens of milliseconds.

For example, to measure how long some code takes to execute:

long startTime = System.currentTimeMillis();
   // ... the code being measured ...
   long estimatedTime = System.currentTimeMillis() - startTime;

Returns:
the difference, measured in milliseconds, between the current time and midnight, January 1, 1970 UTC.

nanoTime

public static long nanoTime()

Returns the current value of the most precise available system timer, in nanoseconds.

This method can only be used to measure elapsed time and is not related to any other notion of system or wall-clock time. The value returned represents nanoseconds since some fixed but arbitrary time (perhaps in the future, so values may be negative). This method provides nanosecond precision, but not necessarily nanosecond accuracy. No guarantees are made about how frequently values change. Differences in successive calls that span greater than approximately 292 years (263 nanoseconds) will not accurately compute elapsed time due to numerical overflow.

For example, to measure how long some code takes to execute:

long startTime = System.nanoTime();
   // ... the code being measured ...
   long estimatedTime = System.nanoTime() - startTime;

Returns:
The current value of the system timer, in nanoseconds.

So, I decided to do my own version of the Stopwatch class, not before doing some google to see if someone did it already ;) you know, code reuse FTW!

Quickly I found a basic version using System.currentTimeMillis() written by Corey Goldberg and provided with a GPL license here: http://www.goldb.org/stopwatchjava.html (thanks man!), so I took it and extended it to use System.nanoTime() instead, and implemented some other missing methods and the most important (for me) the Elapsed time formatted as "hh:mm:ss.sss" using the SimpleDateFormat class, which looks like only considers 3 milliseconds... so I added the rest (the nanoseconds part) to have: 00:00:00.0000000 (hh:mm:ss.sssssss), just like the .NET version output it. Here it is:

Stopwatch class in Java

/*
 *  Copyright (c) 2011, Carlos Quintanilla
 *  Special thanks to Corey Goldberg (for his StopWatch.java | Java Timer Class)
 *  here http://www.goldb.org/stopwatchjava.html
 * 
 *  Stopwatch.java is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 */

package stopwatchapp;

import java.text.SimpleDateFormat;
import java.util.Calendar;  

/**
 * @author Carlos Quintanilla
 */

public class Stopwatch {
    // constants
    private final long nsPerTick = 100;
    private final long nsPerMs = 1000000;
    private final long nsPerSs = 1000000000;
    private final long nsPerMm = 60000000000L;
    private final long nsPerHh = 3600000000000L;

    private long startTime = 0;
    private long stopTime = 0;
    private boolean running = false;
    
    /**
     * Starts measuring elapsed time
     * for an interval.
     */
    public void start() {
        this.startTime = System.nanoTime();       
        this.running = true;
    }
    
    /**
     * Stops measuring elapsed time
     * for an interval.
     */
    public void stop() {
        this.stopTime = System.nanoTime();
        this.running = false;
    }
    
    /**
     * Stops time interval measurement 
     * and resets the elapsed time to zero.
     */ 
    public void reset() {
        this.startTime = 0;
        this.stopTime = 0;
        this.running = false;
    }
    
    /**
     * Gets the total elapsed time measured 
     * by the current instance, in nanoseconds.
     * 1 Tick = 100 nanoseconds 
     */
    public long getElapsedTicks() {
        long elapsed;
        if (running) {
             elapsed = (System.nanoTime() - startTime);
        }
        else {
            elapsed = (stopTime - startTime);
        }
        return elapsed / nsPerTick;
    }
    
    /**
     * Gets the total elapsed time measured 
     * by the current instance, in milliseconds.
     * 10000 Ticks = 1 millisecond (1000000 nanoseconds)
     */
    public long getElapsedMilliseconds() {
        long elapsed;
        if (running) {
             elapsed = (System.nanoTime() - startTime);
        }
        else {
            elapsed = (stopTime - startTime);
        }
        return elapsed / nsPerMs;
    }
    
    /**
     * Gets the total elapsed time measured 
     * by the current instance, in seconds.
     * 10000000 Ticks = 1 second (1000 milliseconds)
     */
    public long getElapsedSeconds() {
        long elapsed;
        if (running) {
             elapsed = (System.nanoTime() - startTime);
        }
        else {
            elapsed = (stopTime - startTime);
        }        
        return elapsed / nsPerSs;
    }
    
    /**
     * Gets the total elapsed time measured 
     * by the current instance, in minutes.
     * 600000000 Ticks = 1 minute (60 seconds)
     */
    public long getElapsedMinutes() {
        long elapsed;
        if (running) {
             elapsed = (System.nanoTime() - startTime);
        }
        else {
            elapsed = (stopTime - startTime);
        }        
        return elapsed / nsPerMm;
    }
    
    /**
     * Gets the total elapsed time measured 
     * by the current instance, in hours.
     * 36000000000 Ticks = 1 hour (60 minutes)
     */
    public long getElapsedHours() {
        long elapsed;
        if (running) {
             elapsed = (System.nanoTime() - startTime);
        }
        else {
            elapsed = (stopTime - startTime);
        }        
        return elapsed / nsPerHh;
    }
    
    /**
     * Gets the total elapsed time with format 
     * 00:00:00.0000000 = 00:mm:ss.SSS + 9999 Ticks
     */ 
    public String getElapsed() {
        String timeFormatted = "";
        timeFormatted = this.formatTime(this.getElapsedTicks());        
        return timeFormatted;
    }
    
    /**
     * Gets the total elapsed time with format 
     * 00:00:00.0000000 = 00:mm:ss.SSS + #### Ticks
     * @param elapsedTicks elapsed ticks between start and stop nano time
     */ 
    private String formatTime(final long elapsedTicks) {        
        String formattedTime = "";
        // should be hh:mm:ss.SSS, but 00 starts with 01 
        SimpleDateFormat formatter = new SimpleDateFormat("00:mm:ss.SSS");
        Calendar calendar = Calendar.getInstance();        
        
        if (elapsedTicks <= 9999) {
            calendar.setTimeInMillis(0);
            formattedTime = formatter.format(calendar.getTime()) 
                    + String.valueOf(String.format("%04d", elapsedTicks));
        }
        else {
            calendar.setTimeInMillis(elapsedTicks * nsPerTick / nsPerMs);            
            String formattedTicks = String.format("%07d", elapsedTicks);
            formattedTicks = formattedTicks.substring(formattedTicks.length() - 4);
            formattedTime = formatter.format(calendar.getTime()) + formattedTicks;
        }
        return formattedTime;
    }
}

If we add that class in any Java project, we can now do what the C# code at the beginning of this post does! Let's see the Java version of the code:

package stopwatchapp;
import java.math.BigInteger;

public class StopwatchApp {

    public static void main(String[] args) {
        
        Stopwatch timer = new Stopwatch();
        timer.start();
        Fibonacci(50);
        timer.stop();
        
        System.out.println("Elapsed time in ticks: " 
            + timer.getElapsedTicks());
        System.out.println("Elapsed time in milliseconds: " 
            + timer.getElapsedMilliseconds());
        System.out.println("Elapsed time in seconds: " 
            + timer.getElapsedSeconds());
        System.out.println("Elapsed time in minutes: " 
            + timer.getElapsedMinutes());
        System.out.println("Elapsed time in hours: " 
            + timer.getElapsedHours());
        System.out.println("Elapsed time with format: " 
            + timer.getElapsed());
    }
    
    private static BigInteger Fibonacci(int n)
    {
        if (n < 2)
            return BigInteger.ONE;
        else
            return Fibonacci(n - 1).add(Fibonacci(n - 2));
    }
}

And the Output is:

That's it! now I'm ready to work on the next posts using this java timer class. Hope it is helpful to you too since I found lot's of forums asking for it and the answer was always use: System.nanoTime() and System.currentTimeMillis()

By the way, if you want to run the example, change Fibonacci(50) to a lower value such as Fibonacci(35 or 40) to not wait for the result some minutes.

Factorial and Fibonacci in Java

2011-05-15T15:56:00.000-07:00

Here below a little program in Java that implements 2 classes (in fact, they are 3 + an extra utility Stopwatch class from my previous post http://carlosqt.blogspot.com/2011/05/stopwatch-class-for-java.html). There is the main class, called Fiborial (Fibo(nnacci)+(Facto)rial) that implements the Fibonacci and the Factorial algorithms in two ways, one Recursive (using recursion) and the other Imperative (using loops and states). The second class is just an instance class that does the same thing, but its there just to show the difference between static and instance classes, and finally the third one (which will not appear in other languages) is the Program class which has the static execution method "main".

You can also find 3 more little examples at the bottom. One prints out the Factorial's Series and Fibonacci's Series, the second one just shows a class that mixes both: static and instance members, and finally the third one that uses different return types (including java.math.BigInteger) for the Factorial method to compare the timing and result.

As with the previous posts, you can copy and paste the code below in your favorite IDE/Editor and start playing and learning with it. This little "working" program will teach you some more basics of the Programming Language.

There are some "comments" on the code added just to tell you what are or how are some features called. In case you want to review the theory, you can read my previous post, where I give a definition of each of the concepts mentioned on the code. You can find it here: http://carlosqt.blogspot.com/2011/01/new-series-factorial-and-fibonacci.html

The Fiborial Program

// Factorial and Fibonacci in Java
package fiborial;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;

// Instance Class         
// static is not a class modifier in Java
public class StaticFiborial
{  
    // Static Field  
    private static String className;  
    // Static Constructor/Initializer
    static
    {  
        className = "Static Constructor";  
        System.out.println(className);        
    }  
    // Static Method - Factorial Recursive  
    public static BigInteger factorialR(int n)  
    {  
        if (n == 1)  
            return BigInteger.ONE;
        else  
            return BigInteger.valueOf(n).multiply(factorialR(n - 1));
    }  
    // Static Method - Factorial Imperative  
    public static BigInteger factorialI(int n)  
    {  
        BigInteger res = BigInteger.ONE;  
        for (int i = n; i >= 1; i--)  
        {                  
            res = res.multiply(BigInteger.valueOf(i));  
        }  
        return res;
    }  
    // Static Method - Fibonacci Recursive  
    public static long fibonacciR(int n)  
    {  
        if (n < 2)  
            return 1;  
        else  
            return fibonacciR(n - 1) + fibonacciR(n - 2);  
    }  
    // Static Method - Fibonacci Imperative  
    public static long fibonacciI(int n)  
    {              
        long pre, cur, tmp = 0;  
        pre = cur = 1;              
        for (int i = 2; i <= n; i++)  
        {  
            tmp = cur + pre;  
            pre = cur;  
            cur = tmp;  
        }  
        return cur;  
    }      
    // Static Method - Benchmarking Algorithms  
    public static void benchmarkAlgorithm(int algorithm, List<Integer> values)  
    {              
        Stopwatch timer = new Stopwatch();  
        int i, testValue;  
        BigInteger facTimeResult = BigInteger.valueOf(0);  
        long fibTimeResult = 0;  
        i = testValue = 0;              
          
        // "Switch" Flow Control Statement  
        switch (algorithm)  
        {  
            case 1:  
                System.out.println("\nFactorial Imperative:");  
                // "For" Loop Statement  
                for (i = 0; i < values.size(); i++)  
                {                          
                    testValue = ((Integer)values.get(i)).intValue();  
                    // Taking Time  
                    timer.start();  
                    facTimeResult = factorialI(testValue);  
                    timer.stop();                          
                    // Getting Time  
                    System.out.println(" (" + testValue + ") = " 
                        + timer.getElapsed());  
                }                      
                break;  
            case 2:  
                System.out.println("\nFactorial Recursive:");  
                // "While" Loop Statement  
                while (i < values.size())  
                {                          
                    testValue = ((Integer)values.get(i)).intValue();  
                    // Taking Time  
                    timer.start();  
                    facTimeResult = factorialR(testValue);  
                    timer.stop();  
                    // Getting Time  
                    System.out.println(" (" + testValue + ") = " 
                        + timer.getElapsed());  
                    i++;  
                }  
                break;  
            case 3:  
                System.out.println("\nFibonacci Imperative:");  
                // "Do-While" Loop Statement  
                do {  
                    testValue = ((Integer)values.get(i)).intValue();  
                    // Taking Time  
                    timer.start();  
                    fibTimeResult = fibonacciI(testValue);  
                    timer.stop();  
                    // Getting Time  
                    System.out.println(" (" + testValue + ") = " 
                        + timer.getElapsed());  
                    i++;  
                } while (i < values.size());  
                break;  
            case 4:  
                System.out.println("\nFibonacci Recursive:");  
                // "For Each" Loop Statement  
                for (Integer item : values)  
                {  
                    testValue = item;  
                    // Taking Time  
                    timer.start();  
                    fibTimeResult = fibonacciR(testValue);  
                    timer.stop();  
                    // Getting Time  
                    System.out.println(" (" + testValue + ") = " 
                        + timer.getElapsed());  
                }  
                break;  
            default:  
                System.out.println("DONG!");  
                break;  
        }                  
    }  
}

package fiborial;
import java.math.BigInteger;
// Instance Class  
public class InstanceFiborial  
{  
    // Instance Field  
    private String className;  
    // Instance Constructor  
    public InstanceFiborial()  
    {  
        this.className = "Instance Constructor";  
        System.out.println(this.className);
    }  
    // Instance Method - Factorial Recursive  
    public BigInteger factorialR(int n)  
    {  
        // Calling Static Method  
        return StaticFiborial.factorialR(n);  
    }  
    // Instance Method - Factorial Imperative  
    public BigInteger factorialI(int n)  
    {  
        // Calling Static Method  
        return StaticFiborial.factorialI(n);  
    }  
    // Instance Method - Fibonacci Recursive  
    public long fibonacciR(int n)  
    {  
        // Calling Static Method  
        return StaticFiborial.fibonacciR(n);  
    }  
    // Instance Method - Factorial Imperative  
    public long fibonacciI(int n)  
    {  
        // Calling Static Method  
        return StaticFiborial.fibonacciI(n);  
    }  
}

package fiborial;
import java.util.Scanner; 
import java.util.ArrayList;
import java.util.List;

public class StaticFiborialProgram 
{
    public static void main(String[] args)
    {
        System.out.println("\nStatic Class");  
        // Calling Static Class and Methods  
        // No instantiation needed. Calling method directly from the class  
        System.out.println("FacImp(5) = " + StaticFiborial.factorialI(5));  
        System.out.println("FacRec(5) = " + StaticFiborial.factorialR(5));  
        System.out.println("FibImp(11)= " + StaticFiborial.fibonacciI(11));  
        System.out.println("FibRec(11)= " + StaticFiborial.fibonacciR(11));  

        System.out.println("\nInstance Class");  
        // Calling Instance Class and Methods   
        // Need to instantiate before using. Calling method from instantiated object  
        InstanceFiborial ff = new InstanceFiborial();  
        System.out.println("FacImp(5) = " + ff.factorialI(5));  
        System.out.println("FacRec(5) = " + ff.factorialR(5));  
        System.out.println("FibImp(11)= " + ff.fibonacciI(11));  
        System.out.println("FibRec(11)= " + ff.fibonacciR(11));  

        // Create a (generic) list of integer values to test  
        // From 5 to 50 by 5  
        List<Integer> values = new ArrayList<Integer>();  
        for(int i = 5; i <= 50; i += 5)  
            values.add(i);  

        // Benchmarking Fibonacci                       
        // 1 = Factorial Imperative              
        StaticFiborial.benchmarkAlgorithm(1, values);  
        // 2 = Factorial Recursive  
        StaticFiborial.benchmarkAlgorithm(2, values);   

        // Benchmarking Factorial              
        // 3 = Fibonacci Imperative  
        StaticFiborial.benchmarkAlgorithm(3, values);  
        // 4 = Fibonacci Recursive  
        StaticFiborial.benchmarkAlgorithm(4, values);   

        // Stop and exit  
        System.out.println("Press any key to exit...");  
        Scanner in = new Scanner(System.in);  
        String line = in.nextLine();  
        in.close();  
    }
}

And the Output is:

Printing the Factorial and Fibonacci Series

package fiborialseries;
import java.math.BigInteger;
import java.lang.StringBuffer;

class Fiborial
{
    // Using a StringBuffer as a list of string elements
    public static String getFactorialSeries(int n)
    {
        // Create the String that will hold the list
        StringBuffer series = new StringBuffer();
        // We begin by concatenating the number you want to calculate
        // in the following format: "!# ="
        series.append("!");
        series.append(n);
        series.append(" = ");
        // We iterate backwards through the elements of the series
        for (int i = n; i <= n && i > 0; i--)
        {
            // and append it to the list
            series.append(i);
            if (i > 1)
                series.append(" * ");
            else 
                series.append(" = "); 
        }
        // Get the result from the Factorial Method
        // and append it to the end of the list
        series.append(factorial(n));
        // return the list as a string
        return series.toString();
    }

    // Using a StringBuffer as a list of string elements
    public static String getFibonnaciSeries(int n)
    {
        // Create the String that will hold the list
        StringBuffer series = new StringBuffer();
        // We begin by concatenating the first 3 values which
        // are always constant
        series.append("0, 1, 1");
        // Then we calculate the Fibonacci of each element
        // and add append it to the list
        for (int i = 2; i <= n; i++)
        {
            if (i < n)
                series.append(", ");
            else
                series.append(" = ");
            
            series.append(fibonacci(i));
        }
        // return the list as a string
        return series.toString();
    }

    public static BigInteger factorial(int n)
    {
        if (n == 1)  
            return BigInteger.ONE;
        else  
            return BigInteger.valueOf(n).multiply(factorial(n - 1));
    }        

    public static long fibonacci(int n)
    {
        if (n < 2)  
            return 1;  
        else  
            return fibonacci(n - 1) + fibonacci(n - 2);  
    }   
}

package fiborialseries;

class FiborialExtrasProgram
{    
    public static void main(String[] args) 
    {            
        // Printing Factorial Series
        System.out.println("");
        System.out.println(Fiborial.getFactorialSeries(5));
        System.out.println(Fiborial.getFactorialSeries(7));
        System.out.println(Fiborial.getFactorialSeries(9));
        System.out.println(Fiborial.getFactorialSeries(11));
        System.out.println(Fiborial.getFactorialSeries(40));
        // Printing Fibonacci Series
        System.out.println("");
        System.out.println(Fiborial.getFibonnaciSeries(5));
        System.out.println(Fiborial.getFibonnaciSeries(7));
        System.out.println(Fiborial.getFibonnaciSeries(9));
        System.out.println(Fiborial.getFibonnaciSeries(11));
        System.out.println(Fiborial.getFibonnaciSeries(40));
    }
}

And the Output is:

Mixing Instance and Static Members in the same Class

Instance classes can contain both, instance and static members such as: fields, getters/setters, constructors/initializers, methods, etc.

package fiborialextrasjava2;

// Instance Class  
class Fiborial  
{  
    // Instance Field  
    private int instanceCount;  
    // Static Field  
    private static int staticCount;          
    // Instance Read-Only Getter  
    // Within instance members, you can always use    
    // the "this" reference pointer to access your (instance) members.  
    public int getInstanceCount()
    {  
        return this.instanceCount;   
    }  
    // Static Read-Only Getter      
    // As with Static Methods, you cannot reference your class members  
    // with the "this" reference pointer since static members are not  
    // instantiated.          
    public static int getStaticCount()
    {  
        return staticCount;  
    }  
    // Instance Constructor  
    public Fiborial()  
    {  
        this.instanceCount = 0;  
        System.out.println("\nInstance Constructor " + this.instanceCount); 
    }  
    // Static Constructor  
    static
    {  
        staticCount = 0;  
        System.out.println("\nStatic Constructor " + staticCount);  
    }  

    // Instance Method  
    public void factorial(int n)  
    {  
        this.instanceCount += 1;  
        System.out.println("\nFactorial(" + n + ")");  
    }  

    // Static Method  
    public static void fibonacci(int n)  
    {  
        staticCount += 1;  
        System.out.println("\nFibonacci(" + n + ")");  
    }                  
}

package fiborialextrasjava2;

class FiborialExtras2Program
{    
    public static void main(String[] args) 
    {            
        // Calling Static Constructor and Methods  
        // No need to instantiate  
        Fiborial.fibonacci(5);              

        // Calling Instance Constructor and Methods  
        // Instance required  
        Fiborial fib = new Fiborial();  
        fib.factorial(5);              

        Fiborial.fibonacci(15);              
        fib.factorial(5);  

        // Calling Instance Constructor and Methods  
        // for a second object  
        Fiborial fib2 = new Fiborial();  
        fib2.factorial(5);  
          
        System.out.println("");
        // Calling Static Property  
        System.out.println("Static Count = " + Fiborial.getStaticCount());  
        // Calling Instance Property of object 1 and 2  
        System.out.println("Instance 1 Count = " + fib.getInstanceCount());  
        System.out.println("Instance 2 Count = " + fib2.getInstanceCount());          
    }
}

And the Output is:

Factorial using java.lang.Long, java.lang.Double, java.math.BigInteger

package fiborialextrasjava3;
import java.math.BigInteger;

class FiborialExtrasProgram
{    
    public static void main(String[] args) 
    {            
        Stopwatch timer = new Stopwatch();  
        long facIntResult = 0;  
        double facDblResult = 0;  
        BigInteger facBigResult = BigInteger.valueOf(0);  

        System.out.println("\nFactorial using Int64");
        // Benchmark Factorial using Int64  
        for (int i = 5; i <= 50; i += 5)  
        {  
            timer.start();  
            facIntResult = factorialInt64(i);  
            timer.stop();  
            System.out.println(" (" + i + ") = " 
                + timer.getElapsed() + " : " + facIntResult);
        }  
        System.out.println("\nFactorial using Double");  
        // Benchmark Factorial using Double  
        for (int i = 5; i <= 50; i += 5)  
        {  
            timer.start();  
            facDblResult = factorialDouble(i);  
            timer.stop();              
            System.out.println(" (" + i + ") = " 
                + timer.getElapsed() + " : " + facDblResult);
        }  
        System.out.println("\nFactorial using BigInteger");  
        // Benchmark Factorial using BigInteger  
        for (int i = 5; i <= 50; i += 5)  
        {  
            timer.start();  
            facBigResult = factorialBigInteger(i);  
            timer.stop();  
            System.out.println(" (" + i + ") = " 
                + timer.getElapsed() + " : " + facBigResult);
        }          
    }
    
    // Long Factorial  
    public static long factorialInt64(int n)  
    {  
        if (n == 1)  
            return 1;
        else  
            return n * factorialInt64(n - 1);
    }
    
    // Double Factorial
    public static double factorialDouble(int n)  
    {  
        if (n == 1)  
            return 1;
        else  
            return n * factorialDouble(n - 1);
    }
    
    // BigInteger Factorial 
    public static BigInteger factorialBigInteger(int n)  
    {  
        if (n == 1)  
            return BigInteger.ONE;
        else  
            return BigInteger.valueOf(n).multiply(factorialBigInteger(n - 1));
    }
}

And the Output is:

Factorial and Fibonacci in Phalanger

2011-04-03T13:27:00.000-07:00

Update 1: using BigInteger Multiply method instead of unsupported custom * Operator.
Update 2: Porting code examples to Phalanger 3 - syntax changes on namespace use.

Here below a little program in Phalanger that implements 2 classes (in fact, they are 3). There is the main class, called Fiborial (Fibo(nnacci)+(Facto)rial) that implements the Fibonacci and the Factorial algorithms in two ways, one Recursive (using recursion) and the other Imperative (using loops and states). The second class is just an instance class that does the same thing, but its there just to show the difference between static and instance classes, and finally the third one (which will not appear in other languages) is the Program class which has the static execution method "Main".

You can also find 3 more little examples at the bottom. One prints out the Factorial's Series and Fibonacci's Series, the second one just shows a class that mixes both: static and instance members, and finally the third one that uses different return types (including System.Numerics.BigInteger) for the Factorial method to compare the timing and result.

As with the previous posts, you can copy and paste the code below in your favorite IDE/Editor and start playing and learning with it. This little "working" program will teach you some more basics of the Programming Language.

There are some "comments" on the code added just to tell you what are or how are some features called. In case you want to review the theory, you can read my previous post, where I give a definition of each of the concepts mentioned on the code. You can find it here: http://carlosqt.blogspot.com/2011/01/new-series-factorial-and-fibonacci.html

The Fiborial Program

<?php      
# Factorial and Fibonacci in Phalanger        
namespace FiborialPhp;

use System;
use System\Collections\Generic as G;
use System\Diagnostics as D;
use System\Numerics as N;

# Instance Class           
# static is not a class modifier in PHP    
[\Export]
class StaticFiborial    
{      
    # Static Field     
    private static $className;    
    # no available static __constructor support    
    # Static Initializer Method instead, but need to be explicitly invoked    
    public static function StaticFiborialConstructor()    
    {                
        $className = "Static Constructor";    
        echo $className . "\n";    
    }            
    # Static Method - Factorial Recursive    
    public static function FactorialR(int $n)    
    {      
        if($n == 1)     
            return N\BigInteger::$One;  
        else                    
            return N\BigInteger::Multiply(new N\BigInteger($n), self::FactorialR($n-1));  
    }            
    # Static Method - Factorial Imperative        
    public static function FactorialI(int $n)     
    {                    
        $res = N\BigInteger::$One;
        for ($i = $n; $i >= 1; $i--)  
            $res = N\BigInteger::Multiply($res, new N\BigInteger($i));                  
        return $res;    
    }       
    # Static Method - Fibonacci Recursive        
    public static function FibonacciR(int $n)     
    {        
        if ($n < 2)    
            return 1;        
        else        
            return self::FibonacciR($n - 1) + self::FibonacciR($n - 2);        
    }    
    # Static Method - Fibonacci Imperative        
    public static function FibonacciI(int $n)     
    {    
        $pre = 0; $cur = 0; $tmp = 0;    
        $pre = 1; $cur = 1;    
        for ($i = 2; $i <= $n; $i++)     
        {    
            $tmp = $cur + $pre;        
            $pre = $cur;        
            $cur = $tmp;        
        }        
        return $cur;    
    }    
    # Static Method - Benchmarking Algorithms        
    public static function BenchmarkAlgorithm(int $algorithm, G\List<:int:> $values)     
    {    
        $timer = new D\Stopwatch();    
        $i = 0;     
        $testValue = 0;                
        $facTimeResult = N\BigInteger::$Zero;  
        $fibTimeResult = 0;        
                
        # "Switch" Flow Constrol Statement        
        switch ($algorithm)        
        {        
            case 1:        
                echo "\nFactorial Imperative:\n";    
                # "For" Loop Statement        
                for ($i = 0; $i < $values->Count; $i++)      
                {                                                    
                    $testValue = $values->get_Item($i);    
                    # Taking Time        
                    $timer->Start();        
                    $facTimeResult = self::FactorialI($testValue);        
                    $timer->Stop();                                
                    # Getting Time                              
                    echo " ($testValue) = {$timer->Elapsed->ToString()}\n";    
                }                            
                break;        
            case 2:        
                echo "\nFactorial Recursive:\n";    
                # "While" Loop Statement        
                while ($i < $values->Count)        
                {                                
                    $testValue = $values->get_Item($i);                            
                    # Taking Time        
                    $timer->Start();        
                    $facTimeResult = self::FactorialR($testValue);        
                    $timer->Stop();        
                    # Getting Time        
                    echo " ($testValue) = {$timer->Elapsed->ToString()}\n";    
                    $i++;    
                }    
                break;        
            case 3:        
                echo "\nFibonacci Imperative:\n";    
                # "Do-While" Loop Statement        
                do     
                {        
                    $testValue = $values->get_Item($i);    
                    # Taking Time        
                    $timer->Start();        
                    $fibTimeResult = self::FibonacciI($testValue);        
                    $timer->Stop();        
                    # Getting Time        
                    echo " ($testValue) = {$timer->Elapsed->ToString()}\n";    
                    $i++;        
                } while ($i < $values->Count);                            
                break;        
            case 4:        
                echo "\nFibonacci Recursive:\n";    
                # "ForEach" Loop Statement        
                foreach ($values as $item)        
                {        
                    $testValue = (int)$item;        
                    # Taking Time        
                    $timer->Start();        
                    $fibTimeResult = self::FibonacciR($testValue);    
                    $timer->Stop();        
                    # Getting Time        
                    echo " ($testValue) = {$timer->Elapsed->ToString()}\n";    
                }        
                break;        
            default:        
                echo "DONG!\n";    
                break;    
        }                        
    }        
}    
    
[\Export]     
# Instance Class    
class InstanceFiborial    
{      
    # Instance  Field     
    private $className;    
    # Instance Constructor                            
    function __construct()      
    {      
        $this->className = "Instance Constructor";    
        echo $this->className . "\n";    
    }    
    # Instance Method - Factorial Recursive    
    public function FactorialR(int $n)    
    {      
        # Calling Static Method    
        return StaticFiborial::FactorialR($n);    
    }    
    # Instance Method - Factorial Imperative        
    public function FactorialI(int $n)     
    {        
        # Calling Static Method    
        return StaticFiborial::FactorialI($n);    
    }       
    # Instance Method - Fibonacci Recursive        
    public function FibonacciR(int $n)     
    {        
        # Calling Static Method    
        return StaticFiborial::FibonacciR($n);    
    }    
    # Instance Method - Fibonacci Imperative        
    public function FibonacciI(int $n)     
    {    
        # Calling Static Method    
        return StaticFiborial::FibonacciI($n);    
    }    
}    
    
# Console Program      
class Program      
{      
    public static function Main()      
    {      
        # Static Initializer/Constructor for StaticFiborial Class     
        # explicitly called somewhere in your code ^_^    
        StaticFiborial::StaticFiborialConstructor();    
                
        echo "\nStatic Class\n";    
        # Calling Static Class and Methods      
        # No instantiation needed. Calling method directly from the class      
        echo "FacImp(5) = " . StaticFiborial::FactorialI(5)->ToString() . "\n";    
        echo "FacRec(5) = " . StaticFiborial::FactorialR(5)->ToString() . "\n";    
        echo "FibImp(11)= " . StaticFiborial::FibonacciI(11)->ToString() . "\n";    
        echo "FibRec(11)= " . StaticFiborial::FibonacciR(11)->ToString() . "\n";    
      
        echo "\nInstance Class\n";      
        # Calling Instance Class and Methods      
        # Need to instantiate before using. Calling method from instantiated object      
        $ff = new InstanceFiborial();    
        echo "FacImp(5) = {$ff->FactorialI(5)->ToString()}\n";    
        echo "FacRec(5) = {$ff->FactorialR(5)->ToString()}\n";    
        echo "FibImp(11)= {$ff->FibonacciI(11)->ToString()}\n";    
        echo "FibRec(11)= {$ff->FibonacciR(11)->ToString()}\n";    
                              
        # From 5 to 50 by 5    
        $values = new G\List<:int:>;    
        for($i = 5; $i <= 50; $i += 5)    
            $values->Add($i);    
    
        # Benchmarking Fibonacci      
        # 1 = Factorial Imperative      
        StaticFiborial::BenchmarkAlgorithm(1, $values);    
        # 2 = Factorial Recursive      
        StaticFiborial::BenchmarkAlgorithm(2, $values);    
        # Benchmarking Factorial      
        # 3 = Fibonacci Imperative      
        StaticFiborial::BenchmarkAlgorithm(3, $values);    
        # 4 = Fibonacci Recursive      
        StaticFiborial::BenchmarkAlgorithm(4, $values);    
    
        # Stop and exit      
        echo "Press any key to exit...";      
        fgets(STDIN);
        return 0;      
    }      
}    
 
?>

And the Output is:

Printing the Factorial and Fibonacci Series

<?php        
namespace FiborialSeries;
use System;
use System\Text as T;    
use System\Numerics as N;
      
[\Export]
class Fiborial    
{      
    # Using a StringBuilder as a list of string elements                
    static function GetFactorialSeries(int $n)     
    {            
        # Create the String that will hold the list        
        $series = new T\StringBuilder();        
        # We begin by concatenating the number you want to calculate        
        # in the following format: "!# ="        
        $series->Append("!");        
        $series->Append($n);        
        $series->Append(" = ");        
        # We iterate backwards through the elements of the series        
        for ($i = $n; $i <= $n && $i > 0; $i--)     
        {        
            # and append it to the list        
            $series->Append($i);    
            if ($i > 1)        
                $series->Append(" * ");        
            else         
                $series->Append(" = ");         
        }        
        # Get the result from the Factorial Method        
        # and append it to the end of the list                                        
        # $series->Append(self::Factorial($n)->ToString());    
        # BUT! that throws an exception with big numbers (> fact(30))    
        # Overflow ex "Value was either too large or too small for a Decimal."  
        # because I think it is a bug i used an ugly workaround which is  
        # using the "." in the return.  
        return $series->ToString() . self::Factorial($n)->ToString();  
    }        
        
    # Using a StringBuilder as a list of string elements        
    static function GetFibonnaciSeries(int $n)        
    {        
        # Create the String that will hold the list        
        $series = new T\StringBuilder();    
        # We begin by concatenating the first 3 values which        
        # are always constant        
        $series->Append("0, 1, 1");        
        # Then we calculate the Fibonacci of each element        
        # and add append it to the list        
        for ($i = 2; $i <= $n; $i++)        
        {        
            if ($i < $n)        
                $series->Append(", ");        
            else        
                $series->Append(" = ");        
            
            $series->Append(self::Fibonacci($i));    
        }        
        # return the list as a string        
        return $series->ToString();        
    }        
    
    static function Factorial(int $n)    
    {      
        if($n == 1)     
            return new N\BigInteger(1);  
        else                    
            return N\BigInteger::Multiply(new N\BigInteger($n), self::Factorial($n - 1));  
    }    
            
    static function Fibonacci(int $n)     
    {        
        if ($n < 2)    
            return 1;    
        else        
            return self::Fibonacci($n - 1) + self::Fibonacci($n - 2);        
    }        
}    
    
class Program      
{      
    public static function Main()      
    {      
        # Printing Factorial Series        
        echo "\n";    
        echo Fiborial::GetFactorialSeries(5) . "\n";    
        echo Fiborial::GetFactorialSeries(7) . "\n";    
        echo Fiborial::GetFactorialSeries(9) . "\n";    
        echo Fiborial::GetFactorialSeries(11) . "\n";    
        echo Fiborial::GetFactorialSeries(40) . "\n";      
        # Printing Fibonacci Series  
        echo "\n";    
        echo Fiborial::GetFibonnaciSeries(5) . "\n";    
        echo Fiborial::GetFibonnaciSeries(7) . "\n";    
        echo Fiborial::GetFibonnaciSeries(9) . "\n";    
        echo Fiborial::GetFibonnaciSeries(11) . "\n";    
        echo Fiborial::GetFibonnaciSeries(40) . "\n";    
                 
        fgets(STDIN);
        return 0;      
    }      
}    
?>

And the Output is:

Mixing Instance and Static Members in the same Class

Instance classes can contain both, instance and static members such as: fields, properties, constructors, methods, etc.

<?php    
namespace FiborialExtras2;
use System;

# Instance Class  
[\Export]       
class Fiborial  
{    
    # Instance Field  
    private $instanceCount;  
    # Static Field  
    private static $staticCount;          
    # Instance Read-Only Property/Getter  
    # Within instance members, you can always use    
    # the "this" reference pointer to access your (instance) members.  
    public function getInstanceCount()  
    {  
        return $this->instanceCount;  
    }  
    # Static Read-Only Property/Getter  
    # As with Static Methods, you cannot reference your class members  
    # with the "this" reference pointer since static members are not  
    # instantiated.          
    public static function getStaticCount()  
    {  
        return $staticCount;  
    }  
    # Instance Constructor            
    public function __construct()    
    {    
        $this->instanceCount = 0;  
        echo "\nInstance Constructor {$this->instanceCount}\n";  
    }    
    # Static Constructor  
    public static function FiborialStaticConstructor()  
    {  
        $staticCount = 0;  
        echo "\nStatic Constructor {$staticCount}\n";  
    }      
    # Instance Method  
    public function Factorial(int $n)  
    {    
        $this->instanceCount += 1;  
        echo "\nFactorial({$n})\n";  
    }  
    # Static Method  
    public static function Fibonacci(int $n)   
    {      
        $staticCount += 1;  
        echo "\nFibonacci({$n})\n";  
    }      
}  
  
class Program    
{    
    public static function Main()    
    {    
        # Calling Static Constructor/Initializer and Methods  
        # No need to instantiate  
        Fiborial::FiborialStaticConstructor();  
        Fiborial::Fibonacci(5);              
  
        // Calling Instance Constructor and Methods  
        // Instance required  
        $fib = new Fiborial();  
        $fib->Factorial(5);  
  
        Fiborial::Fibonacci(15);              
        $fib->Factorial(5);  
  
        // Calling Instance Constructor and Methods  
        // for a second object  
        $fib2 = new Fiborial();  
        $fib2->Factorial(5);  
              
        echo "\n";  
        // Calling Static Property  
        echo "Static Count = " . Fiborial::getStaticCount() . "\n";  
        // Calling Instance Property of object 1 and 2  
        echo "Instance 1 Count = {$fib->getInstanceCount()}\n";  
        echo "Instance 2 Count = {$fib2->getInstanceCount()}\n";  
  
        fgets(STDIN);    
        return 0;    
    }    
}  
?>

And the Output is:

Factorial using System.Int64, System.Double, System.Numerics.BigInteger

The Factorial of numbers over 20 are massive!
For instance: !40 = 815915283247897734345611269596115894272000000000!
Because of this, the previous version of this program was giving the "wrong" result
!40 = -70609262346240000 when using "long" (System.Int64) type, but it was not until I did the Fiborial version in VB.NET that I realized about this faulty code, because instead of giving me a wrong value, VB.NET, JScript.NET, Boo execution thrown an Overflow Exception when using the "Long/long" (System.Int64) type.

My first idea was to use ulong and ULong, but both failed for "big" numbers. I then used Double (double floating point) type and got no more exception/wrong result. The result of the factorial was now correct !40 = 1.1962222086548E+56, but still I wanted to show the Integer value of it, so I did some research and found that there is a new System.Numerics.BigInteger class in the .NET Framework 4.0. Adding the reference to the project and using this new class as the return type of the Factorial methods, I was able to get the result I was expecting.
!40 = 815915283247897734345611269596115894272000000000

What I also found was that using different types change the time the algorithm takes to finish:
System.Int64 < System.Double < System.Numerics.BigInteger
Almost by double!

To illustrate what I just "tried" to say, lets have a look at the following code and the output we get.

<?php      
use System\Numerics as N;
use System\Diagnostics as D;      
    
function FactorialInt64(int $n)     
{        
    if ($n == 1)        
        return 1;        
    else        
        return $n * FactorialInt64($n - 1);        
}        
    
function FactorialDouble(int $n)     
{        
    if ($n == 1)        
        return (double)1;        
    else        
        return (double)($n * FactorialDouble($n - 1));    
}    
    
function FactorialBigInteger(int $n)     
{        
    if($n == 1)     
        return N\BigInteger::$One;  
    else                    
        return N\BigInteger::Multiply(new N\BigInteger($n), FactorialBigInteger($n - 1));  
}    
    
class Program    
{    
    public static function Main()      
    {      
            $timer = new D\Stopwatch();    
            $facIntResult = 0;        
            $facDblResult = (double)0;        
            $facBigResult = N\BigInteger::$Zero;     
    
            echo "\nFactorial using Int64\n";        
            // Benchmark Factorial using Int64        
            for ($i = 5; $i <= 50; $i += 5)        
            {        
                $timer->Start();        
                $facIntResult = FactorialInt64($i);        
                $timer->Stop();        
                echo " ({$i}) = {$timer->Elapsed->ToString()} : {$facIntResult}\n";    
            }                    
            echo "\nFactorial using Double\n";        
            // Benchmark Factorial using Double    
            for ($i = 5; $i <= 50; $i += 5)        
            {        
                $timer->Start();        
                $facDblResult = FactorialDouble($i);        
                $timer->Stop();        
                echo " ({$i}) = {$timer->Elapsed->ToString()} : {$facDblResult}\n";    
            }        
            echo "\nFactorial using N\BigInteger\n";    
            // Benchmark Factorial using N\BigInteger                    
            for ($i = 5; $i <= 50; $i += 5)    
            {        
                    
                $timer->Start();        
                $facBigResult = FactorialBigInteger($i);        
                $timer->Stop();        
                echo " ({$i}) = {$timer->Elapsed->ToString()} : {$facBigResult->ToString()}\n";    
            }      
                          
            fgets(STDIN);      
            return 0;      
    }      
}    
?>

NOTE: you need to manually add a reference to the System.Numerics.dll assembly to your project so you can add it to your code.

And the Output is:

Factorial and Fibonacci in Nemerle

2011-03-27T10:14:00.000-07:00

Here below a little program in Nemerle that implements 2 classes (in fact, they are 3). There is the main class, called Fiborial (Fibo(nnacci)+(Facto)rial) that implements the Fibonacci and the Factorial algorithms in two ways, one Recursive (using recursion) and the other Imperative (using loops and states). The second class is just an instance class that does the same thing, but its there just to show the difference between static and instance classes, and finally the third one (which will not appear in other languages) is the Program class which has the static execution method "Main".

You can also find 3 more little examples at the bottom. One prints out the Factorial's Series and Fibonacci's Series, the second one just shows a class that mixes both: static and instance members, and finally the third one that uses different return types (including System.Numerics.BigInteger) for the Factorial method to compare the timing and result.

As with the previous posts, you can copy and paste the code below in your favorite IDE/Editor and start playing and learning with it. This little "working" program will teach you some more basics of the Programming Language.

There are some "comments" on the code added just to tell you what are or how are some features called. In case you want to review the theory, you can read my previous post, where I give a definition of each of the concepts mentioned on the code. You can find it here: http://carlosqt.blogspot.com/2011/01/new-series-factorial-and-fibonacci.html

The Fiborial Program

// Factorial and Fibonacci in Nemerle
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Numerics;
using Nemerle.IO;

namespace FiborialN
{
    // Module = Static Class
    // all members become static by default
    // no need to explicitly use static on members (i did anyway)
    module StaticFiborial
    {
        // Static Field
        static mutable className : string; 
        // Static Constructor
        static this()
        {
            className = "Static Constructor";
            printf("%s", className);
        }
        // Static Method - Factorial Recursive
        public static FactorialR(n : int) : BigInteger
        {            
            if (n == 1)
                 BigInteger(1);
            else 
                 BigInteger(n) * FactorialR(n - 1);
        }
        // Static Method - Factorial Imperative
        public static FactorialI(n : int) : BigInteger
        {
            mutable res : BigInteger = BigInteger(1);
            for (mutable i : int = n; i >= 1; i--)
                res *= i;
            res;
        }
        // Static Method - Fibonacci Recursive
        public static FibonacciR(n : int) : long
        {
            def oneLong : long = 1;
            if (n < 2)
                oneLong;
            else
                FibonacciR(n - 1) + FibonacciR(n - 2);
        }
        // Static Method - Fibonacci Imperative
        public static FibonacciI(n : int) : long
        {            
            mutable pre : long = 1;
            mutable cur : long = 1;
            mutable tmp : long = 0;
            
            for (mutable i : int = 2; i <= n; i++)
            {
                tmp = cur + pre;
                pre = cur;
                cur = tmp;
            }
            cur;
        }
        // Static Method - Benchmarking Algorithms
        public static BenchmarkAlgorithm(algorithm : int, values : list[int]) : void
        {            
            def timer : Stopwatch = Stopwatch();
            mutable i : int = 0;
            mutable testValue : int = 0;
            mutable facTimeResult : BigInteger = BigInteger(0);
            mutable fibTimeResult : long = 0;
           
            // "Switch" Flow Constrol Statement
            match (algorithm)
            {
                | 1 =>
                    printf("\nFactorial Imperative:\n");
                    // "For" Loop Statement
                    for (i = 0; i < values.Length; i++)
                    {
                        testValue = values.Nth(i);
                        // Taking Time
                        timer.Start();
                        facTimeResult = FactorialI(testValue);
                        timer.Stop();                        
                        // Getting Time
                        printf(" (%d) = %s\n", testValue, timer.Elapsed.ToString());
                    }
                | 2 =>
                    printf("\nFactorial Recursive:\n");
                    // 'While' Loop Statement  
                    while (i < values.Length) 
                    {
                        testValue = values.Nth(i);  
                        // Taking Time  
                        timer.Start();  
                        facTimeResult = FactorialR(testValue);  
                        timer.Stop();  
                        // Getting Time  
                        printf(" (%d) = %s\n", testValue, timer.Elapsed.ToString());
                        i++;
                    }
                | 3 =>
                    printf("\nFibonacci Imperative:\n");
                    // 'Do-While' Loop Statement  
                    do {  
                        testValue = values.Nth(i);  
                        // Taking Time 
                        timer.Start();  
                        fibTimeResult = FibonacciI(testValue);  
                        timer.Stop();  
                        // Getting Time  
                        printf(" (%d) = %s\n", testValue, timer.Elapsed.ToString());
                        i++;  
                    } while (i < values.Length);  
                | 4 =>
                    printf("\nFibonacci Recursive:\n");
                    // 'For Each' Loop Statement  
                    foreach (item : int in values) {  
                        testValue = item;
                        // Taking Time  
                        timer.Start();  
                        fibTimeResult = FibonacciR(testValue);  
                        timer.Stop();  
                        // Getting Time  
                        printf(" (%d) = %s\n", testValue, timer.Elapsed.ToString());
                    }  
                | _ => printf("DONG!");
            }                
        }
    }
    
    // Instance Class  
    public class InstanceFiborial 
    {  
        // Instance Field  
        mutable className : String;  
        // Instance Constructor  
        public this() 
        {  
            this.className = "Instance Constructor";  
            printf("%s", this.className);
        }  
        // Instance Method - Factorial Recursive  
        public FactorialR(n : int) : BigInteger 
        {  
            // Calling Static Method  
            StaticFiborial.FactorialR(n);  
        }  
        // Instance Method - Factorial Imperative  
        public FactorialI(n : int) : BigInteger 
        {  
            // Calling Static Method  
            StaticFiborial.FactorialI(n);  
        }  
        // Instance Method - Fibonacci Recursive  
        public FibonacciR(n : int) : long 
        {  
            // Calling Static Method  
            StaticFiborial.FibonacciR(n);  
        }  
        // Instance Method - Factorial Imperative  
        public FibonacciI(n : int) : long 
        {  
            // Calling Static Method  
            StaticFiborial.FibonacciI(n);  
        }  
    }  
    
    module Program
    {
        Main() : void
        {          
            printf("\nStatic Class\n");
            // Calling Static Class and Methods  
            // No instantiation needed. Calling method directly from the class 
            printf("FacImp(5) = %s\n", StaticFiborial.FactorialI(5).ToString());  
            printf("FacRec(5) = %s\n", StaticFiborial.FactorialR(5).ToString());  
            printf("FibImp(11)= %s\n", StaticFiborial.FibonacciI(11).ToString());  
            printf("FibRec(11)= %s\n", StaticFiborial.FibonacciR(11).ToString());  

            printf("\nInstance Class\n");  
            // Calling Instance Class and Methods   
            // Need to instantiate before using. Calling method from instantiated object  
            def ff : InstanceFiborial = InstanceFiborial();  
            printf("FacImp(5) = %s\n", ff.FactorialI(5).ToString());  
            printf("FacRec(5) = %s\n", ff.FactorialR(5).ToString());  
            printf("FibImp(11)= %s\n", ff.FibonacciI(11).ToString());  
            printf("FibRec(11)= %s\n", ff.FibonacciR(11).ToString()); 

            // Create a (nemerle) list of integer values to test
            // From 5 to 50 by 5
            mutable values : list[int] = [];
            foreach (i in $[5,10..50])
                values ::= i;
                    
            // Benchmarking Fibonacci                       
            // 1 = Factorial Imperative              
            StaticFiborial.BenchmarkAlgorithm(1, values.Reverse());
            // 2 = Factorial Recursive  
            StaticFiborial.BenchmarkAlgorithm(2, values.Reverse());

            // Benchmarking Factorial              
            // 3 = Fibonacci Imperative  
            StaticFiborial.BenchmarkAlgorithm(3, values.Reverse());
            // 4 = Fibonacci Recursive  
            StaticFiborial.BenchmarkAlgorithm(4, values.Reverse());        

            // Stop and Exit 
            _ = Console.ReadLine();
        }
    }
}

And the Output is:

using System;  
using System.Text;  
using System.Numerics;
using Nemerle.IO;

namespace FiborialSeries
{
    static class Fiborial
    {
        // Using a StringBuilder as a list of string elements  
        public static GetFactorialSeries(n : int) : string
        {  
            // Create the String that will hold the list  
            def series : StringBuilder = StringBuilder();  
            // We begin by concatenating the number you want to calculate  
            // in the following format: "!# ="  
            _ = series.Append("!");
            _ = series.Append(n);  
            _ = series.Append(" = ");  
            // We iterate backwards through the elements of the series  
            for (mutable i : int = n; i <= n && i > 0; i--)  
            {  
                // and append it to the list  
                _ = series.Append(i);  
                if (i > 1)  
                    _ = series.Append(" * ");  
                else   
                    _ = series.Append(" = ");   
            }  
            // Get the result from the Factorial Method  
            // and append it to the end of the list  
            _ = series.Append(Factorial(n));  
            // return the list as a string  
            series.ToString();  
        }
        // Using a StringBuilder as a list of string elements  
        public static GetFibonnaciSeries(n : int) : string 
        {  
            // Create the String that will hold the list  
            def series : StringBuilder = StringBuilder();  
            // We begin by concatenating the first 3 values which  
            // are always constant  
            _ = series.Append("0, 1, 1");  
            // Then we calculate the Fibonacci of each element  
            // and add append it to the list  
            for (mutable i : int = 2; i <= n; i++)  
            {  
                if (i < n)  
                    _ = series.Append(", ");  
                else  
                    _ = series.Append(" = ");  
                  
                _ = series.Append(Fibonacci(i));  
            }  
            // return the list as a string  
            series.ToString();  
        }  
        // Static Method - Factorial Recursive
        public static Factorial(n : int) : BigInteger
        {            
            if (n == 1)
                 BigInteger(1);
            else 
                 BigInteger(n) * Factorial(n - 1);
        }        
        // Static Method - Fibonacci Recursive
        public static Fibonacci(n : int) : long
        {
            def oneLong : long = 1;
            if (n < 2)
                oneLong;
            else
                Fibonacci(n - 1) + Fibonacci(n - 2);
        }        
    }
        
    module Program
    {
        Main() : void
        {          
            printf("\nStatic Class\n");
            // Printing Factorial Series  
            printf("\n");
            printf("%s\n", Fiborial.GetFactorialSeries(5));
            printf("%s\n", Fiborial.GetFactorialSeries(7));  
            printf("%s\n", Fiborial.GetFactorialSeries(9));  
            printf("%s\n", Fiborial.GetFactorialSeries(11));  
            printf("%s\n", Fiborial.GetFactorialSeries(40));  
            // Printing Fibonacci Series  
            printf("\n");
            printf("%s\n", Fiborial.GetFibonnaciSeries(5));  
            printf("%s\n", Fiborial.GetFibonnaciSeries(7));  
            printf("%s\n", Fiborial.GetFibonnaciSeries(9));  
            printf("%s\n", Fiborial.GetFibonnaciSeries(11));  
            printf("%s\n", Fiborial.GetFibonnaciSeries(40));              
        }
    }
}

And the Output is:

Mixing Instance and Static Members in the same Class

We can also define instance classes that have both, instance and static members such as: fields, properties, constructors, methods, etc. However, we cannot do that if the class is marked as static because of the features mentioned in the previous post:
The main features of a static class are:

They only contain static members.
They cannot be instantiated.
They are sealed.
They cannot contain Instance Constructors

using System;  
namespace FiborialExtrasN2
{
    // Instance Class
    class Fiborial  
    {  
        // Instance Field  
        mutable instanceCount : int;  
        // Static Field  
        static mutable staticCount : int;          
        // Instance Read-Only Property  
        // Within instance members, you can always use    
        // the "this" reference pointer to access your (instance) members.  
        public InstanceCount : int
        {  
            get { this.instanceCount; }  
        }  
        // Static Read-Only Property  
        // Remeber that Properties are Methods to the CLR, so, you can also  
        // define static properties for static fields.   
        // As with Static Methods, you cannot reference your class members  
        // with the "this" reference pointer since static members are not  
        // instantiated.          
        public static StaticCount : int
        {  
            get { staticCount; }  
        }  
        // Instance Constructor  
        public this()  
        {  
            this.instanceCount = 0;  
            Console.WriteLine("\nInstance Constructor {0}", this.instanceCount);  
        }  
        // Static Constructor  
        static this()  
        {  
            staticCount = 0;  
            Console.WriteLine("\nStatic Constructor {0}", staticCount);  
        }  
  
        // Instance Method  
        public Factorial(n : int) : void
        {  
            this.instanceCount += 1;  
            Console.WriteLine("\nFactorial({0})", n);  
        }  
  
        // Static Method  
        public static Fibonacci(n : int) : void
        {  
            staticCount += 1;  
            Console.WriteLine("\nFibonacci({0})", n);  
        }                   
    }
        
    module Program
    {
        Main() : void
        {          
            // Calling Static Constructor and Methods  
            // No need to instantiate  
            Fiborial.Fibonacci(5);              
  
            // Calling Instance Constructor and Methods  
            // Instance required  
            def fib : Fiborial = Fiborial();  
            fib.Factorial(5);              
  
            Fiborial.Fibonacci(15);              
            fib.Factorial(5);  
  
            // Calling Instance Constructor and Methods  
            // for a second object  
            def fib2 : Fiborial = Fiborial();  
            fib2.Factorial(5);  
              
            Console.WriteLine();  
            // Calling Static Property  
            Console.WriteLine("Static Count = {0}", Fiborial.StaticCount);  
            // Calling Instance Property of object 1 and 2  
            Console.WriteLine("Instance 1 Count = {0}", fib.InstanceCount);  
            Console.WriteLine("Instance 2 Count = {0}", fib2.InstanceCount); 
        }
    }
}

And the Output is:

#pragma indent
using System;  
using System.Numerics;  
using System.Diagnostics;  
using System.Console;

namespace FiborialExtrasCs3

    module Program
        // Long Factorial
        public static FactorialInt64(n : int) : long
            def oneLong : long = 1;
            if (n == 1)
                 oneLong;
            else 
                 n * FactorialInt64(n - 1);

        // Double Factorial
        public static FactorialDouble(n : int) : double
            def oneDouble : double = 1;
            if (n == 1)
                oneDouble;
            else 
                 n * FactorialDouble(n - 1);

        // BigInteger Factorial
        public static FactorialBigInteger(n : int) : BigInteger
            if (n == 1)
                 BigInteger(1);
            else 
                 BigInteger(n) * FactorialBigInteger(n - 1);
    
        Main() : void
            def timer : Stopwatch = Stopwatch();  
            mutable facIntResult : long = 0;  
            mutable facDblResult : double = 0;  
            mutable facBigResult : BigInteger = BigInteger(0);
                        
            WriteLine("\nFactorial using Int64");
            // Benchmark Factorial using Int64
            // Overflow Exception!!!
            try
                foreach (i in $[5,10..50])
                    timer.Start();  
                    facIntResult = FactorialInt64(i);  
                    timer.Stop();
                    WriteLine(" ({0}) = {1} : {2}", i, timer.Elapsed, facIntResult);  
            catch
                | ex is OverflowException =>
                    // yummy ^_^  
                    WriteLine("Oops! {0}", ex.Message);
            
            WriteLine("\nFactorial using Double");  
            // Benchmark Factorial using Double  
            foreach (i in $[5,10..50])
                timer.Start();  
                facDblResult = FactorialDouble(i);
                timer.Stop();
                WriteLine(" ({0}) = {1} : {2}", i, timer.Elapsed, facDblResult);  
            
            WriteLine("\nFactorial using BigInteger");  
            // Benchmark Factorial using BigInteger
            foreach (i in $[5,10..50])
                timer.Start();
                facBigResult = FactorialBigInteger(i);
                timer.Stop();
                WriteLine(" ({0}) = {1} : {2}", i, timer.Elapsed, facBigResult);

NOTE: you need to manually add a reference to the System.Numerics.dll assembly to your project so you can add it to your code.

And the Output is: