Carlos Quintanilla's blog

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:

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 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_int(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 FiborialExtrasBoo3  

    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.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  
    // 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 Constrol 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

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" 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. It looks like in Java it also applies, so I'm copying the same I said for the previous posts:

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 which in Java is java.math.BigInteger. Using BigInteger class to calculate the Factorial gave me the results I was expecting.
!40 = 815915283247897734345611269596115894272000000000

What I also found was that using different types change the time the algorithm takes to finish:
Almost by double!

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

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

Updated: using BigInteger Multiply method instead of unsupported custom * Operator.

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    
import namespace System;    
import namespace System:::Collections:::Generic;  
import namespace System:::Diagnostics;  
import namespace System:::Numerics;  
  
namespace FiborialPhp   
{    
    [Export]   
    # Instance Class         
    # static is not a class modifier in PHP  
    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 new BigInteger(1);
            else                  
                return BigInteger::Multiply(new BigInteger($n), self::FactorialR($n-1));
        }          
        # Static Method - Factorial Imperative      
        public static function FactorialI(int $n)   
        {                  
            $res = new BigInteger(1);            
            for ($i = $n; $i >= 1; $i--)
                $res = BigInteger::Multiply($res, new 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, i'List'<:int:> $values)   
        {  
            $timer = new Stopwatch();  
            $i = 0;   
            $testValue = 0;              
            $facTimeResult = new BigInteger(0);
            $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 FiborialPhp:::StaticFiborial::FactorialR($n);  
        }  
        # Instance Method - Factorial Imperative      
        public function FactorialI(int $n)   
        {      
            # Calling Static Method  
            return FiborialPhp:::StaticFiborial::FactorialI($n);  
        }     
        # Instance Method - Fibonacci Recursive      
        public function FibonacciR(int $n)   
        {      
            # Calling Static Method  
            return FiborialPhp:::StaticFiborial::FibonacciR($n);  
        }  
        # Instance Method - Fibonacci Imperative      
        public function FibonacciI(int $n)   
        {  
            # Calling Static Method  
            return FiborialPhp:::StaticFiborial::FibonacciI($n);  
        }  
    }  
  
    # Console Program    
    class Program    
    {    
        public static function Main()    
        {    
            # Static Initializer/Constructor for StaticFiborial Class   
            # explicitly called somewhere in your code ^_^  
            FiborialPhp:::StaticFiborial::StaticFiborialConstructor();  
              
            echo "\nStatic Class\n";  
            # Calling Static Class and Methods    
            # No instantiation needed. Calling method directly from the class    
            echo "FacImp(5) = " . FiborialPhp:::StaticFiborial::FactorialI(5)->ToString() . "\n";  
            echo "FacRec(5) = " . FiborialPhp:::StaticFiborial::FactorialR(5)->ToString() . "\n";  
            echo "FibImp(11)= " . FiborialPhp:::StaticFiborial::FibonacciI(11)->ToString() . "\n";  
            echo "FibRec(11)= " . FiborialPhp:::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 FiborialPhp:::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";  
    
            # PHP/CLR provides syntax of quoted identifiers.   
            # the List class can be referred to by i'List' quoted identifier.  
            # to avoid ambiguity with PHP List keyword  
            # From 5 to 50 by 5  
            $values = new i'List'<:int:>;  
            for($i = 5; $i <= 50; $i += 5)  
                $values->Add($i);  
  
            # Benchmarking Fibonacci    
            # 1 = Factorial Imperative    
            FiborialPhp:::StaticFiborial::BenchmarkAlgorithm(1, $values);  
            # 2 = Factorial Recursive    
            FiborialPhp:::StaticFiborial::BenchmarkAlgorithm(2, $values);  
            # Benchmarking Factorial    
            # 3 = Fibonacci Imperative    
            FiborialPhp:::StaticFiborial::BenchmarkAlgorithm(3, $values);  
            # 4 = Fibonacci Recursive    
            FiborialPhp:::StaticFiborial::BenchmarkAlgorithm(4, $values);  
  
            # Stop and exit    
            echo "Press any key to exit...";    
            fgets(STDIN);    
            return 0;    
        }    
    }  
}  
?>

And the Output is:

<?php    
import namespace System;    
import namespace System:::Text;  
import namespace System:::Numerics;  
  
namespace FiborialSeries  
{    
    [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 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 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 BigInteger(1);
            else                  
                return BigInteger::Multiply(new 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 FiborialSeries:::Fiborial::GetFactorialSeries(5) . "\n";  
            echo FiborialSeries:::Fiborial::GetFactorialSeries(7) . "\n";  
            echo FiborialSeries:::Fiborial::GetFactorialSeries(9) . "\n";  
            echo FiborialSeries:::Fiborial::GetFactorialSeries(11) . "\n";  
            echo FiborialSeries:::Fiborial::GetFactorialSeries(40) . "\n";    
            # Printing Fibonacci Series
            echo "\n";  
            echo FiborialSeries:::Fiborial::GetFibonnaciSeries(5) . "\n";  
            echo FiborialSeries:::Fiborial::GetFibonnaciSeries(7) . "\n";  
            echo FiborialSeries:::Fiborial::GetFibonnaciSeries(9) . "\n";  
            echo FiborialSeries:::Fiborial::GetFibonnaciSeries(11) . "\n";  
            echo FiborialSeries:::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  
import namespace System;  

namespace FiborialExtras2
{  
    # 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
            FiborialExtras2:::Fiborial::FiborialStaticConstructor();
            FiborialExtras2:::Fiborial::Fibonacci(5);            

            // Calling Instance Constructor and Methods
            // Instance required
            $fib = new FiborialExtras2:::Fiborial();
            $fib->Factorial(5);

            FiborialExtras2:::Fiborial::Fibonacci(15);            
            $fib->Factorial(5);

            // Calling Instance Constructor and Methods
            // for a second object
            $fib2 = new FiborialExtras2:::Fiborial();
            $fib2->Factorial(5);
            
            echo "\n";
            // Calling Static Property
            echo "Static Count = " . FiborialExtras2:::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    
import namespace System;    
import namespace System:::Numerics;    
import namespace System:::Diagnostics;    
  
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 new BigInteger(1);
    else                  
        return BigInteger::Multiply(new BigInteger($n), FactorialBigInteger($n - 1));
}  
  
class Program  
{  
    public static function Main()    
    {    
            $timer = new Stopwatch();  
            $facIntResult = 0;      
            $facDblResult = (double)0;      
            $facBigResult = new BigInteger(0);   
  
            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 BigInteger\n";  
            // Benchmark Factorial using 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:

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:

Factorial and Fibonacci in Boo

2011-03-08T15:01:00.000-08:00

Here below a little program in Boo 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 Boo
namespace FiborialBoo
import System
import System.Collections.Generic
import System.Diagnostics
import System.Numerics

// Static Class  
public static class StaticFiborial:
    // Static Field
    private className as string
    // Static Constructor
    def constructor():
        className = "Static Constructor"
        print className
    // Static Method - Factorial Recursive  
    public def FactorialR(n as int) as BigInteger:
        if n == 1:
            return 1  
        else:  
            return n * FactorialR(n - 1)
    // Static Method - Factorial Imperative  
    public def FactorialI(n as int) as BigInteger:
        res as BigInteger = 1
        for i as int in range(n, 1):
            res *= i
        return res
    // Static Method - Fibonacci Recursive  
    public def FibonacciR(n as int) as long:
        if n < 2:
            return 1  
        else:  
            return FibonacciR(n - 1) + FibonacciR(n - 2)
    // Static Method - Fibonacci Imperative
    public def FibonacciI(n as int) as long:
        pre as long = 1
        cur as long = 1
        tmp as long = 0
        for i as int in range(2, n+1):
            tmp = cur + pre
            pre = cur
            cur = tmp
        return cur
    // Static Method - Benchmarking Algorithms
    public def BenchmarkAlgorithm(algorithm as int, values as List[of int]) as void:
        timer as Stopwatch = Stopwatch()
        i as int = 0
        testValue as int = 0
        facTimeResult as BigInteger = 0
        fibTimeResult as long = 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 = FactorialI(testValue)
                timer.Stop()                          
                // Getting Time  
                print " (${testValue}) = ${timer.Elapsed}"
        elif algorithm == 2:
            print "\nFactorial Recursive:"
            // "While" Loop Statement
            while i < len(values):
                testValue = values[i]
                // Taking Time  
                timer.Start()
                facTimeResult = FactorialR(testValue)
                timer.Stop()                          
                // Getting Time  
                print " (${testValue}) = ${timer.Elapsed}"
                i += 1
        elif algorithm == 3:
            print "\nFibonacci Imperative:" 
            // "For in List" Loop Statement             
            for item as int in values:
                testValue = item
                // Taking Time
                timer.Start()
                fibTimeResult = FibonacciI(testValue)
                timer.Stop()
                // Getting Time
                print " (${testValue}) = ${timer.Elapsed}"                
        elif algorithm == 4:
            print "\nFibonacci Recursive:"
            // "For in List" Loop Statement 
            for item as int in values:
                testValue = item
                // Taking Time
                timer.Start()
                fibTimeResult = FibonacciR(testValue)
                timer.Stop()
                // Getting Time
                print " (${testValue}) = ${timer.Elapsed}"
        else:
            print "DONG!"

// Instance Class
public class InstanceFiborial:
    // Instances Field
    private className as string
    // Instance Constructor
    def constructor():
        self.className = "Instance Constructor"
        print self.className
    // Instance Method - Factorial Recursive
    public def FactorialR(n as int) as BigInteger:
        // Calling Static Method
        return StaticFiborial.FactorialR(n)
    // Instance Method - Factorial Imperative
    public def FactorialI(n as int) as BigInteger:
        // Calling Static Method
        return StaticFiborial.FactorialI(n)
    // Instance Method - Fibonacci Recursive  
    public def FibonacciR(n as int) as long:
        // Calling Static Method
        return StaticFiborial.FibonacciR(n)
    // Instance Method - Fibonacci Imperative
    public def FibonacciI(n as int) as long:
        // Calling Static Method
        return StaticFiborial.FibonacciI(n)

public def Main(argv as (string)):
    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. Calling method from instantiated object
    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 (Boo) list of values to test  
    // From 5 to 50 by 5
    values as List[of int] = List[of int]()
    for i as int in range(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.ReadKey(true)

And the Output is:

namespace FiborialSeries
import System
import System.Text
import System.Numerics

// Static Class  
public static class Fiborial:
    // Using a StringBuilder as a list of string elements  
    public def GetFactorialSeries(n as int) as string:  
        // 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 range(n, 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  
    public def GetFibonnaciSeries(n as int) as string:
        // 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 range(2, n+1):
            if i < n:
                series.Append(", ") 
            else:
                series.Append(" = ")  
            series.Append(Fibonacci(i))
        // return the list as a string  
        return series.ToString()
        
    public def Factorial(n as int) as BigInteger:
        if n == 1:
            return 1  
        else:  
            return n * Factorial(n - 1)    
    
    public def Fibonacci(n as int) as long:
        if n < 2:
            return 1  
        else:  
            return Fibonacci(n - 1) + Fibonacci(n - 2)

public def Main(argv as (string)):
    // 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.ReadKey(true)

And the Output is:

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

namespace FiborialExtrasBoo2
import System

// Instance Classes can have both: static and instance members.   
// However, Static Classes only allow static members to be defined.  
// If you declare our next example class as static  
// (static class Fiborial) you will get the following compile error  
// Error: cannot declare instance members in a static class  
    
// Instance Class  
public class Fiborial:
    // Instance Field
    private instanceCount as int
    // Static Field
    private static staticCount as int
    // Instance Read-Only Property  
    // Within instance members, you can always use    
    // the "self" reference pointer to access your (instance) members.            
    public InstanceCount as int:
        get:
            return self.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 "self" reference pointer since static members are not  
    // instantiated.          
    public static StaticCount as int:
        get:  
            return staticCount  
    // Instance Constructor  
    public def constructor():
        self.instanceCount = 0  
        print "\nInstance Constructor ${self.instanceCount}"
    // Static Constructor  
    private static def constructor():
        staticCount = 0  
        print "\nStatic Constructor ${staticCount}"
    // Instance Method
    public def Factorial(n as int) as void: 
        self.instanceCount += 1 
        print "\nFactorial(${n})" 
    // Static Method  
    public static def Fibonacci(n as int) as void: 
        staticCount += 1
        print "\nFibonacci(${n})" 

public def Main(argv as (string)):
    // 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.ReadKey(true)

And the Output is:

namespace FiborialExtrasBoo3
import System
import System.Diagnostics
import System.Numerics

# Long Factorial
def FactorialInt64(n as int) as long:
    if n == 1:
        return 1
    else:
        return n * FactorialInt64(n - 1)
    
# Double/Number Factorial   
def FactorialDouble(n as int) as double:
    if n == 1:
        return 1
    else:
        return n * FactorialDouble(n - 1)
 
# BigInteger Factorial   
def FactorialBigInteger(n as int) as BigInteger:  
    if n == 1:
        return 1
    else:
        return n * FactorialBigInteger(n - 1)

public def Main(argv as (string)):
    timer as Stopwatch = Stopwatch()
    facIntResult as long = 0
    facDblResult as double = 0
    facBigResult as BigInteger = 0  
    i as int = 0
    
    print "\nFactorial using Int64"
    # Benchmark Factorial using Int64  
    # Overflow Exception!!!
    try:
        for i as int in range(5,55,5):
            timer.Start()
            facIntResult = FactorialInt64(i)
            timer.Stop()        
            print " (${i}) = ${timer.Elapsed} : ${facIntResult}"
    except ex as ArithmeticException:
        # yummy ^_^
        print "Oops! ${ex.Message} "
    
    print "\nFactorial using Double"
    # Benchmark Factorial using Double
    for i as int in range(5,55,5):
        timer.Start()
        facDblResult = FactorialDouble(i)
        timer.Stop()        
        print " (${i}) = ${timer.Elapsed} : ${facDblResult}"
    
    print "\nFactorial using BigInteger"
    # Benchmark Factorial using BigInteger
    for i as int in range(5,55,5):
        timer.Start()
        facBigResult = FactorialBigInteger(i)
        timer.Stop()        
        print " (${i}) = ${timer.Elapsed} : ${facBigResult}"
    
    Console.ReadKey(true)

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 F#

2011-03-06T11:02:00.000-08:00

WARNING! I know that F# 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 F# 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

In F# like in VB.NET there is a type called Module. An F# module is a grouping of F# code constructs such as types, values, function values, and code in do bindings. It is implemented as a common language runtime (CLR) class that has only static members. Normally I would only use the Module type as the first example, however, here I included both, an instance class with only Static Members and a second example using Module. The syntax for the members declaration varies so I wanted to include both even if we see a second example in the Mixing Instance and Static members program.

The Fiborial Program (using Type = Instance Class)

// Factorial and Fibonacci in F#
namespace FiborialFs
open System  
open System.Collections.Generic
open System.Diagnostics
open System.Numerics

// Instance Class 
// with all static members 
type StaticFiborial() = class
    // Static Field
    static let mutable className:string = ""
    // Static Constructor/Initializer(s) 
    static do className <- "Static Constructor"    
    static do printfn "%s" className    
    // Static Method - Factorial Recursive
    // in F#: type bigint = BigInteger
    static member public FactorialR(n:int) : bigint =
        if n = 1 then 
            bigint(1)
        else 
            bigint(n) * StaticFiborial.FactorialR(n-1)
    // Static Method - Factorial Imperative
    static member public FactorialI(n:int) : bigint =
        let mutable res:bigint = bigint(1)
        for i = n downto 1 do 
            res <- res * bigint(i)
        res
    // Static Method - Fibonacci Recursive
    static member public FibonacciR(n:int) : int64 =
        if (n < 2) then
            int64(1)
        else  
            StaticFiborial.FibonacciR(n - 1) + StaticFiborial.FibonacciR(n - 2)
    // Static Method - Fibonacci Imperative
    static member public FibonacciI(n:int) : int64 =
        let mutable pre:int64 = int64(1)
        let mutable cur:int64 = int64(1)
        let mutable tmp:int64 = int64(0)
        for i = 2 to n do
            tmp <- cur + pre
            pre <- cur
            cur <- tmp
        cur
    // Static Method - Benchmarking Algorithms
    static member public BenchmarkAlgorithm(algorithm:int, values:list<int>) =
        let timer = new Stopwatch()
        let mutable i:int = 1
        let mutable testValue:int = 1
        let mutable facTimeResult:bigint = bigint(0)
        let mutable fibTimeResult:int64 = int64(0)

        // "if-elif-else" Flow Control Statement
        if algorithm = 1 then
            printfn "\nFactorial Imperative:" 
            // "For to" Loop Statement
            for i = 1 to values.Length - 1 do
                testValue <- values.Item(i)
                // Taking Time  
                timer.Start()
                facTimeResult <- StaticFiborial.FactorialI(testValue)
                timer.Stop()
                // Getting Time  
                printfn " (%s) = %s" (testValue.ToString()) (timer.Elapsed.ToString())

        elif algorithm = 2 then
            printfn "\nFactorial Recursive:" 
            // "While" Loop Statement
            while i < values.Length - 1 do  
                testValue <- values.Item(i)
                // Taking Time  
                timer.Start()
                facTimeResult <- StaticFiborial.FactorialR(testValue)
                timer.Stop()
                // Getting Time  
                printfn " (%s) = %s" (testValue.ToString()) (timer.Elapsed.ToString())
                i <- i + 1

        elif algorithm = 3 then
            printfn "\nFibonacci Imperative:"
            // "For in" Loop Statement
            for item in values do
                testValue <- item
                // Taking Time  
                timer.Start();  
                fibTimeResult <- StaticFiborial.FibonacciI(testValue)
                timer.Stop();  
                // Getting Time  
                printfn " (%s) = %s" (testValue.ToString()) (timer.Elapsed.ToString())

        elif algorithm = 4 then
            printfn "\nFibonacci Recursive:"
            // "For in" Loop Statement
            for item in values do
                testValue <- item
                // Taking Time  
                timer.Start();  
                fibTimeResult <- StaticFiborial.FibonacciR(testValue)
                timer.Stop();  
                // Getting Time  
                printfn " (%s) = %s" (testValue.ToString()) (timer.Elapsed.ToString())

        else 
            printfn "DONG!" 
end 

// Instance Class  
type InstanceFiborial() = class   
        // Instance Field
        let mutable className:string = ""
        // Instance Constructor/Initializer(s) 
        do className <- "Instance Constructor"
        do printfn "%s" className
        // Instance Method - Factorial Recursive  
        member public self.FactorialR(n:int) : bigint =
            // Calling Static Method  
            StaticFiborial.FactorialR(n)  
        // Instance Method - Factorial Imperative  
        member public self.FactorialI(n:int) : bigint =
            // Calling Static Method  
            StaticFiborial.FactorialI(n)  
        // Instance Method - Fibonacci Recursive  
        member public self.FibonacciR(n:int) : int64 =
            // Calling Static Method  
            StaticFiborial.FibonacciR(n)
        // Instance Method - Factorial Imperative  
        member public self.FibonacciI(n:int) : int64 =
            // Calling Static Method  
            StaticFiborial.FibonacciI(n);  
end

module Program = 
    //printfn "%s" (Fiborial.FactorialR(40).ToString())
    printfn "\nStatic Class"
    // Calling Instance Class with Static Methods  
    // No instantiation needed. Calling method directly from the class  
    printfn "FacImp(5) = {%s}" (StaticFiborial.FactorialI(5).ToString())  
    printfn "FacRec(5) = {%s}" (StaticFiborial.FactorialR(5).ToString())  
    printfn "FibImp(11)= {%s}" (StaticFiborial.FibonacciI(11).ToString())  
    printfn "FibRec(11)= {%s}" (StaticFiborial.FibonacciR(11).ToString())  
  
    printfn "\nInstance Class"
    // Calling Instance Class and Methods   
    // Need to instantiate before using. Calling method from instantiated object  
    let ff:InstanceFiborial = new InstanceFiborial()  
    Console.WriteLine("FacImp(5) = {0}", ff.FactorialI(5))  
    Console.WriteLine("FacRec(5) = {0}", ff.FactorialR(5))  
    Console.WriteLine("FibImp(11)= {0}", ff.FibonacciI(11))  
    Console.WriteLine("FibRec(11)= {0}", ff.FibonacciR(11))  
  
    // Create a (generic) list of integer values to test  
    // From 5 to 50 by 5  
    let values = [5..5..50]
    
    // 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  
    let i = Console.Read()

And the Output is:

// Factorial and Fibonacci in F#
namespace FiborialFs
open System  
open System.Collections.Generic
open System.Diagnostics
open System.Numerics

// Static Class 
module StaticFiborial = 
    // Static Field
    let mutable className:string = ""
    // Static Constructor/Initializer(s) 
    do className <- "Static Constructor"    
    do printfn "%s" className    
    // Static Method - Factorial Recursive
    // in F#: type bigint = BigInteger
    let rec FactorialR(n:int) : bigint =
        if n = 1 then 
            bigint(1)
        else 
            bigint(n) * FactorialR(n-1)
    // Static Method - Factorial Imperative
    let public FactorialI(n:int) : bigint =
        let mutable res:bigint = bigint(1)
        for i = n downto 1 do 
            res <- res * bigint(i)
        res
    // Static Method - Fibonacci Recursive
    let rec FibonacciR(n:int) : int64 =
        if (n < 2) then
            int64(1)
        else  
            FibonacciR(n - 1) + FibonacciR(n - 2)
    // Static Method - Fibonacci Imperative
    let public FibonacciI(n:int) : int64 =
        let mutable pre:int64 = int64(1)
        let mutable cur:int64 = int64(1)
        let mutable tmp:int64 = int64(0)
        for i = 2 to n do
            tmp <- cur + pre
            pre <- cur
            cur <- tmp
        cur
    // Static Method - Benchmarking Algorithms
    let public BenchmarkAlgorithm(algorithm:int, values:list<int>) =
        let timer = new Stopwatch()
        let mutable i:int = 1
        let mutable testValue:int = 1
        let mutable facTimeResult:bigint = bigint(0)
        let mutable fibTimeResult:int64 = int64(0)

        // "if-elif-else" Flow Control Statement
        if algorithm = 1 then
            printfn "\nFactorial Imperative:" 
            // "For to" Loop Statement
            for i = 1 to values.Length - 1 do
                testValue <- values.Item(i)
                // Taking Time  
                timer.Start()
                facTimeResult <- FactorialI(testValue)
                timer.Stop()
                // Getting Time  
                printfn " (%s) = %s" (testValue.ToString()) (timer.Elapsed.ToString())

        elif algorithm = 2 then
            printfn "\nFactorial Recursive:" 
            // "While" Loop Statement
            while i < values.Length - 1 do  
                testValue <- values.Item(i)
                // Taking Time  
                timer.Start()
                facTimeResult <- FactorialR(testValue)
                timer.Stop()
                // Getting Time  
                printfn " (%s) = %s" (testValue.ToString()) (timer.Elapsed.ToString())
                i <- i + 1

        elif algorithm = 3 then
            printfn "\nFibonacci Imperative:"
            // "For in" Loop Statement
            for item in values do
                testValue <- item
                // Taking Time  
                timer.Start();  
                fibTimeResult <- FibonacciI(testValue)
                timer.Stop();  
                // Getting Time  
                printfn " (%s) = %s" (testValue.ToString()) (timer.Elapsed.ToString())

        elif algorithm = 4 then
            printfn "\nFibonacci Recursive:"
            // "For in" Loop Statement
            for item in values do
                testValue <- item
                // Taking Time  
                timer.Start();  
                fibTimeResult <- FibonacciR(testValue)
                timer.Stop();  
                // Getting Time  
                printfn " (%s) = %s" (testValue.ToString()) (timer.Elapsed.ToString())

        else 
            printfn "DONG!" 

module Program = 
    //printfn "%s" (Fiborial.FactorialR(40).ToString())
    printfn "\nStatic Class"
    // Calling Instance Class with Static Methods  
    // No instantiation needed. Calling method directly from the class  
    printfn "FacImp(5) = {%s}" (StaticFiborial.FactorialI(5).ToString())  
    printfn "FacRec(5) = {%s}" (StaticFiborial.FactorialR(5).ToString())  
    printfn "FibImp(11)= {%s}" (StaticFiborial.FibonacciI(11).ToString())  
    printfn "FibRec(11)= {%s}" (StaticFiborial.FibonacciR(11).ToString())  

    // Create a (generic) list of integer values to test  
    // From 5 to 50 by 5  
    let values = [5..5..50]
    
    // 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  
    let i = Console.Read()

And the Output is:

Printing the Factorial and Fibonacci Series

// Factorial and Fibonacci in F#
namespace FiborialSeries
open System  
open System.Text
open System.Numerics

// Static Class 
module Fiborial = 
    // We first define the Factorial and Fibonacci methods
    // so we can use them after in the Series methods

    let rec Factorial(n:int) : bigint =
        if n = 1 then 
            bigint(1)
        else 
            bigint(n) * Factorial(n-1)

    let rec Fibonacci(n:int) : int64 =
        if (n < 2) then
            int64(1)
        else  
            Fibonacci(n - 1) + Fibonacci(n - 2)

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

    // Using a StringBuilder as a list of string elements 
    let public GetFibonnaciSeries(n:int): string =
        // Create the String that will hold the list 
        let mutable series:StringBuilder = StringBuilder()
        // We begin by concatenating the first 3 values which  
        // are always constant  
        ignore (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
                ignore (series.Append(", "))
            else
                ignore (series.Append(" = "))
            ignore (series.Append(Fibonacci(i)))
        // return the list as string
        series.ToString()

module Program =
    // Printing Factorial Series  
    printfn ""  
    printfn "%s" (Fiborial.GetFactorialSeries(5))
    printfn "%s" (Fiborial.GetFactorialSeries(7))  
    printfn "%s" (Fiborial.GetFactorialSeries(9))
    printfn "%s" (Fiborial.GetFactorialSeries(11))  
    printfn "%s" (Fiborial.GetFactorialSeries(40))  
    // Printing Fibonacci Series  
    printfn ""  
    printfn "%s" (Fiborial.GetFibonnaciSeries(5))
    printfn "%s" (Fiborial.GetFibonnaciSeries(7))
    printfn "%s" (Fiborial.GetFibonnaciSeries(9))
    printfn "%s" (Fiborial.GetFibonnaciSeries(11))
    printfn "%s" (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 type is a Module because Module = Static Class and remember 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

namespace FiborialExtrasFs2
open System

// Instance Classes can have both: static and instance members.   
// However, Modules (Static Classes) only allow static members to be defined.  

// Instance Class  
type Fiborial() = class
    // Instance Field
    let mutable instanceCount:int = 0
    // Instance Constructor/Initializer(s) 
    do instanceCount <- 0
    do printfn "\nInstance Constructor %s" (instanceCount.ToString())
    // Static Field
    static let mutable staticCount:int = 0
    // Static Constructor/Initializer(s) 
    static do staticCount <- 0
    static do printfn "\nStatic Constructor %s" (Fiborial.StaticCount.ToString())
    //static do printfn "\nInstance Constructor {%s}" (staticCount.ToString())
    // Instance Read-Only Property
    member public this.InstanceCount 
        with get() = instanceCount
    // Static Read-Only Property  
    // Remeber that Properties are Methods to the CLR, so, you can also  
    // define static properties for static fields.   
    static member public StaticCount
        with get() = staticCount
    // Instance Method
    member public this.Factorial(n:int) =
        instanceCount <- instanceCount + 1
        printfn "\nFactorial(%s)" (instanceCount.ToString())
    // Static Method
    static member public Fibonacci(n:int) =
        staticCount <- staticCount + 1
        printfn "\nFibonacci(%s)" (Fiborial.StaticCount.ToString())
end

module Program =
    // Calling Static Constructor and Methods  
    // No need to instantiate  
    Fiborial.Fibonacci(5)
  
    // Calling Instance Constructor and Methods  
    // Instance required  
    let fib:Fiborial = new Fiborial()
    fib.Factorial(5)
  
    Fiborial.Fibonacci(15)
    fib.Factorial(5)
  
    // Calling Instance Constructor and Methods  
    // for a second object  
    let fib2:Fiborial = new Fiborial()
    fib2.Factorial(5);  
              
    printfn ""
    // Calling Static Property  
    printfn "Static Count = %s" (Fiborial.StaticCount.ToString())
    // Calling Instance Property of object 1 and 2  
    printfn "Instance 1 Count = %s" (fib.InstanceCount.ToString())
    printfn "Instance 2 Count = %s" (fib2.InstanceCount.ToString())

And the Output is:

Factorial using System.Int64, System.Double, System.Numerics.BigInteger (bigint)

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 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.

open System
open System.Diagnostics
open System.Numerics

// Long Factorial
let rec FactorialInt64(n:int): int64 =
    match n with
    | 1 -> int64(1)
    | n -> int64(n) * FactorialInt64(n - 1)

// Double Factorial
let rec FactorialDouble(n:int): double =
    match n with
    | 1 -> double(1)
    | n -> double(n) * FactorialDouble(n - 1)

// BigInteger Factorial
let rec FactorialBigInteger(n:int): bigint =
    match n with
    | 1 -> bigint(1)
    | n -> bigint(n) * FactorialBigInteger(n - 1)

let timer:Stopwatch = new Stopwatch()
let mutable facIntResult:int64 = int64(0)
let mutable facDblResult:double = double(0)
let mutable facBigResult:bigint = bigint(0)
let mutable i:int = 0

let values:list<int> = [5..5..50]

printfn "\nFactorial using Int64"
// Benchmark Factorial using Int64
for i in values do
    timer.Start();  
    facIntResult <- FactorialInt64(i)
    timer.Stop(); 
    printfn "(%d) = %s : %s" i (timer.Elapsed.ToString()) (facIntResult.ToString())

printfn "\nFactorial using Double"
// Benchmark Factorial using Double
for i in values do
    timer.Start();  
    facDblResult <- FactorialDouble(i)
    timer.Stop(); 
    printfn "(%d) = %s : %s" i (timer.Elapsed.ToString()) (facDblResult.ToString())

printfn "\nFactorial using BigInteger"
// Benchmark Factorial using Double
for i in values do
    timer.Start();
    facBigResult <- FactorialBigInteger(i)
    timer.Stop(); 
    printfn "(%d) = %s : %s" i (timer.Elapsed.ToString()) (facBigResult.ToString())

NOTE: you DONT need to manually add a reference to the System.Numerics.dll assembly to your project because F# already adds it for you. In fact you don't need to use BigInteger, but bigint which is a type bigint = BigInteger.

And the Output is:

Factorial and Fibonacci in JScript.NET

2011-03-04T09:37:00.000-08:00

Here below a little program in JScript.NET 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 JScript.NET
import System;  
// JScript does not support the use of generics
// import System.Collections.Generic;
import System.Collections;
import System.Diagnostics;
import System.Numerics;
 
package FiborialJs {     
    // Instance Class     
    // static is not a class modifier in JScript
    public class StaticFiborial {
        // Static Field
        static var className : String;
        // Static Initializer (Static Constructor)
        static StaticFiborial {
            className = 'Static Constructor';
            Console.WriteLine(className);            
        }
        // Static Method - Factorial Recursive
        static function FactorialR(n : int) : BigInteger {
            if (n == 1)
                // cannot use return 1 because literal 1 is
                // not a BigNumber and cannot convert! 
                return new BigInteger(1);
            else
                return n * FactorialR(n - 1);
        }
        // Static Method - Factorial Imperative
        static function FactorialI(n : int) : BigInteger {
            // cannot use var res : BigInteger = 1; because 
            // literal 1 is not a BigNumber and cannot convert! 
            var res : BigInteger = new BigInteger(1);
            for (var i : int = n; i >= 1; i--) {
                res *= i;
            }
            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, cur : long, tmp : long = 0;
            pre = cur = 1;            
            for (var i : int = 2; i <= n; i++) {
                tmp = cur + pre;
                pre = cur;
                cur = tmp;
            }
            return cur;
        }
        // Static Method - Benchmarking Algorithms
        static function BenchmarkAlgorithm(algorithm : int, values : ArrayList) {
            var timer : Stopwatch = new Stopwatch;
            var i : int = 0, testValue : int = 0;
            var facTimeResult : BigInteger = new BigInteger(0);
            var fibTimeResult : long = 0;
            
            // 'Switch' Flow Constrol Statement
            switch (algorithm)
            {
                case 1:
                    Console.WriteLine('\nFactorial Imperative:');
                    // 'For' Loop Statement
                    for (i = 0; i < values.Count; i++) {                        
                        testValue = values[i];
                        // Taking Time
                        timer.Start();
                        facTimeResult = FactorialI(testValue);
                        timer.Stop();                        
                        // Getting Time
                        Console.WriteLine(' ({0}) = {1}', testValue, timer.Elapsed);
                    }                    
                    break;
                case 2:
                    Console.WriteLine('\nFactorial Recursive:');
                    // 'While' Loop Statement
                    while (i < values.Count) {                        
                        testValue = values[i];
                        // Taking Time
                        timer.Start();
                        facTimeResult = FactorialR(testValue);
                        timer.Stop();
                        // Getting Time
                        Console.WriteLine(' ({0}) = {1}', testValue, timer.Elapsed);
                        i++;
                    }
                    break;
                case 3:
                    Console.WriteLine('\nFibonacci Imperative:');
                    // 'Do-While' Loop Statement
                    do {
                        testValue = values[i];
                        // Taking Time
                        timer.Start();
                        fibTimeResult = FibonacciI(testValue);
                        timer.Stop();
                        // Getting Time
                        Console.WriteLine(' ({0}) = {1}', testValue, timer.Elapsed);
                        i++;
                    } while (i < values.Count);
                    break;
                case 4:
                    Console.WriteLine('\nFibonacci Recursive:');
                    // 'For In' Loop Statement
                    for (var item : int in values) {
                        testValue = item;
                        // Taking Time
                        timer.Start();
                        fibTimeResult = FibonacciR(testValue);
                        timer.Stop();
                        // Getting Time
                        Console.WriteLine(' ({0}) = {1}', testValue, timer.Elapsed);
                    }
                    break;
                default:
                    Console.WriteLine('DONG!');
                    break;
            }            
        }        
    }

    // Instance Class
    public class InstanceFiborial {
        // Instance Field
        var className : String;
        // Instance Constructor
        function InstanceFiborial() {
            this.className = 'Instance Constructor';
            Console.WriteLine(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);
        }
    };
};

import FiborialJs;

function Main() {
    Console.WriteLine('\nInstance Class with Static Methods only');
    // Calling Static Methods from an Instance Class
    // No instantiation needed. Calling method directly from the class
    Console.WriteLine('FacImp(5) = {0}', StaticFiborial.FactorialI(5));
    Console.WriteLine('FacRec(5) = {0}', StaticFiborial.FactorialR(5));
    Console.WriteLine('FibImp(11)= {0}', StaticFiborial.FibonacciI(11));
    Console.WriteLine('FibRec(11)= {0}', StaticFiborial.FibonacciR(11));

    Console.WriteLine('\nInstance Class');
    // Calling Instance Class and Methods 
    // Need to instantiate before using. Calling method from instantiated object
    var ff : InstanceFiborial = new InstanceFiborial;
    Console.WriteLine('FacImp(5) = {0}', ff.FactorialI(5));
    Console.WriteLine('FacRec(5) = {0}', ff.FactorialR(5));
    Console.WriteLine('FibImp(11)= {0}', ff.FibonacciI(11));
    Console.WriteLine('FibRec(11)= {0}', ff.FibonacciR(11));

    // Create na arraylist of integer values to test
    // From 5 to 50 by 5
    //var values : List<int> = new List<int>;
    var values : ArrayList = new ArrayList;
    for(var i : int = 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
    Console.Read();
};

Main();

And the Output is:

import System;  
import System.Text;
import System.Numerics;

package FiborialSeries {
    class Fiborial {
        // Using a StringBuilder as a list of string elements
        public static function GetFactorialSeries(n : int) : String {
            // Create the String that will hold the list
            var 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 (var 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
            return series.ToString();
        }

        // Using a StringBuilder as a list of string elements
        public static function GetFibonnaciSeries(n : int) : String {
            // Create the String that will hold the list
            var 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 (var i : int = 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 function Factorial(n : int) : BigInteger {
            if (n == 1)                
                return new BigInteger(1);
            else
                return n * Factorial(n - 1);
        }

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

import FiborialSeries;

// Printing Factorial Series
Console.WriteLine();
Console.WriteLine(Fiborial.GetFactorialSeries(5));
Console.WriteLine(Fiborial.GetFactorialSeries(7));
Console.WriteLine(Fiborial.GetFactorialSeries(9));
Console.WriteLine(Fiborial.GetFactorialSeries(11));
Console.WriteLine(Fiborial.GetFactorialSeries(40));
// Printing Fibonacci Series
Console.WriteLine();
Console.WriteLine(Fiborial.GetFibonnaciSeries(5));
Console.WriteLine(Fiborial.GetFibonnaciSeries(7));
Console.WriteLine(Fiborial.GetFibonnaciSeries(9));
Console.WriteLine(Fiborial.GetFibonnaciSeries(11));
Console.WriteLine(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/initializers, methods, etc. However, we cannot do that if the class is marked as static because JScript.NET does not support it. The following text explains why:

"The static modifier signifies that a member belongs to the class itself rather than to instances of the class. Only one copy of a static member exists in a given application even if many instances of the class are created. You can only access static members with a reference to the class rather than a reference to an instance. However, within a class member declaration, static members can be accessed with the this object.

Members of classes can be marked with the static modifier. Classes, interfaces, and members of interfaces cannot take the static modifier.

You may not combine the static modifier with any of the inheritance modifiers (abstract and final) or version-safe modifiers (hide and override).

Do not confuse the static modifier with the static statement. The static modifier denotes a member that belongs to the class itself rather than any instance of the class." Taken from:

on the other hand:

"A static initializer is used to initialize a class object (not object instances) before its first use. This initialization occurs only once, and it can be used to initialize fields in the class that have the static modifier.

A class may contain several static initializer blocks interspersed with static field declarations. To initialize the class, all the static blocks and static field initializers are executed in the order in which they appear in the class body. This initialization is performed before the first reference to a static field.

Do not confuse the static modifier with the static statement. The static modifier denotes a member that belongs to the class itself, not any instance of the class." Taken from:

import System;

package FiborialExtrasJs2 {
    // Instance Classes can have both: static and instance members. 
    // However, Static Classes only allow static members to be defined.
    // If you declare our next example class as static
    // (static class Fiborial) you will get the following compile error
    // Error: cannot declare instance members in a static class
    
    // Instance Class
    class Fiborial {
        // Instance Field
        private var instanceCount : int;
        // Static Field
        private static var staticCount : int;
        // Instance Read-Only Property
        // Within instance members, you can always use  
        // the 'this' reference pointer to access your (instance) members.
        public function get InstanceCount() : int {
            return 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 function get StaticCount() : int {
            return staticCount;
        }
        // Instance Constructor
        public function Fiborial() {
            this.instanceCount = 0;
            Console.WriteLine('\nInstance Constructor {0}', this.instanceCount);
        }
        // Static Constructor
        static Fiborial {
            staticCount = 0;
            Console.WriteLine('\nStatic Constructor {0}', staticCount);
        }
        // Instance Method
        public function Factorial(n : int)
        {
            this.instanceCount += 1;
            Console.WriteLine('\nFactorial({0})', n);
        }
        // Static Method
        public static function Fibonacci(n : int)
        {
            staticCount += 1;
            Console.WriteLine('\nFibonacci({0})', n);
        }
    };       
};

import FiborialExtrasJs2;
// Calling Static Constructor and Methods
// No need to instantiate
Fiborial.Fibonacci(5);

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

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

// Calling Instance Constructor and Methods
// for a second object
var fib2 : Fiborial = new 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:

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 and JScript.NET 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.

import System;  
import System.Diagnostics;
import System.Numerics;
import Microsoft.JScript; // to get the JScriptException

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

// Double/Number Factorial 
function FactorialDouble(n : int) : Number {
    if (n == 1)
        return 1;
    else
        return n * FactorialDouble(n - 1);
}

// BigInteger Factorial 
function FactorialBigInteger(n : int) : BigInteger {
    if (n == 1)
        return new BigInteger(1);
    else
        return n * FactorialBigInteger(n - 1);
}

function Main() {
    var timer : Stopwatch = new Stopwatch;
    var facIntResult : long = 0;
    var facDblResult : Number = 0;
    var facBigResult : BigInteger = new BigInteger(0);
    var i : int = 0;
    
    Console.WriteLine('\nFactorial using Int64');
    // Benchmark Factorial using Int64
    // Overflow Exception!!! 
    // in JScript case this is a JsScriptException
    try {
        for (i = 5; i <= 50; i += 5) {
            timer.Start();
            facIntResult = FactorialInt64(i);
            timer.Stop();
            Console.WriteLine(' ({0}) = {1} : {2}', i, timer.Elapsed, facIntResult);
        }
    } catch(ex : JScriptException) {
        // yummy ^_^  
        Console.WriteLine(' Oops! {0} ', ex.Message);
    }    
    Console.WriteLine('\nFactorial using Double');
    // Benchmark Factorial using Double/Number
    for (i = 5; i <= 50; i += 5) {
        timer.Start();
        facDblResult = FactorialDouble(i);
        timer.Stop();
        Console.WriteLine(' ({0}) = {1} : {2}', i, timer.Elapsed, facDblResult);
    }
    Console.WriteLine('\nFactorial using BigInteger');
    // Benchmark Factorial using BigInteger
    for (i = 5; i <= 50; i += 5) {
        timer.Start();
        facBigResult = FactorialBigInteger(i);
        timer.Stop();
        Console.WriteLine(' ({0}) = {1} : {2}', i, timer.Elapsed, facBigResult);
    }
}

Main();

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 in this particular case, you also need to reference Microsoft.JScript.dll assembly to get the JScriptException class.

And the Output is:

Factorial and Fibonacci in Delphi Prism

2011-02-26T16:47:00.000-08:00

Here below a little program in Delphi Prism 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 Delphi Prism
namespace FiborialDelphi;

interface
uses
    System,
    System.Diagnostics,
    System.Collections.Generic,
    System.Numerics;

type
    // Static Class 
    StaticFiborial = public static class
    private
        // Static/Class Field
        class var 
            fClassName: string;        
    public
        // Static/Class Constructor 
        class constructor;
        // Static/Class Method - Factorial Recursive    
        class method FactorialR(n: integer): BigInteger;
        // Static/Class Method - Factorial Imperative
        class method FactorialI(n: integer): BigInteger;
        // Static/Class Method - Fibonacci Recursive
        class method FibonacciR(n: integer): Int64;
        // Static/Class Method - Fibonacci Imperative
        class method FibonacciI(n: integer): Int64;
        // Static/Class Method - Benchmarking Algorithms 
        class method BenchmarkAlgorithm(algorithm: integer; values: List<integer>);
    end;

type
    // Instance Class 
    InstanceFiborial = public class
    private
        // Instance Field
        var
            fClassName: string;
    public
        // Instance Constructor 
        constructor;
        // Instance Method - Factorial Recursive    
        method FactorialR(n: integer): BigInteger;
        // Instance Method - Factorial Imperative
        method FactorialI(n: integer): BigInteger;
        // Instance Method - Fibonacci Recursive
        method FibonacciR(n: integer): Int64;
        // Instance Method - Fibonacci Imperative
        method FibonacciI(n: integer): Int64;
    end;

type
    ConsoleApp = class
    public
        class method Main(args: array of string);
    end;

implementation

// Static/Class Constructor   
class constructor StaticFiborial;
begin
    fClassName := 'Static/Class Constructor';
    Console.WriteLine(fClassName);
end;
// Static/Class Method - Factorial Recursive    
class method StaticFiborial.FactorialR(n: integer): BigInteger;
begin
    if n = 1 then 
        result := 1
    else 
        result := n * FactorialR(n - 1);
end;
// Static/Class Method - Factorial Imperative
class method StaticFiborial.FactorialI(n: integer): BigInteger;
var 
    res: BigInteger := 1;
begin
    for i:integer := n downto 1 step 1 do
        res := res * i;
    result := res;
end;
// Static/Class Method - Fibonacci Recursive
class method StaticFiborial.FibonacciR(n: integer): Int64;
begin
    if n < 2 then
        result := 1
    else
        result := FibonacciR(n - 1) + FibonacciR(n - 2);    
end;
// Static/Class Method - Fibonacci Imperative
class method StaticFiborial.FibonacciI(n: integer): Int64;
var
    tmp, pre, cur: Int64;        
begin    
    tmp := 0;
    pre := 1;
    cur := 1;
    for i: integer := 2 to n step 1 do
    begin
        tmp := cur + pre;
        pre := cur;
        cur := tmp;
    end;
    result := cur;
end;
// Static Method - Benchmarking Algorithms
class method StaticFiborial.BenchmarkAlgorithm(algorithm: integer; values: List<integer>);
var
    timer: StopWatch;
    i, testValue: integer;
    facTimeResult: BigInteger := 0;
    fibTimeResult: Int64 := 0;
begin
    i := 0;
    testValue := 0;
    timer := new StopWatch();
    // 'switch/case' Flow Constrol Statement 
    case algorithm of  
        1: begin
            Console.WriteLine(''#10'Factorial Imperative:');
            // 'For' Loop Statement
            for i: integer := 0 to values.Count - 1 step 1 do
            begin
                testValue := values[i];
                // Taking Time    
                timer.Start();    
                facTimeResult := FactorialI(testValue);
                timer.Stop();                            
                // Getting Time    
                Console.WriteLine(' ({0}) = {1}', testValue, timer.Elapsed);
            end;
        end;
        2: begin
            Console.WriteLine(''#10'Factorial Recursive:');
            // 'While' Loop Statement 
            while i < values.Count do 
            begin
                testValue := values[i];
                // Taking Time    
                timer.Start();    
                facTimeResult := FactorialR(testValue);
                timer.Stop();                            
                // Getting Time    
                Console.WriteLine(' ({0}) = {1}', testValue, timer.Elapsed);
                inc(i);
            end;
        end;
        3: begin
            Console.WriteLine(''#10'Fibonacci Imperative:');
            // 'Repeat/Do' Loop Statement
            repeat        
                testValue := values[i];
                // Taking Time    
                timer.Start();    
                facTimeResult := FibonacciI(testValue);
                timer.Stop();
                // Getting Time    
                Console.WriteLine(' ({0}) = {1}', testValue, timer.Elapsed);
                inc(i);
            until i = values.Count - 1
        end;
        4: begin            
            Console.WriteLine(''#10'Fibonacci Recursive:');
            // 'For Each' Loop Statement
            for each item in values do
            begin
                testValue := item;  
                // Taking Time    
                timer.Start();    
                facTimeResult := FibonacciR(testValue);
                timer.Stop();
                // Getting Time    
                Console.WriteLine(' ({0}) = {1}', testValue, timer.Elapsed);
            end;
        end;
        else Console.WriteLine('DONG!');
    end;  
end;

// Instance Constructor   
constructor InstanceFiborial;
begin
    self.fClassName := 'Instance Constructor';
    Console.WriteLine(self.fClassName);
end;
// Instance Method - Factorial Recursive
method InstanceFiborial.FactorialR(n: integer): BigInteger;
begin
    // Calling Static Method    
    result := StaticFiborial.FactorialR(n);
end;
// Instance Method - Factorial Imperative
method InstanceFiborial.FactorialI(n: integer): BigInteger;
begin
    // Calling Static Method    
    result := StaticFiborial.FactorialI(n);
end;
// Instance Method - Fibonacci Recursive
method InstanceFiborial.FibonacciR(n: integer): Int64;
begin
    // Calling Static Method
    result := StaticFiborial.FibonacciR(n);
end;
// Instance Method - Fibonacci Imperative
method InstanceFiborial.FibonacciI(n: integer): Int64;
begin        
    // Calling Static Method
    result := StaticFiborial.FibonacciI(n);
end;

class method ConsoleApp.Main(args: array of string);
var
    values: List<integer>;
    ff: InstanceFiborial; 
begin
    Console.WriteLine(''#10'Static Class');
    // Calling Static Class and Methods  
    // No instantiation needed. Calling method directly from the class  
    Console.WriteLine('FacImp(5) = {0}', StaticFiborial.FactorialI(5));  
    Console.WriteLine('FacRec(5) = {0}', StaticFiborial.FactorialR(5));  
    Console.WriteLine('FibImp(11)= {0}', StaticFiborial.FibonacciI(11));  
    Console.WriteLine('FibRec(11)= {0}', StaticFiborial.FibonacciR(11));  
  
    Console.WriteLine(''#10'Instance Class');  
    // Calling Instance Class and Methods   
    // Need to instantiate before using. Calling method from instantiated object  
    ff := new InstanceFiborial();  
    Console.WriteLine('FacImp(5) = {0}', ff.FactorialI(5));  
    Console.WriteLine('FacRec(5) = {0}', ff.FactorialR(5));  
    Console.WriteLine('FibImp(11)= {0}', ff.FibonacciI(11));  
    Console.WriteLine('FibRec(11)= {0}', ff.FibonacciR(11));  
  
    // Create a (generic) list of integer values to test  
    // From 5 to 50 by 5  
    values := new List<integer>();  
    for i:integer := 5 to 50 step 5 do
        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();  
end;

end.

And the Output is:

namespace FiborialSeries;

interface
uses
    System,
    System.Text,
    System.Numerics;

type
    Fiborial = static class
    public
        class method GetFactorialSeries(n: integer): string;
        class method GetFibonnaciSeries(n: integer): string;
        class method Factorial(n: integer): BigInteger;
        class method Fibonacci(n: integer): Int64;
    end;

type
    ConsoleApp = class
    public
        class method Main(args: array of string);
    end;

implementation

class method Fiborial.GetFactorialSeries(n: integer): string;
var
    // Using a StringBuilder as a list of string elements    
    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: integer := n downto 1 do
    begin
        // and append it to the list
        series.Append(i);
        if i > 1 then
            series.Append(' * ')
        else 
            series.Append(' = ');         
    end;
    // 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
    result := series.ToString();
end;

class method Fiborial.GetFibonnaciSeries(n: integer): string;
var
    // Using a StringBuilder as a list of string elements
    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: integer := 2 to n do
    begin
        if i < n then
            series.Append(', ')
        else
            series.Append(' = ');
                
        series.Append(Fibonacci(i));
    end;
    // return the list as a string
    result := series.ToString();
end;

class method Fiborial.Factorial(n: integer): BigInteger;
begin
    if n = 1 then 
        result := 1
    else 
        result := n * Factorial(n - 1);
end;

class method Fiborial.Fibonacci(n: integer): Int64;
begin
    if n < 2 then
        result := 1
    else
        result := Fibonacci(n - 1) + Fibonacci(n - 2);    
end;

class method ConsoleApp.Main(args: array of string);
begin
    // Printing Factorial Series
    Console.WriteLine();
    Console.WriteLine(Fiborial.GetFactorialSeries(5));
    Console.WriteLine(Fiborial.GetFactorialSeries(7));
    Console.WriteLine(Fiborial.GetFactorialSeries(9));
    Console.WriteLine(Fiborial.GetFactorialSeries(11));
    Console.WriteLine(Fiborial.GetFactorialSeries(40));
    // Printing Fibonacci Series
    Console.WriteLine();
    Console.WriteLine(Fiborial.GetFibonnaciSeries(5));
    Console.WriteLine(Fiborial.GetFibonnaciSeries(7));
    Console.WriteLine(Fiborial.GetFibonnaciSeries(9));
    Console.WriteLine(Fiborial.GetFibonnaciSeries(11));
    Console.WriteLine(Fiborial.GetFibonnaciSeries(40));
    Console.Read();
end;

end.

And the Output is:

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

namespace FiborialExtrasDelphi2;
// Instance Classes can have both: static and instance members. 
// However, Static Classes only allow static members to be defined.
// If you declare our next example class as static
// (static class Fiborial) you will get the following compile error
// Error: cannot declare instance members in a static class
interface

// Instance Class
type Fiborial = class
    private
        // Instance Field
        var fInstanceCount: integer;
        // Static Field
        class var fStaticCount: integer;
    public
        // Instance Read-Only Property   
        // Within instance members, you can always use  
        // the "this" reference pointer to access your (instance) members.     
        property InstanceCount : integer read self.fInstanceCount;
        // 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.          
        class property StaticCount : integer read fStaticCount;
        // Instance Constructor
        constructor;
        // Static Constructor
        class constructor;
        // Instance Method
        method Factorial(n: integer);
        // Static Method
        class method Fibonacci(n: integer);
    end;

type ConsoleApp = class
    public
        class method Main(args: array of string);
    end;

implementation

// Instance Constructor   
constructor Fiborial;
begin
    self.fInstanceCount := 0;
    Console.WriteLine(''#10'Instance Constructor {0}', self.fInstanceCount);
end;
// Static/Class Constructor   
class constructor Fiborial;
begin
    fStaticCount := 0;
    Console.WriteLine(''#10'Static Constructor {0}', fStaticCount);
end;
// Instance Method
method Fiborial.Factorial(n: integer);
begin
    inc(self.fInstanceCount);
    Console.WriteLine(''#10'Factorial({0})', n);
end;
// Static Method
class method Fiborial.Fibonacci(n: integer);
begin
    inc(fStaticCount);
    Console.WriteLine(''#10'Fibonacci({0})', n);
end;

class method ConsoleApp.Main(args: array of string);
begin
    // 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);
            
    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);
    Console.Read();
end;

end.

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 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.

namespace FiborialExtrasDelphi3;

interface

uses   
    System,
    System.Numerics,
    System.Diagnostics;

type
    ConsoleApp = class
    public
        class method Main(args: array of string);
        class method FactorialInt64(n: integer): Int64;
        class method FactorialDouble(n: integer): Double;
        class method FactorialBigInteger(n: integer): BigInteger;
    end;

implementation

class method ConsoleApp.Main(args: array of string);
var
    timer: StopWatch;
    facIntResult: System.Int64 := 0;
    facDblResult: System.Double := 0;
    facBigResult: System.Numerics.BigInteger := 0;

begin
    timer := new StopWatch();
    Console.WriteLine(''#10'Factorial using Int64');    
    for i: integer := 5 to 50 step 5 do
    begin                
        timer.Start();
        facIntResult := FactorialInt64(i);
        timer.Stop();                                    
        Console.WriteLine(' ({0}) = {1} : {2}', i, timer.Elapsed, facIntResult);
    end;
    Console.WriteLine(''#10'Factorial using Double');
    for i: integer := 5 to 50 step 5 do
    begin                
        timer.Start();
        facDblResult := FactorialDouble(i);
        timer.Stop();                                    
        Console.WriteLine(' ({0}) = {1} : {2}', i, timer.Elapsed, facDblResult);
    end;
    Console.WriteLine(''#10'Factorial using BigInteger');
    for i: integer := 5 to 50 step 5 do
    begin                
        timer.Start();
        facBigResult := FactorialBigInteger(i);
        timer.Stop();                                    
        Console.WriteLine(' ({0}) = {1} : {2}', i, timer.Elapsed, facBigResult);
    end;
    Console.Read();
end;

class method ConsoleApp.FactorialInt64(n: integer): Int64;
begin
    if n = 1 then 
        result := 1
    else 
        result := n * FactorialInt64(n - 1);
end;

class method ConsoleApp.FactorialDouble(n: integer): Double;
begin
    if n = 1 then 
        result := 1
    else 
        result := n * FactorialDouble(n - 1);
end;

class method ConsoleApp.FactorialBigInteger(n: integer): BigInteger;
begin
    if n = 1 then 
        result := 1
    else 
        result := n * FactorialBigInteger(n - 1);
end;

end.

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 C++/CLI

2011-02-25T15:09:00.000-08:00

Here below a little program in C++/CLI 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 C++/CLI
#include "stdafx.h"
using namespace System;
using namespace System::Collections::Generic;
using namespace System::Diagnostics;
using namespace System::Numerics;

namespace FiborialCpp {
 // static class
 static ref class StaticFiborial {
 private:
  // Static Field
  static String^ className;
  // Static Constructor  
  static StaticFiborial() {  
   className = L"Static Constructor";  
   Console::WriteLine(className);              
  }  

 public:
  // Static Method - Factorial Recursive  
  static BigInteger FactorialR(int n) {  
   if (n == 1)
    return 1;
   else  
    return n * FactorialR(n - 1);
  }  
  // Static Method - Factorial Imperative  
  static BigInteger FactorialI(int n) {  
   BigInteger res = 1;  
   for (int i = n; i >= 1; i--) {
    res *= i;
   }
   return res;  
  }  
  // Static Method - Fibonacci Recursive  
  static long FibonacciR(int n) {  
   if (n < 2)  
    return 1;  
   else  
    return FibonacciR(n - 1) + FibonacciR(n - 2);  
  }  
  // Static Method - Fibonacci Imperative  
  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  
  static void BenchmarkAlgorithm(int algorithm, List<int>^ values) {              
   Stopwatch ^timer = gcnew Stopwatch();  
   int i, testValue;  
   BigInteger facTimeResult = 0;  
   long fibTimeResult = 0;  
   i = testValue = 0;              
     
   // "Switch" Flow Constrol Statement  
   switch (algorithm)  
   {  
    case 1:  
     Console::WriteLine("\nFactorial Imperative:");  
     // "For" Loop Statement  
     for (i = 0; i < values->Count; i++)
     {                          
      testValue = values[i];  
      // Taking Time  
      timer->Start();  
      facTimeResult = FactorialI(testValue);  
      timer->Stop();                          
      // Getting Time  
      Console::WriteLine(" ({0}) = {1}", testValue, timer->Elapsed);  
     }                      
     break;  
    case 2:  
     Console::WriteLine("\nFactorial Recursive:");  
     // "While" Loop Statement  
     while (i < values->Count)  
     {                          
      testValue = values[i];  
      // Taking Time  
      timer->Start();  
      facTimeResult = FactorialR(testValue);  
      timer->Stop();  
      // Getting Time  
      Console::WriteLine(" ({0}) = {1}", testValue, timer->Elapsed);  
      i++;  
     }  
     break;  
    case 3:  
     Console::WriteLine("\nFibonacci Imperative:");  
     // "Do-While" Loop Statement  
     do {  
      testValue = values[i];  
      // Taking Time  
      timer->Start();  
      fibTimeResult = FibonacciI(testValue);  
      timer->Stop();  
      // Getting Time  
      Console::WriteLine(" ({0}) = {1}", testValue, timer->Elapsed);  
      i++;  
     } while (i < values->Count);  
     break;  
    case 4:  
     Console::WriteLine("\nFibonacci Recursive:");  
     // "For Each" Loop Statement  
     for each (int item in values)  
     {  
      testValue = item;  
      // Taking Time  
      timer->Start();  
      fibTimeResult = FibonacciR(testValue);  
      timer->Stop();  
      // Getting Time  
      Console::WriteLine(" ({0}) = {1}", testValue, timer->Elapsed);  
     }  
     break;  
    default:  
     Console::WriteLine(L"DONG!");  
     break;  
   }                  
  }  
 };

 // Instance Class  
 public ref class InstanceFiborial {  
  // Instance Field  
  String^ className;  
  // Instance Constructor  
 public:
  InstanceFiborial() {  
   this->className = "Instance Constructor";  
   Console::WriteLine(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  
  long FibonacciR(int n) {  
   // Calling Static Method  
   return StaticFiborial::FibonacciR(n);  
  }  
  // Instance Method - Factorial Imperative  
  long FibonacciI(int n) {  
   // Calling Static Method  
   return StaticFiborial::FibonacciI(n);  
  }  
 };
};

int main(array<System::String ^> ^args)
{ 
 Console::WriteLine("\nStatic Class");  
    // Calling Static Class and Methods  
    // No instantiation needed. Calling method directly from the class  
    Console::WriteLine("FacImp(5) = {0}", FiborialCpp::StaticFiborial::FactorialI(5));  
    Console::WriteLine("FacRec(5) = {0}", FiborialCpp::StaticFiborial::FactorialR(5));  
    Console::WriteLine("FibImp(11)= {0}", FiborialCpp::StaticFiborial::FibonacciI(11));  
    Console::WriteLine("FibRec(11)= {0}", FiborialCpp::StaticFiborial::FibonacciR(11));  
  
    Console::WriteLine("\nInstance Class");  
    // Calling Instance Class and Methods   
    // Need to instantiate before using. Calling method from instantiated object  
 FiborialCpp::InstanceFiborial ^ff = gcnew FiborialCpp::InstanceFiborial();  
    Console::WriteLine("FacImp(5) = {0}", ff->FactorialI(5));  
    Console::WriteLine("FacRec(5) = {0}", ff->FactorialR(5));  
    Console::WriteLine("FibImp(11)= {0}", ff->FibonacciI(11));  
    Console::WriteLine("FibRec(11)= {0}", ff->FibonacciR(11));  
  
    // Create a (generic) list of integer values to test  
    // From 5 to 50 by 5  
    List<int> ^values = gcnew List<int>();  
    for(int i = 5; i <= 50; i += 5)  
        values->Add(i);  
  
    // Benchmarking Fibonacci                       
    // 1 = Factorial Imperative              
    FiborialCpp::StaticFiborial::BenchmarkAlgorithm(1, values);  
    // 2 = Factorial Recursive  
    FiborialCpp::StaticFiborial::BenchmarkAlgorithm(2, values);   
  
    // Benchmarking Factorial              
    // 3 = Fibonacci Imperative  
    FiborialCpp::StaticFiborial::BenchmarkAlgorithm(3, values);  
    // 4 = Fibonacci Recursive  
    FiborialCpp::StaticFiborial::BenchmarkAlgorithm(4, values);   
  
    // Stop and Exit  
    Console::Read();  

 return 0;
}

And the Output is:

#include "stdafx.h"

using namespace System;
using namespace System::Text;
using namespace System::Numerics;  
 
namespace FiborialSeries {      

 static ref class Fiborial {  
 public:
  // Using a StringBuilder as a list of string elements  
  static String^ GetFactorialSeries(int n) {  
   // Create the String that will hold the list  
   StringBuilder ^series = gcnew 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 (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 StringBuilder as a list of string elements  
  static String^ GetFibonnaciSeries(int n)  
  {  
   // Create the String that will hold the list  
   StringBuilder ^series = gcnew 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 (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();  
  }  
  
  static BigInteger Factorial(int n)  
  {  
   if (n == 1)  
    return 1;  
   else  
    return n * Factorial(n - 1);  
  }  
  
  static long Fibonacci(int n)  
  {  
   if (n < 2)  
    return 1;  
   else  
    return Fibonacci(n - 1) + Fibonacci(n - 2);  
  }    
 };  
};

using namespace FiborialSeries;
int main(array<System::String ^> ^args)
{
 // Printing Factorial Series  
 Console::WriteLine();  
 Console::WriteLine(Fiborial::GetFactorialSeries(5));  
 Console::WriteLine(Fiborial::GetFactorialSeries(7));  
 Console::WriteLine(Fiborial::GetFactorialSeries(9));  
 Console::WriteLine(Fiborial::GetFactorialSeries(11));  
 Console::WriteLine(Fiborial::GetFactorialSeries(40));  
 // Printing Fibonacci Series  
 Console::WriteLine();  
 Console::WriteLine(Fiborial::GetFibonnaciSeries(5));  
 Console::WriteLine(Fiborial::GetFibonnaciSeries(7));  
 Console::WriteLine(Fiborial::GetFibonnaciSeries(9));  
 Console::WriteLine(Fiborial::GetFibonnaciSeries(11));  
 Console::WriteLine(Fiborial::GetFibonnaciSeries(40));  
 Console::Read();
 return 0;
}

And the Output is:

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

#include "stdafx.h"

using namespace System;

namespace FiborialExtrasCpp2 {  
 // Instance Classes can have both: static and instance members.   
 // However, Static Classes only allow static members to be defined.  
 // If you declare our next example class as static  
 // (static class Fiborial) you will get the following compile error  
 // Error: cannot declare instance members in a static class  
  
 // Instance Class  
 ref class Fiborial {  
 // Instance Field  
  private:
   int instanceCount;  
 // Static Field  
 static int staticCount;   
 
 public:
  // Instance Read-Only Property  
  // Within instance members, you can always use
  // the "this" reference pointer to access your (instance) members.  s
  property int InstanceCount {  
   int get() { return 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.  
  static property int StaticCount {  
   int get() { return staticCount; }  
  }
  // Instance Constructor  
  Fiborial() {  
   this->instanceCount = 0;  
   Console::WriteLine("\nInstance Constructor {0}", this->instanceCount);  
  }
  // Static Constructor  
  static Fiborial() {  
   staticCount = 0;  
   Console::WriteLine("\nStatic Constructor {0}", staticCount);
  }
  // Instance Method  
  void Factorial(int n) {  
   this->instanceCount += 1;  
   Console::WriteLine("\nFactorial({0})", n);  
  }
  // Static Method  
  static void Fibonacci(int n) {  
   staticCount += 1;  
   Console::WriteLine("\nFibonacci({0})", n);  
  }
 };  
};

using namespace FiborialExtrasCpp2;
int main(array<System::String ^> ^args)
 {
 // Calling Static Constructor and Methods  
 // No need to instantiate  
 Fiborial::Fibonacci(5);
  
 // Calling Instance Constructor and Methods  
 // Instance required  
 Fiborial ^fib = gcnew Fiborial();  
 fib->Factorial(5);
  
 Fiborial::Fibonacci(15);  
 fib->Factorial(5);  
  
 // Calling Instance Constructor and Methods  
 // for a second object  
 Fiborial ^fib2 = gcnew 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);
 Console::Read();
 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 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.

#include "stdafx.h"

using namespace System;
using namespace System::Numerics;
using namespace System::Diagnostics;

// Long Factorial   
static Int64 FactorialInt64(int n) {  
    if (n == 1)  
        return 1;  
    else  
        return n * FactorialInt64(n - 1);  
}  
  
// Double Factorial   
static Double FactorialDouble(int n) {  
    if (n == 1)  
        return 1;  
    else  
        return n * FactorialDouble(n - 1);  
}  
          
// BigInteger Factorial   
static BigInteger FactorialBigInteger(int n) {  
    if (n == 1)  
        return 1;  
    else  
        return n * FactorialBigInteger(n - 1);  
}  

int main(array<System::String ^> ^args) {
    Stopwatch ^timer = gcnew Stopwatch();
    Int64 facIntResult = 0;  
    Double facDblResult = 0;  
    BigInteger facBigResult = 0;  
  
    Console::WriteLine("\nFactorial using Int64");  
    // Benchmark Factorial using Int64  
    for (int i = 5; i <= 50; i += 5)  
    {  
        timer->Start();  
        facIntResult = FactorialInt64(i);  
        timer->Stop();  
        Console::WriteLine(" ({0}) = {1} : {2}", i, timer->Elapsed, facIntResult);  
    }  
    Console::WriteLine("\nFactorial using Double");  
    // Benchmark Factorial using Double  
    for (int i = 5; i <= 50; i += 5)  
    {  
        timer->Start();  
        facDblResult = FactorialDouble(i);  
        timer->Stop();  
        Console::WriteLine(" ({0}) = {1} : {2}", i, timer->Elapsed, facDblResult);  
    }  
    Console::WriteLine("\nFactorial using BigInteger");  
    // Benchmark Factorial using BigInteger  
    for (int i = 5; i <= 50; i += 5)  
    {  
        timer->Start();  
        facBigResult = FactorialBigInteger(i);  
        timer->Stop();  
        Console::WriteLine(" ({0}) = {1} : {2}", i, timer->Elapsed, facBigResult);
    }
 Console::Read();
    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 VB.NET

2011-02-19T14:42:00.000-08:00

Here below a little program in VB.NET 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 (or shared in VB.NET) 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 VB.NET
Option Explicit On
Option Strict On

Imports System.Collections.Generic
Imports System.Diagnostics
Imports System.Numerics

Namespace FiborialVB
    ' Static Class (All Members in a Module are Static/Shared)
    Module StaticFiborial
        ' Static Field
        Dim className As String
        ' Static Constructor        
        Sub New()
            className = "Static Constructor"
            Console.WriteLine(className)
        End Sub
        ' Static Method - Factorial Recursive
        Public Function FactorialR(ByVal n As Integer) As BigInteger
            If n = 1 Then
                Return 1
            Else
                Return n * FactorialR(n - 1)
            End If
        End Function
        ' Static Method - Factorial Imperative
        Public Function FactorialI(ByVal n As Integer) As BigInteger
            Dim res As BigInteger = 1
            For i = n To 1 Step -1
                res *= i
            Next            
            Return res
        End Function
        ' Static Method - Fibonacci Recursive
        Public Function FibonacciR(ByVal n As Integer) As Long
            If n < 2 Then
                Return 1
            Else
                Return FibonacciR(n - 1) + FibonacciR(n - 2)
            End If
        End Function
        ' Static Method - Fibonacci Imperative
        Public Function FibonacciI(ByVal n As Integer) As Long
            Dim i As Integer = 2
            Dim pre As Long = 1, cur As Long = 1
            Dim tmp As Long = 0
            While i <= n
                tmp = cur + pre
                pre = cur
                cur = tmp
                i += 1
            End While
            Return cur
        End Function
        ' Static Method - Benchmarking Algorithms
        Public Sub BenchmarkAlgorithm(ByVal algorithm As Integer,
                                      ByVal values As List(Of Integer))
            Dim timer As New Stopwatch()
            Dim i As Integer, facTimeResult As BigInteger,
                fibTimeResult As Long, testValue As Integer
            ' "Case/Switch" Flow Constrol Statement
            Select Case algorithm
                Case 1
                    Console.WriteLine(ControlChars.CrLf & "Factorial Imperative:")
                    ' "For" Loop Statement
                    For i = 0 To values.Count - 1 Step 1
                        testValue = values(i)
                        ' Taking Time
                        timer.Start()
                        facTimeResult = FactorialI(testValue)
                        timer.Stop()
                        ' Getting Time
                        Console.WriteLine(" ({0}) = {1}", testValue, timer.Elapsed)
                    Next
                Case 2
                    Console.WriteLine(ControlChars.CrLf & "Factorial Recursive:")
                    ' "While" Loop Statement
                    While i < values.Count
                        testValue = values(i)
                        ' Taking Time
                        timer.Start()
                        facTimeResult = FactorialR(testValue)
                        timer.Stop()
                        ' Getting Time
                        Console.WriteLine(" ({0}) = {1}", testValue, timer.Elapsed)
                        i += 1
                    End While
                Case 3
                    Console.WriteLine(ControlChars.CrLf & "Fibonacci Imperative:")
                    ' "Do-While" Loop Statement
                    Do
                        testValue = values(i)
                        ' Taking Time
                        timer.Start()
                        fibTimeResult = FibonacciI(testValue)
                        timer.Stop()
                        ' Getting Time
                        Console.WriteLine(" ({0}) = {1}", testValue, timer.Elapsed)
                        i += 1
                    Loop While i < values.Count
                Case 4
                    Console.WriteLine(ControlChars.CrLf & "Fibonacci Recursive:")
                    ' "For Each" Loop Statement
                    For Each item As Integer In values
                        testValue = item
                        ' Taking Time
                        timer.Start()
                        fibTimeResult = FibonacciR(testValue)
                        timer.Stop()
                        ' Getting Time
                        Console.WriteLine(" ({0}) = {1}", testValue, timer.Elapsed)
                    Next
                Case Else
                    Console.WriteLine("DONG!")
            End Select
        End Sub
    End Module

    ' Instance Class
    Public Class InstanceFiborial
        ' Instance Field
        Dim className As String
        ' Instance Constructor
        Sub New()
            Me.className = "Instance Constructor"
            Console.WriteLine(className)
        End Sub
        ' Instance Method - Factorial Recursive
        Public Function FactorialR(ByVal n As Integer) As BigInteger
            ' Calling Static Method
            Return StaticFiborial.FactorialR(n)
        End Function
        ' Instance Method - Factorial Imperative
        Public Function FactorialI(ByVal n As Integer) As BigInteger
            ' Calling Static Method
            Return StaticFiborial.FactorialI(n)
        End Function
        ' Instance Method - Fibonacci Recursive
        Public Function FibonacciR(ByVal n As Integer) As Long
            ' Calling Static Method
            Return StaticFiborial.FibonacciR(n)
        End Function
        ' Instance Method - Fibonacci Imperative
        Public Function FibonacciI(ByVal n As Integer) As Long
            ' Calling Static Method
            Return StaticFiborial.FibonacciI(n)
        End Function
    End Class

    ' Console Program  
    Friend Module Program
        Public Sub Main()

            Console.WriteLine(ControlChars.CrLf & "Static Class")
            ' Calling Static Class and Methods
            ' No instantiation needed. Calling method directly from the class
            Console.WriteLine("FacImp(5) = {0}", StaticFiborial.FactorialI(5))
            Console.WriteLine("FacRec(5) = {0}", StaticFiborial.FactorialR(5))
            Console.WriteLine("FibImp(11)= {0}", StaticFiborial.FibonacciI(11))
            Console.WriteLine("FibRec(11)= {0}", StaticFiborial.FibonacciR(11))

            Console.WriteLine(ControlChars.CrLf & "Instance Class")
            ' Calling Instance Class and Methods 
            ' Need to instantiate before using. Calling method from instantiated object
            Dim ff As New InstanceFiborial()
            Console.WriteLine("FacImp(5) = {0}", ff.FactorialI(5))
            Console.WriteLine("FacRec(5) = {0}", ff.FactorialR(5))
            Console.WriteLine("FibImp(11)= {0}", ff.FibonacciI(11))
            Console.WriteLine("FibRec(11)= {0}", ff.FibonacciR(11))

            ' Create a (generic) list of integer values to test
            ' From 5 to 50 by 5
            Dim values As New List(Of Integer)
            For i = 5 To 50 Step 5
                values.Add(i)
            Next
            ' 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()
        End Sub
    End Module

End Namespace

And the Output is:

Imports System.Text
Imports System.Numerics

Namespace FiborialSeries

    Module Fiborial
        ' Using a StringBuilder as a list of string elements
        Function GetFactorialSeries(ByVal n As Integer) As String
            ' Create the String that will hold the list
            Dim series As 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 Step -1
                ' and append it to the list
                series.Append(i)
                If i > 1 Then
                    series.Append(" * ")
                Else
                    series.Append(" = ")
                End If
            Next
            ' 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()
        End Function

        ' Using a StringBuilder as a list of string elements
        Function GetFibonnaciSeries(ByVal n As Integer) As String
            ' Create the String that will hold the list
            Dim series As 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 Step 1
                If i < n Then
                    series.Append(", ")
                Else
                    series.Append(" = ")
                End If
                series.Append(Fibonacci(i))
            Next
            ' return the list as a string
            Return series.ToString()
        End Function

        Function Factorial(ByVal n As Integer) As BigInteger
            If n = 1 Then
                Return 1
            Else
                Return n * Factorial(n - 1)
            End If
        End Function

        Function Fibonacci(ByVal n As Integer) As Long
            If n < 2 Then
                Return 1
            Else
                Return Fibonacci(n - 1) + Fibonacci(n - 2)
            End If
        End Function
    End Module

    Module Program
        Sub Main()
            ' Printing Factorial Series
            Console.WriteLine()
            Console.WriteLine(Fiborial.GetFactorialSeries(5))
            Console.WriteLine(Fiborial.GetFactorialSeries(7))
            Console.WriteLine(Fiborial.GetFactorialSeries(9))
            Console.WriteLine(Fiborial.GetFactorialSeries(11))
            Console.WriteLine(Fiborial.GetFactorialSeries(40))
            ' Printing Fibonacci Series
            Console.WriteLine()
            Console.WriteLine(Fiborial.GetFibonnaciSeries(5))
            Console.WriteLine(Fiborial.GetFibonnaciSeries(7))
            Console.WriteLine(Fiborial.GetFibonnaciSeries(9))
            Console.WriteLine(Fiborial.GetFibonnaciSeries(11))
            Console.WriteLine(Fiborial.GetFibonnaciSeries(40))
        End Sub
    End Module

End Namespace

And the Output is:

Mixing Instance and Static/Shared 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, you cannot do that if instead of a Class you used a Module since a Module in VB.NET is like a Static Class in C#, and remember that a Static Class has the following characteristics:

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

Namespace FiborialExtrasVb2

    ' Instance Class
    Class Fiborial
        ' Instance Field
        Private _instanceCount As Integer
        ' Static/Shared Field
        Private Shared _staticCount As Integer
        ' Instance Read-Only Property
        ' Within instance members, you can always use  
        ' the "Me" reference pointer to access your (instance) members.
        Public ReadOnly Property InstanceCount() As Integer
            Get
                Return Me._instanceCount
            End Get
        End Property
        ' Static/Shared Read-Only Property
        ' Remeber that Properties are Methods to the CLR, so, you can also
        ' define static/shared properties for static/shared fields. 
        ' As with Static/Shared Methods, you cannot reference your class members
        ' with the "Me" reference pointer since static/shared members are not
        ' instantiated.
        Public Shared ReadOnly Property StaticCount() As Integer
            Get
                Return _staticCount
            End Get
        End Property
        ' Instance Constructor
        Public Sub New()
            Me._instanceCount = 0
            Console.WriteLine(ControlChars.CrLf & "Instance Constructor {0}",
                              Me._instanceCount)
        End Sub
        ' Static/Shared Constructor
        Shared Sub New()
            _staticCount = 0
            Console.WriteLine(ControlChars.CrLf & "Static/Shared Constructor {0}",
                              _staticCount)
        End Sub
        ' Instance Method
        Public Sub Factorial(ByVal n As Integer)
            Me._instanceCount += 1
            Console.WriteLine(ControlChars.CrLf & "Factorial({0})", n)
        End Sub
        ' Static/Shared Method
        Public Shared Sub Fibonacci(ByVal n As Integer)
            _staticCount += 1
            Console.WriteLine(ControlChars.CrLf & "Fibonacci({0})", n)
        End Sub
    End Class

    Module Program
        Sub Main()
            ' Calling Static/Shared Constructor and Methods
            ' No need to instantiate
            Fiborial.Fibonacci(5)

            ' Calling Instance Constructor and Methods
            ' Instance required
            Dim fib As New Fiborial()
            fib.Factorial(5)

            Fiborial.Fibonacci(15)
            fib.Factorial(5)

            ' Calling Instance Constructor and Methods
            ' for a second object
            Dim fib2 As New Fiborial()
            fib2.Factorial(5)

            Console.WriteLine()
            ' Calling Static/Shared 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)
        End Sub
    End Module

End Namespace

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 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.

Imports System.Diagnostics
Imports System.Numerics

Namespace FiborialExtrasCs3
    Module Program
        Sub Main()
            Dim timer As New Stopwatch()
            Dim facIntResult As System.Int64 = 0
            Dim facDblResult As System.Double = 0
            Dim facBigResult As System.Numerics.BigInteger = 0

            Console.WriteLine(ControlChars.CrLf & "Factorial using Int64")
            ' Benchmark Factorial using Int64
            ' Overflow Exception!!!
            Try
                For i = 5 To 50 Step 5
                    timer.Start()
                    facIntResult = FactorialInt64(i)
                    timer.Stop()
                    Console.WriteLine(" ({0}) = {1} : {2}", i, timer.Elapsed, facIntResult)
                Next
            Catch ex As OverflowException
                ' yummy ^_^
                Console.WriteLine(" Oops! {0} ", ex.Message)
            End Try
            Console.WriteLine(ControlChars.CrLf & "Factorial using Double")
            ' Benchmark Factorial using Double
            For i = 5 To 50 Step 5
                timer.Start()
                facDblResult = FactorialDouble(i)
                timer.Stop()
                Console.WriteLine(" ({0}) = {1} : {2}", i, timer.Elapsed, facDblResult)
            Next
            Console.WriteLine(ControlChars.CrLf & "Factorial using BigInteger")
            ' Benchmark Factorial using BigInteger
            For i = 5 To 50 Step 5
                timer.Start()
                facBigResult = FactorialBigInteger(i)
                timer.Stop()
                Console.WriteLine(" ({0}) = {1} : {2}", i, timer.Elapsed, facBigResult)
            Next
        End Sub
        'Long Factorial 
        Public Function FactorialInt64(ByVal n As Integer) As Int64
            If n = 1 Then
                Return 1
            Else
                Return n * FactorialInt64(n - 1)
            End If
        End Function
        ' Double Factorial 
        Public Function FactorialDouble(ByVal n As Integer) As Double
            If n = 1 Then
                Return 1
            Else
                Return n * FactorialDouble(n - 1)
            End If
        End Function
        ' BigInteger Factorial 
        Public Function FactorialBigInteger(ByVal n As Integer) As BigInteger
            If n = 1 Then
                Return 1
            Else
                Return n * FactorialBigInteger(n - 1)
            End If
        End Function
    End Module
End Namespace

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

And the Output is:

Factorial and Fibonacci in C#

2011-01-29T11:01:00.000-08:00

UPDATE: updated code examples and section using System.Numerics.BigInteger.

Here below a little program in C# 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 C#
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Numerics;

namespace FiborialCs
{
    // Static Class
    static class StaticFiborial
    {
        // Static Field
        static string className;
        // Static Constructor
        static StaticFiborial()
        {
            className = "Static Constructor";
            Console.WriteLine(className);            
        }
        // Static Method - Factorial Recursive
        public static BigInteger FactorialR(int n)
        {
            if (n == 1)
                return 1;
            else
                return n * FactorialR(n - 1);
        }
        // Static Method - Factorial Imperative
        public static BigInteger FactorialI(int n)
        {
            BigInteger res = 1;
            for (int i = n; i >= 1; i--)
            {                
                res *= 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<int> values)
        {            
            Stopwatch timer = new Stopwatch();
            int i, testValue;
            BigInteger facTimeResult = 0;
            long fibTimeResult = 0;
            i = testValue = 0;            
            
            // "Switch" Flow Constrol Statement
            switch (algorithm)
            {
                case 1:
                    Console.WriteLine("\nFactorial Imperative:");
                    // "For" Loop Statement
                    for (i = 0; i < values.Count; i++)
                    {                        
                        testValue = values[i];
                        // Taking Time
                        timer.Start();
                        facTimeResult = FactorialI(testValue);
                        timer.Stop();                        
                        // Getting Time
                        Console.WriteLine(" ({0}) = {1}", testValue, timer.Elapsed);
                    }                    
                    break;
                case 2:
                    Console.WriteLine("\nFactorial Recursive:");
                    // "While" Loop Statement
                    while (i < values.Count)
                    {                        
                        testValue = values[i];
                        // Taking Time
                        timer.Start();
                        facTimeResult = FactorialR(testValue);
                        timer.Stop();
                        // Getting Time
                        Console.WriteLine(" ({0}) = {1}", testValue, timer.Elapsed);
                        i++;
                    }
                    break;
                case 3:
                    Console.WriteLine("\nFibonacci Imperative:");
                    // "Do-While" Loop Statement
                    do {
                        testValue = values[i];
                        // Taking Time
                        timer.Start();
                        fibTimeResult = FibonacciI(testValue);
                        timer.Stop();
                        // Getting Time
                        Console.WriteLine(" ({0}) = {1}", testValue, timer.Elapsed);
                        i++;
                    } while (i < values.Count);
                    break;
                case 4:
                    Console.WriteLine("\nFibonacci Recursive:");
                    // "For Each" Loop Statement
                    foreach (int item in values)
                    {
                        testValue = item;
                        // Taking Time
                        timer.Start();
                        fibTimeResult = FibonacciR(testValue);
                        timer.Stop();
                        // Getting Time
                        Console.WriteLine(" ({0}) = {1}", testValue, timer.Elapsed);
                    }
                    break;
                default:
                    Console.WriteLine("DONG!");
                    break;
            }                
        }
    }

    // Instance Class
    public class InstanceFiborial
    {
        // Instance Field
        string className;
        // Instance Constructor
        public InstanceFiborial()
        {
            this.className = "Instance Constructor";
            Console.WriteLine(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);
        }
    }

    public class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("\nStatic Class");
            // Calling Static Class and Methods
            // No instantiation needed. Calling method directly from the class
            Console.WriteLine("FacImp(5) = {0}", StaticFiborial.FactorialI(5));
            Console.WriteLine("FacRec(5) = {0}", StaticFiborial.FactorialR(5));
            Console.WriteLine("FibImp(11)= {0}", StaticFiborial.FibonacciI(11));
            Console.WriteLine("FibRec(11)= {0}", StaticFiborial.FibonacciR(11));

            Console.WriteLine("\nInstance Class");
            // Calling Instance Class and Methods 
            // Need to instantiate before using. Calling method from instantiated object
            InstanceFiborial ff = new InstanceFiborial();
            Console.WriteLine("FacImp(5) = {0}", ff.FactorialI(5));
            Console.WriteLine("FacRec(5) = {0}", ff.FactorialR(5));
            Console.WriteLine("FibImp(11)= {0}", ff.FibonacciI(11));
            Console.WriteLine("FibRec(11)= {0}", ff.FibonacciR(11));

            // Create a (generic) list of integer values to test
            // From 5 to 50 by 5
            List<int> values = new List<int>();
            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
            Console.Read();
        }
    }
}

And the Output is:

using System;
using System.Text;
using System.Numerics;

namespace FiborialSeries
{    
    static class Fiborial
    {
        // Using a StringBuilder as a list of string elements
        public static string GetFactorialSeries(int n)
        {
            // Create the String that will hold the list
            StringBuilder 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 (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 StringBuilder as a list of string elements
        public static string GetFibonnaciSeries(int n)
        {
            // Create the String that will hold the list
            StringBuilder 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 (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 1;
            else
                return n * Factorial(n - 1);
        }

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

    class Program
    {
        static void Main(string[] args)
        {            
            // Printing Factorial Series
            Console.WriteLine();
            Console.WriteLine(Fiborial.GetFactorialSeries(5));
            Console.WriteLine(Fiborial.GetFactorialSeries(7));
            Console.WriteLine(Fiborial.GetFactorialSeries(9));
            Console.WriteLine(Fiborial.GetFactorialSeries(11));
            Console.WriteLine(Fiborial.GetFactorialSeries(40));
            // Printing Fibonacci Series
            Console.WriteLine();
            Console.WriteLine(Fiborial.GetFibonnaciSeries(5));
            Console.WriteLine(Fiborial.GetFibonnaciSeries(7));
            Console.WriteLine(Fiborial.GetFibonnaciSeries(9));
            Console.WriteLine(Fiborial.GetFibonnaciSeries(11));
            Console.WriteLine(Fiborial.GetFibonnaciSeries(40));
        }
    }
}

And the Output is:

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

using System;
namespace FiborialExtrasCs2
{
    // Instance Classes can have both: static and instance members. 
    // However, Static Classes only allow static members to be defined.
    // If you declare our next example class as static
    // (static class Fiborial) you will get the following compile error
    // Error: cannot declare instance members in a static class
    
    // Instance Class
    class Fiborial
    {
        // Instance Field
        private int instanceCount;
        // Static Field
        private static int staticCount;        
        // Instance Read-Only Property
        // Within instance members, you can always use  
        // the "this" reference pointer to access your (instance) members.
        public int InstanceCount
        {
            get { return 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 int StaticCount
        {
            get { return staticCount; }
        }
        // Instance Constructor
        public Fiborial()
        {
            this.instanceCount = 0;
            Console.WriteLine("\nInstance Constructor {0}", this.instanceCount);
        }
        // Static Constructor
        static Fiborial()
        {
            staticCount = 0;
            Console.WriteLine("\nStatic Constructor {0}", staticCount);
        }

        // Instance Method
        public void Factorial(int n)
        {
            this.instanceCount += 1;
            Console.WriteLine("\nFactorial({0})", n);
        }

        // Static Method
        public static void Fibonacci(int n)
        {
            staticCount += 1;
            Console.WriteLine("\nFibonacci({0})", n);
        }                
    }
    
    class Program
    {
        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);
            
            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:

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 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.

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

namespace FiborialExtrasCs3
{
    class Program
    {
        static void Main(string[] args)
        {
            Stopwatch timer = new Stopwatch();
            System.Int64 facIntResult = 0;
            System.Double facDblResult = 0;
            System.Numerics.BigInteger facBigResult = 0;

            Console.WriteLine("\nFactorial using Int64");
            // Benchmark Factorial using Int64
            for (int i = 5; i <= 50; i += 5)
            {
                timer.Start();
                facIntResult = FactorialInt64(i);
                timer.Stop();
                Console.WriteLine(" ({0}) = {1} : {2}", i, timer.Elapsed, facIntResult);
            }
            Console.WriteLine("\nFactorial using Double");
            // Benchmark Factorial using Double
            for (int i = 5; i <= 50; i += 5)
            {
                timer.Start();
                facDblResult = FactorialDouble(i);
                timer.Stop();
                Console.WriteLine(" ({0}) = {1} : {2}", i, timer.Elapsed, facDblResult);
            }
            Console.WriteLine("\nFactorial using BigInteger");
            // Benchmark Factorial using BigInteger
            for (int i = 5; i <= 50; i += 5)
            {
                timer.Start();
                facBigResult = FactorialBigInteger(i);
                timer.Stop();
                Console.WriteLine(" ({0}) = {1} : {2}", i, timer.Elapsed, facBigResult);
            }
        }

        // Long Factorial 
        public static Int64 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 1;
            else
                return n * FactorialBigInteger(n - 1);
        }
    }
}

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

And the Output is:

New Series - Factorial and Fibonacci

2011-01-25T15:06:00.000-08:00

I'm going to start a new series of posts called "Factorial and Fibonacci in [Language]". As with my previous 2 series, "OO Hello World" and "Language's Basics by Example", my aim is to show programming language's basic features, and as such, I will be showing stuff such as: static members, instance member, recursion, more loops and conditional constructs, and whatever else comes up. The idea is to write a simple OO program that implements the Factorial and Fibonacci algorithms in a Functional (Recursion) and Imperative (Statements-Loops) way using static methods and fields plus different loop statements such as Do, While, For, For each, etc. I will also add the Timer classes provided by the language's framework to count how much time those algorithms take (benchmark?) and do some comparison of the timing by language.

From now on, I will not be including 2 versions of the same program. First, to save some space and second, because counting keywords is not the main topic anymore. So, a mix of minimal and verbose syntax in each of the languages will be used instead.

The languages:
.NET/CLR: C#, VB.NET, C++/CLI, F#, Boo, Phalanger, IronPython, IronRuby, Delphi Prism, Zonnon, Nemerle, Cobra, JScript.NET
Java/JVM: Groovy, Java, Jython, JRuby, Fantom, Scala, JavaFX, Gosu

The Program's Structure will be (more or less) as follows:

// Factorial and Fibonacci in Language
    // Static Class
        // Static Fields
        // Static Constructor
        // Static Method 1
            // Recursive Fibonacci
        // Static Method 2
            // Imperative Fibonacci
        // Static Method 3
            // Recursive Factorial
        // Static Method 4
            // Imperative Factorial
        // Static Method 5
            // For Loop Range
                // Start Timer
                // Call Static Method: Recursive Fibonacci
                // Stop Timer
                // Print Result
            // While Loop Range
                // Start Timer
                // Call Static Method: Imperative Fibonacci
                // Stop Timer
                // Print Result
            // Do Loop Range
                // Start Timer
                // Call Static Method: Recursive Factorial
                // Stop Timer
                // Print Result
            // For Each Loop Range
                // Start Timer
                // Call Static Method: Imperative Factorial
                // Stop Timer
                // Print Result

    // Instance Class
        // Instance Fields
        // Instance Constructor
        // Instance Method 1
            // Call Static Recursive Fibonacci
        // Instance Method 2
            // Call Static Imperative Fibonacci
        // Instance Method 3
            // Call Static Recursive Factorial
        // Instance Method 4
            // Call Static Imperative Factorial

    // Console Program/Script
        // Calling Static Class and Methods
        // Calling Instance Class and Methods
        // Create a List of values to test
        // Benchmarking Fibonacci
        // Call Factorial Imperative
        // Call Factorial Recursive
        // Benchmarking Factorial
        // Call Fibonacci Imperative
        // Call Fibonacci Recursive
        // Stop and exit

And here below some definitions of the new concepts:

Factorial
"In mathematics, the factorial of a positive integer n,[1] denoted by n!, is the product of all positive integers less than or equal to n. For example:

5! = 5 x 4 x 3 x 2 x 1 = 120

0! is a special case that is explicitly defined to be 1."
Taken from: http://en.wikipedia.org/wiki/Factorial#Definition

Fibonacci
"In mathematics, the Fibonacci numbers are the numbers in the following integer sequence:

0,1,1,2,3,5,8,13,21,34,55,89,144, ...

By definition, the first two Fibonacci numbers are 0 and 1, and each subsequent number is the sum of the previous two. Some sources omit the initial 0, instead beginning the sequence with two 1s." Taken from: http://en.wikipedia.org/wiki/Fibonacci_series

Recursion
"Recursion is the process of repeating items in a self-similar way. For instance, when the surfaces of two mirrors are exactly parallel with each other the nested images that occur are a form of infinite recursion. The term has a variety of meanings specific to a variety of disciplines ranging from linguistics to logic. The most common application of recursion is in mathematics and computer science, in which it refers to a method of defining functions in which the function being defined is applied within its own definition; specifically it is defining an infinite statement using finite components." Taken from: http://en.wikipedia.org/wiki/Recursion

Imperative
"In computer science, imperative programming is a programming paradigm that describes computation in terms of statements that change a program state. In much the same way that imperative mood in natural languages expresses commands to take action, imperative programs define sequences of commands for the computer to perform." Taken from: http://en.wikipedia.org/wiki/Imperative_programming

Static Class
"A class can be declared static, indicating that it contains only static members. It is not possible to create instances of a static class using the new keyword.

Use a static class to contain methods that are not associated with a particular object. For example, it is a common requirement to create a set of methods that do not act on instance data and are not associated to a specific object in your code. You could use a static class to hold those methods.

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 (C# Programming Guide).

Creating a static class is therefore much the same as creating a class that contains only static members and a private constructor. A private constructor prevents the class from being instantiated.

The advantage of using a static class is that the compiler can check to make sure that no instance members are accidentally added. The compiler will guarantee that instances of this class cannot be created.

Static classes are sealed and therefore cannot be inherited. Static classes cannot contain a constructor, although it is still possible to declare a static constructor to assign initial values or set up some static state." Taken from: http://msdn.microsoft.com/en-us/library/79b3xss3(v=vs.80).aspx

Static Variable
"In computer programming, a static variable is a variable that has been allocated statically — whose lifetime extends across the entire run of the program. This is in contrast to the more ephemeral automatic variables (local variables), whose storage is allocated and deallocated on the call stack; and in contrast to objects whose storage is dynamically allocated." Taken from: http://en.wikipedia.org/wiki/Static_variable#Static_Variables_as_Class_Variables

Static Method
"In object-oriented programming, a method is a subroutine that is exclusively associated either with a class (in which case it is called a class method or a static method) or with an object (in which case it is an instance method).

As mentioned above, a method may be declared as static, meaning that it acts at the class level rather than at the instance level. Therefore, a static method cannot refer to a specific instance of the class (i.e. it cannot refer to this, self, Me, etc.), unless such references are made through a parameter referencing an instance of the class, although in such cases they must be accessed through the parameter's identifier instead of this. Most importantly there is no need to make an object for accessing data .i.e. without creating an object we can access the data members of a static class." Taken from: http://en.wikipedia.org/wiki/Static_method#Static_methods

Static Constructor
"A static constructor is a static data initializer. Static constructors allow complex static variable initialization.[1] Static constructors can be called once and call is made implicitly by the run-time right before the first time the class is accessed. Any call to a class (static or constructor call), triggers the static constructor execution. Static constructors are thread safe and are a great way to implement a singleton pattern. When used in a generic programming class, static constructors are called on every new generic instantiation one per type (static variables are instantiated as well)." Taken from:http://en.wikipedia.org/wiki/Constructor_(object-oriented_programming)#C.23_static_constructor

Benchmark
"In computing, a benchmark is the act of running a computer program, a set of programs, or other operations, in order to assess the relative performance of an object, normally by running a number of standard tests and trials against it. The term 'benchmark' is also mostly utilized for the purposes of elaborately-designed benchmarking programs themselves." Taken from: http://en.wikipedia.org/wiki/Benchmark_(computing)

return;

Counting Source Code Keywords using Python 3

2011-01-15T15:14:00.000-08:00

Now that I finished my last post about counting keywords in source code, I will give away the little script I did to help me with the counting. It definitively requires some improvements to cover some extra cases I did not consider, but it work just fine if you manage to avoid them... or even better, implement them yourself :D

1. Multi-line comments are not supported. If there are reserved words within the comments, they will be counted as keywords. But worry not; single line comments work fine.

2. Text literals are not supported. If there are reserved words within the string, they will be counted as keywords.

I think regular expressions can handle those 2 cases. I'll add those two features if I need them in the future.

The programming language used was Python version 3.1.3

I formatted some parts of the code to correctly display it using the size limit of this blog's page. For instance, if the script doesn't compile; try using one line comma separated lists and if statements.

I think the code is simple and very easy to read... that's what all programmers say about their own code, right? Anyway, here below, I will begin by showing, function by function, the code of the script including lots of unnecessary comments and some screen shots that help explain what it does. Next, I will show a complete example of how to use it and the output.
The complete script without comments it's available at the bottom of this post.

Dissecting the Script

# import from sys to handle script's (command line) parameters
import sys
# get_line_comment_char function returns the Language's single 
# line character(s)
# only one "single comments character" is taken in consideration 
# even if the language supports multiple single line comments
# I grouped languages using the same comment character to reduce 
# the number of ifs
def get_line_comment_char(language):
    language = language.lower()    
    if language in ('c#', 'csharp', 'cpp', 'cppcli', 'c++', 'c++cli', 'f#', 
                    'fsharp', 'boo', 'phalanger', 'php', 'delphiprism', 'delphi', 
                    'nemerle', 'groovy', 'java', 'fantom', 'fan', 'jscript', 
                    'jscriptnet', 'scala', 'javafx', 'javafxscript', 'gosu'):
        return '//'
    elif language in ('vb', 'vbnet', 'visualbasic'):
        return '\''
    elif language in ('jython', 'ironpython', 'python', 'jruby', 'ironruby', 
                    'ruby', 'cobra'):
        return '#'        
    elif language in ('zonnon'):
        return '(*'
    return None

Example:

# get_language_keywords function returns a list of all the 
# keywords (reserved words) for the given language
# except for the primitive types since I didn't consider them 
# as keywords for my comparison purposes
# if you need them, you can take the complete keywords lists 
# this blog's Keywords page
# I removed the lists to save space because it makes the program
# too long and less readable, so, in the function below, 
# for every ocurrence of keywords = '' you change '' with the list 
# of keywords of that language.
def get_language_keywords(language):
    language = language.lower()    
    if language == 'c#' or language == 'csharp':
        keywords = '' 
    elif language == 'vb' or language == 'vbnet' 
        or language == 'visualbasic':        
        keywords = '' 
    elif language == 'cpp' or language == 'cppcli' 
        or language == 'c++' or language == 'c++cli':
        keywords = '' 
    elif language == 'f#' or language == 'fsharp':        
        keywords = '' 
    elif language == "boo":
        keywords = '' 
    elif language == 'phalanger' or language == 'php':
        keywords = '' 
    elif language == 'jython' or language == 'ironpython' 
        or language == 'python':        
        keywords = '' 
    elif language == 'jruby' or language == 'ironruby' 
        or language == 'ruby':
        keywords = '' 
    elif language == 'delphiprism' or language == 'delphi':
        keywords = '' 
    elif language == 'zonnon':
        keywords = '' 
    elif language == 'nemerle':
        keywords = '' 
    elif language == 'groovy':
        keywords = '' 
    elif language == 'java':
        keywords = '' 
    elif language == 'cobra':
        keywords = '' 
    elif language == 'fantom' or language == 'fan':
        keywords = '' 
    elif language == 'jscript' or language == 'jscriptnet':
        keywords = '' 
    elif language == 'scala':
        keywords = '' 
    elif language == 'javafx' or language == 'javafxscript':
        keywords = '' 
    elif language == 'gosu':
        keywords = '' 
    else:
        keywords = ''
    return keywords.split()

Example:

# is_keyword function returns true if the given keyword is a 
# valid keyword in the given language
def is_keyword(key, language_keys):    
    if key in language_keys:
        return True
    return False

Example:

# remove_special_characters function removes special characters 
# from the given text and returns the resulting sequence
# special characters includes open and closing blocks, 
# operators, and so on (see the list below).
def remove_special_characters(text):
    special_characters = ('(','[','{','}',']',')','+','-','*','/','=','^','&',
                        '%','$','#','@','!','~','\'','\"', '?', '>', '<', ':', 
                        ';', ',', '.')
    for character in special_characters:
        text = text.replace(character, ' ')
    return text

Example:

# remove_duplicates_in_list function removes any duplicate value 
# found in the given sequence and returns the resulting sequence
def remove_duplicates_in_list(sequence):
    # Thanks to Dave Kirby for this function taken from comments in 
    # http://www.peterbe.com/plog/uniqifiers-benchmark 
    seen = set()
    seen_add = seen.add
    return [x for x in sequence if x not in seen and not seen_add(x)]

Example:

# count_ocurrences_in_list function returns a new list of paired values 
# that contain the keyword and how many times it appeared in the code
# using the standard count method of the sequences types
def count_ocurrences_in_list(sequence):
    totals_by_word = []
    no_duplicates = remove_duplicates_in_list(sequence)
    for word in no_duplicates:
        totals_by_word.append((word,sequence.count(word)))
    return totals_by_word

Example:

# print_results function prints the given sequence to the console
# It displays the list of Keyword and Total Number of Keywords
def print_results(sequence):
    print('', end='\n')    
    for item in sequence:
        print('%s, %s' % (item[0], item[1]))

Example:

# print_to_file function creates an output file and prints the given 
# sequence into it. 
# It writes the list of Keyword and Total Number of Keywords
def print_to_file(sequence, output):
    with open(output, mode='w', encoding='utf-8') as output_file:
        output_file.write('\n')
        for item in sequence:
            output_file.write('%s, %s\n' % (item[0], item[1]))

Example:

Output:

Opening CSV:

# Main function. The program's entry point.
def main(argv=None):
    # if command line arguments are not empty
    if argv is None:
        # assign them to the local sequence variable argv
        argv = sys.argv
    
    # validate the script was used correctly. 
    if len(argv) != 4:
        # Otherwise, print the usage message to the console
        print("usage: program language sourcefile outputfile")
        # and exit the script
        sys.exit()

Example:

# get command line arguments
    # parameter 2 should be the language of the source code you want to count
    programming_language = sys.argv[1]    
    # parameter 3 should be the file that contains the source code you want to count
    source_file = sys.argv[2]    
    # parameter 4 should be the file that will contain the counting results
    output_file = sys.argv[3]     
    # get the list of reserved words for the given programming language
    language_keywords = get_language_keywords(programming_language)
    # get the single line comment character for the given programming language
    comment_character = get_line_comment_char(programming_language)

Example:
Here I added some print() and exit() to stop execution of the script

# define a variable that will hold the total number of keywords found in the file
    total_keywords_found = 0
    # define a list that will store all valid language keywords found in the file
    list_of_keywords_found = []

line_number = 0
    # open a file as read only (default mode)
    with open(source_file, encoding='utf-8') as source_code:
        # navigate through the lines of the file
        for line in source_code:
            # get the line number. Used only for console display purposes
            line_number += 1

Example:
The following line adds the line number to the beginning of the line being read
print('{:>4} {}'.format(line_number, line.rstrip()), end='\n')

# remove line comment if there is one based on the 
            # language's single line comment character  
            comment_idx = line.find(comment_character)
            if comment_idx >= 0:
                line = line[0:comment_idx]

Example:

# remove special characters from remaining text in line 
            # (operators and open-close characters)
            line = remove_special_characters(line)
            # create a list with all remaining words in the line
            words = line.split()

Example:

# navigate through the words of the sequence
            for word in words:
                # if the current word is a valid keyword for the 
                # given language
                if is_keyword(word, language_keywords):                    
                    # add to the list of 
                    # "total keywords found in the source code" the word
                    list_of_keywords_found.append(word)
                    # increment the number of total words found 
                    # in the source code
                    total_keywords_found = total_keywords_found + 1

Example:

# define a list that will store all paired 
    # values (keyword and total ocurrences of that keyword)
    totals_to_output = []    
    # insert first pair of values as the first element of the list, 
    # that is the Programming Language and the Total Keywords found
    totals_to_output.append((programming_language.capitalize(),str(total_keywords_found)))
    # insert all other pairs of values (keyword and total ocurrences 
    # of that keyword) found on the source code
    totals_to_output.extend(count_ocurrences_in_list(list_of_keywords_found))

Example:

# print the results to the console
    print_results(totals_to_output)
    # print the results to the output file
    print_to_file(totals_to_output, output_file)

# run the program
if __name__ == "__main__":    
    main()

Example:

Using the Script

How to use is was already shown in the step by step example above, but here below I just show you how I did the counting for my previous post "Keywords in source code Round 2"

First I created 2 folders:
1. SrcCode
2. OutCode

Then, I added all the source code files I wanted to count from into the SrcCode folder.

Next step was to create a batch file that runs the python script for all the files in the SrcCode folder.

And ran it

Console Output

Files Output in folder OutCode

Et Voilà! I then started merging together the results and did the graphs.

Hope this script works for you or at least shows you some cool python features :)

Final Script

Just don't forget to add the language keywords! take them from the Keywords Page.
Example:
keywords = 'public private static internal for if else while switch'

import sys

def get_line_comment_char(language):
    language = language.lower()    
    if language in ('c#', 'csharp', 'cpp', 'cppcli', 'c++', 'c++cli', 'f#', 
                    'fsharp', 'boo', 'phalanger', 'php', 'delphiprism', 'delphi', 
                    'nemerle', 'groovy', 'java', 'fantom', 'fan', 'jscript', 
                    'jscriptnet', 'scala', 'javafx', 'javafxscript', 'gosu'):
        return '//'
    elif language in ('vb', 'vbnet', 'visualbasic'):
        return '\''
    elif language in ('jython', 'ironpython', 'python', 'jruby', 'ironruby', 
                    'ruby', 'cobra'):
        return '#'        
    elif language in ('zonnon'):
        return '(*'
    return None

def get_language_keywords(language):
    language = language.lower()    
    if language == 'c#' or language == 'csharp':
        keywords = '' 
    elif language == 'vb' or language == 'vbnet' 
        or language == 'visualbasic':        
        keywords = '' 
    elif language == 'cpp' or language == 'cppcli' 
        or language == 'c++' or language == 'c++cli':
        keywords = '' 
    elif language == "f#" or language == "fsharp":        
        keywords = '' 
    elif language == "boo":
        keywords = '' 
    elif language == 'phalanger' or language == 'php':
        keywords = '' 
    elif language == 'jython' or language == 'ironpython' 
        or language == 'python':        
        keywords = '' 
    elif language == 'jruby' or language == 'ironruby' 
        or language == 'ruby':
        keywords = '' 
    elif language == 'delphiprism' or language == 'delphi':
        keywords = '' 
    elif language == 'zonnon':
        keywords = '' 
    elif language == 'nemerle':
        keywords = '' 
    elif language == 'groovy':
        keywords = '' 
    elif language == 'java':
        keywords = '' 
    elif language == 'cobra':
        keywords = '' 
    elif language == 'fantom' or language == 'fan':
        keywords = '' 
    elif language == 'jscript' or language == 'jscriptnet':
        keywords = '' 
    elif language == 'scala':
        keywords = '' 
    elif language == 'javafx' or language == 'javafxscript':
        keywords = '' 
    elif language == 'gosu':
        keywords = '' 
    else:
        keywords = ''
    return keywords.split()

def is_keyword(key, language_keys):    
    if key in language_keys:
        return True
    return False

def remove_special_characters(text):
    special_characters = ('(','[','{','}',']',')','+','-','*','/','=','^','&',
                        '%','$','#','@','!','~','\'','\"', '?', '>', '<', ':', 
                        ';', ',', '.')
    for character in special_characters:
        text = text.replace(character, ' ')
    return text

def remove_duplicates_in_list(sequence):
    seen = set()
    seen_add = seen.add
    return [x for x in sequence if x not in seen and not seen_add(x)]

def count_ocurrences_in_list(sequence):
    totals_by_word = []
    no_duplicates = remove_duplicates_in_list(sequence)
    for word in no_duplicates:
        totals_by_word.append((word,sequence.count(word)))
    return totals_by_word

def print_results(sequence):
    print('', end='\n')    
    for item in sequence:
        print('%s, %s' % (item[0], item[1]))    

def print_to_file(sequence, output):
    with open(output, mode='w', encoding='utf-8') as output_file:
        output_file.write('\n')
        for item in sequence:
            output_file.write('%s, %s\n' % (item[0], item[1]))

def main(argv=None):
    if argv is None:
        argv = sys.argv
    
    if len(argv) != 4:
        print("usage: program language sourcefile outputfile")
        sys.exit()

    programming_language = sys.argv[1]    
    source_file = sys.argv[2]    
    output_file = sys.argv[3]     
    
    language_keywords = get_language_keywords(programming_language)
    comment_character = get_line_comment_char(programming_language)
    
    total_keywords_found = 0
    list_of_keywords_found = []
    
    line_number = 0
    with open(source_file, encoding='utf-8') as source_code:
        for line in source_code:
            line_number += 1
            comment_idx = line.find(comment_character)
            if comment_idx >= 0:
                line = line[0:comment_idx]
            line = remove_special_characters(line)
            words = line.split()
            for word in words:
                if is_keyword(word, language_keywords):                    
                    list_of_keywords_found.append(word)
                    total_keywords_found = total_keywords_found + 1

    totals_to_output = []    
    totals_to_output.append((programming_language.capitalize(),str(total_keywords_found)))
    totals_to_output.extend(count_ocurrences_in_list(list_of_keywords_found))
    
    print_results(totals_to_output)
    print_to_file(totals_to_output, output_file)
    
if __name__ == "__main__":    
    main()

How many keywords in your source code? Round 2

2011-01-14T14:23:00.000-08:00

Last year, in July 2011, I wrote a post about How many keywords do you type in your code?.

"Have you ever wondered how many keywords (reserved words) do you type in your programs? Can you type more or type less without changing what your program does? Can you change programming language and save some typing? And if so, to which language?".

Back then, I tried to answer those questions by showing some comparative graphics with the number of keywords needed to build 2 versions (minimal and verbose) of the same little program in 20 different programming languages (C#, VB.NET, C++/CLI, F#, Boo, Phalanger, IronPython, IronRuby, Delphi Prism, Zonnon, Nemerle, Cobra, JScript.NET, Java, JavaFX, Groovy, Jython, JRuby, Fantom, Scala).

The program I chose was an OO version of the famous Hello World (Archive posts June-July 2010) and had the following structure:

// OO Hello World
    // Import,using,etc.
    // Class
        // Field
        // Constructor
        // Method
    // Program
        // Instantiate Class
        // Call Method = OUTPUT (Hello, World!)

Finally, I added some comments and thoughts about the results, but... What if we do the same with a bigger example? Will the results be more or less the same if I a more elaborated program is used to do the comparison? Do the most verbose language and the most minimalistic of the previous post will still hold the title?

That's exactly what this new post is all about! :) a new comparison on a more elaborated, still small, program using many more language constructs following the sample rules of the previous comparison:

2 Versions Minimal and Verbose.
21 Programming Languages (the previous 20 + Gosu).
Primitive Types such as int, float, double, string not considered as keywords.
Same OO program and structure (taken from series Language's Basics by Example).
OO Hello World was small enough to count by hand, but this time I created a little script written in Python 3 that does the automatic counting for me :) (source code to be provided in my next post).

// Language Basics
    // Greet Class
        // Fields or Attributes
        // Properties
        // Constructor
        // Overloaded Constructor
        // Method 1
            // "if-then-else" statement
        // Method 2
            // "for" statement
        // Overloaded Method 2.1
            // "while" statement
        // Overloaded Method 2.2
            // use Date Class
            // "switch/case" statement

    // Console Program
        // Define object of type Greet 
        // Instantiate Greet. Call Constructor
        // Call Set Properties
        // Call Method 2
        // Call Method 2.1 and Get Properties
        // Call Method 2.2
        // Stop and exit - Read Input From Console

Here below th graphs! Click on the images to enlarge.

Total Keywords by Language

Language	Keywords
IronPython	31
Jython	31
IronRuby	38
JRuby	38
Scala	40
Fantom	46
Java	50
Zonnon	50
Gosu	53
Groovy	57
Nemerle	59
Boo	66
JavaFX	70
JScript.NET	75
C++/CLI	84
Phalanger	92
F#	97
C#	102
Delphi Prism	134
VB.NET	137
Cobra	139

Version 1 (Minimal)

Language	Keywords
VB.NET	130
Delphi Prism	94
Phalanger	89
Cobra	79
JScript.NET	72
Groovy	72
Gosu	72
C#	69
Boo	68
Zonnon	66
Java	65
JavaFX	64
C++/CLI	59
Jython	51
IronPython	48
JRuby	46
IronRuby	46
Fantom	46
F#	41
Scala	37
Nemerle	33

Version 2 (Verbose)

Language	Keywords
VB.NET	169
Delphi Prism	134
JScript.NET	118
Gosu	114
Boo	114
Cobra	109
JavaFX	105
Phalanger	103
Java	103
C#	103
Groovy	101
C++/CLI	101
Zonnon	90
Fantom	80
Nemerle	67
F#	54
Jython	53
IronPython	50
JRuby	48
IronRuby	48
Scala	41

Both (Minimal and Verbose)

Language	Minimal	Verbose
VB.NET	130	169
Delphi Prism	94	134
Phalanger	89	103
Cobra	79	109
JScript.NET	72	118
Groovy	72	101
Gosu	72	114
C#	69	103
Boo	68	114
Zonnon	66	90
Java	65	103
JavaFX	64	105
C++/CLI	59	101
Jython	51	53
IronPython	48	50
JRuby	46	48
IronRuby	46	48
Fantom	46	80
F#	41	54
Scala	37	41
Nemerle	33	67

Compare Basics and HelloWorld (Minimal and Verbose)

Language\|	Basics Minimal\|	Basics Verbose\|	Basics Differ\|	Hello Minimal\|	Hello Verbose\|	Hello Differ\|
VB.NET	130	169	39	24	34	10
Delphi Prism	94	134	40	35	39	4
Phalanger	89	103	14	10	16	6
Cobra	79	109	30	9	14	5
JScript.NET	72	118	46	7	15	8
Groovy	72	101	29	5	11	6
Gosu	72	114	42	5	13	8
C#	69	103	34	10	15	5
Boo	68	114	46	7	17	10
Zonnon	66	90	24	16	21	5
Java	65	103	38	12	16	4
JavaFX	64	105	41	5	15	10
C++/CLI	59	101	42	11	16	5
Jython	51	53	2	4	6	2
IronPython	48	50	2	4	6	2
JRuby	46	48	2	6	6	0
IronRuby	46	48	2	6	6	0
Fantom	46	80	34	5	9	4
F#	41	54	13	5	12	7
Scala	37	41	4	5	10	5
Nemerle	33	67	34	9	16	7

CONCLUSIONS

As with the previous post, we can still notice the 3 main groups of languages:
1. Scripting/Dynamic Languages (Python, Ruby, Groovy, etc.) fewer keywords
2. Functional Languages (F#, Scala, Nemerle, etc.) more or less than the previous group
3. Imperative/Static Languages (C#, C++, VB.NET, Java, etc.) more keywords

We can also see that the scripting/dynamic languages are the ones that define the fewer keywords and that's probably the reason why there are few or no difference in the number of keywords typed between the 2 versions of the same program (see latest graph above).

The difference between the number of keywords of the most verbose and the most minimalistic program is of:
Basics Minimal: VB.NET 130 vs Nemerle 33 (97 keys of difference)
Basics Verbose: VB.NET 169 vs Scala 41 (128 keys of difference)
Big differences... and they could be much bigger if we include primitive types as keywords (because they are keywords, but were excluded for this comparison)

When comparing a small program such as the OO Hello World in which didn't use many language constructs we still saw a big difference between the most verbose and the most minimalistic languages. That is still true when many more statements and constructs are added to the code as in the case of: Delphi Prism and VB.NET, however, this time we can clearly see that the most verbose language is not Delphi Prism but VB.NET!!!

So, VB.NET congratulations! You are the most extra-typing language among the .NET and Java languages. I guess that's why Visual Studio 2010 auto-completes all the closing blocks keywords :D so you don't need to type that many... I'm wondering what about those programmers that love to code in raw text using notepad(++?)... I guess those brave of hearth do not program using VB. Am I right?

Nevertheless, I'm very curious about running the keywords counting on a Real Life program (hundreds-thousands lines of code) and see what the result is.

And now, about the most minimalistic language? Well, this time was Nemerle, followed by Scala and F#. The 3 languages are multi-paradigm languages, but are mainly inspired by the Functional ones, so we can probably assume that functional languages use less keywords, less typing even if using their OO syntax features; that's probably why there are lots of blog posts about the difference in amount of code between Scala and Java; of course they always compare Java's Imperative syntax vs Scala's Functional syntax, which is fare enough because Scala is meant to be used as a functional language. Right? So, in summary, using OO or Functional syntax, you will usually have smaller programs. Of course, that depends how you write code and if you use, let's say, match-case instead of if-then-else.

So what happened to the Scripting languages? weren't they the ones with smaller keywords sets? and I'm not talking about Groovy because remember that Groovy needs to be Java syntax compatible, but Python and Ruby?

Let's have a look:

Ruby 48

module 1
class 1
def 11 # this is understandable
end 17 # and here is where the most keyword go! 
if 1
return 2
else 2
for 1
in 1
while 1
do 1
case 1 # using the case construct also requires lots of keys because 
when 4 # it uses when and then for each case you want to validate against
then 4 #

IronPython 50

import 2
from 1
class 1
def 12  # this is understandable
return 5
if 2
else 2
for 1
in 1
print 4  # print is a keyword but other languages use  
           # Console.WriteLine | System.out.println 
while 1
or 16 # and here is where the most keyword go because 
           # python has no switch | case | match syntax 
elif 2

What else... oh yes. Verbosity of the language has nothing to do with its elegance or expressiveness (for instance Delphi Prism vs Scala|F#).

Finally, counting keywords in your code is probably not relevant, because it will vary a lot between programs, styles, paradigms, if code was automatically generated, manually typed, and so on.
In my case I used the 2 edges to compare the "Minimal" and "Verbose", but in real coding a combination based on the above might be used.

That's pretty much it.

Here below I added the counting results for all the 21 languages in case you wonder which keywords

Basics Minimal

Basics Verbose

Boo 68

Boo 114

import 1
class 1
as 17
get 3
return 5
set 3
def 6
constructor 2
self 4
private 1
if 2
else 2
for 1
in 1
while 1
or 16
elif 2

namespace 1
import 1
private 5
class 1
as 24
public 9
get 3
return 5
self 28
set 3
def 7
constructor 2
if 2
else 2
for 1
in 1
while 1
or 16
elif 2

Basics Minimal

Basics Verbose

Cobra 79

Cobra 109

class 2
var 3
pro 3
as 12
get 3
return 5
set 3
cue 2
base 2
def 5
is 1
private 1
if 1
else 2
for 1
in 1
print 4
while 1
branch 1
on 4
or 20
any 1
to 1

use 1
namespace 1
class 2
is 12
public 10
var 3
as 18
pro 3
get 3
return 5
set 3
cue 2
base 2
def 5
private 1
if 1
else 2
for 1
in 1
print 4
while 1
branch 1
on 4
or 20
shared 1
any 1
to 1

Basics Minimal

Basics Verbose

C++/CLI 59

C++/CLI 101

using 1
namespace 1
class 1
public 2
property 3
return 5
void 6
this 3
private 1
if 1
else 1
for 1
while 1
switch 1
case 24
break 5
default 1
gcnew 1

using 1
namespace 2
private 5
class 1
public 14
property 3
return 6
this 27
void 6
if 1
else 1
for 1
while 1
switch 1
case 24
break 5
default 1
gcnew 1

Basics Minimal

Basics Verbose

C# 69

C# 103

using 1
class 2
public 8
get 3
return 5
set 3
value 3
this 3
if 1
else 1
void 4
for 1
while 1
switch 1
case 24
break 5
default 1
static 1
new 1

using 1
namespace 1
internal 2
class 2
private 4
public 9
get 3
return 5
this 29
set 3
value 3
if 1
else 1
void 4
for 1
while 1
switch 1
case 24
break 5
default 1
static 1
new 1

Basics Minimal

Basics Verbose

DelphiPrism 94

DelphiPrism 134

namespace 1
interface 1
uses 1
type 2
class 4
private 1
method 14
public 2
property 3
read 3
write 3
constructor 4
end 17
array 2
of 3
implementation 1
begin 13
if 1
then 1
result 2
else 2
for 1
to 2
step 1
do 2
var 3
while 1
case 1
new 1
exit 1

namespace 1
interface 1
uses 1
type 2
public 11
class 4
private 6
var 6
method 14
property 3
read 3
write 3
constructor 4
end 17
array 2
of 3
implementation 1
begin 13
self 23
if 1
then 1
result 2
else 2
for 1
to 2
step 1
do 2
while 1
case 1
new 1
exit 1

Basics Minimal

Basics Verbose

Fantom 46

Fantom 80

class 2
private 4
return 5
it 3
new 1
if 1
else 1
for 1
while 1
switch 1
case 24
default 1
static 1

internal 1
class 2
private 4
public 9
return 5
this 24
it 3
new 1
if 1
else 1
for 1
while 1
switch 1
case 24
default 1
static 1

Basics Minimal

Basics Verbose

F# 42

F# 54

open 1
type 1
let 9
mutable 4
member 7
with 4
and 3
new 2
private 1
if 1
then 1
else 1
for 1
to 2
do 2
while 1
match 1

namespace 1
open 1
type 1
public 8
class 1
let 9
mutable 4
member 7
with 4
and 3
new 2
private 1
if 1
then 1
else 1
for 1
to 2
do 2
while 1
match 1
end 1
module 1

Basics Minimal

Basics Verbose

Gosu 72

Gosu 114

uses 4
class 1
var 8
property 6
get 4
return 5
set 3
private 1
function 4
else 1
for 1
while 1
new 3
switch 1
case 24
break 4
default 1

uses 4
public 12
class 1
private 4
var 8
property 6
get 4
return 5
this 27
set 3
function 4
else 1
for 1
while 1
new 3
switch 1
case 24
break 4
default 1

Basics Minimal

Basics Verbose

Groovy 72

Groovy 101

class 1
private 4
def 20
return 5
this 3
if 1
else 1
for 1
in 2
while 1
new 3
switch 1
case 24
break 4
default 1

package 1
public 12
class 1
private 4
return 5
this 29
void 6
def 3
if 1
else 1
for 1
in 2
while 1
new 3
switch 1
case 24
break 5
default 1

Basics Minimal	Basics Verbose
IronPython 48	IronPython 50
from 1 import 1 class 1 def 11 return 5 if 2 else 2 for 1 in 1 print 4 while 1 or 16 elif 2	import 2 from 1 class 1 def 12 return 5 if 2 else 2 for 1 in 1 print 4 while 1 or 16 elif 2

Basics Minimal	Basics Verbose
IronRuby 46	IronRuby 48
class 1 def 11 end 16 if 1 return 2 else 2 for 1 in 1 while 1 do 1 case 1 when 4 then 4	module 1 class 1 def 11 end 17 if 1 return 2 else 2 for 1 in 1 while 1 do 1 case 1 when 4 then 4

Basics Minimal

Basics Verbose

Java 65

Java 103

package 2
import 2
class 2
private 4
return 5
void 7
this 3
if 1
else 1
for 1
while 1
switch 1
case 24
break 5
default 1
public 2
static 1
new 2

package 2
import 2
public 14
class 2
private 4
return 5
this 29
void 7
if 1
else 1
for 1
while 1
switch 1
case 24
break 5
default 1
static 1
new 2

Basics Minimal

Basics Verbose

JavaFX 64

JavaFX 105

import 4
class 1
var 6
function 11
return 5
init 1
if 5
else 5
for 1
in 2
while 1
def 1
new 1
or 20

package 1
import 4
public 11
class 1
var 6
function 11
return 5
this 29
init 1
if 5
else 5
for 1
in 2
while 1
def 1
new 1
or 20

Basics Minimal	Basics Verbose
JRuby 46	JRuby 48
class 1 def 11 end 16 if 1 return 2 else 2 for 1 in 1 while 1 do 1 case 1 when 4 then 4	module 1 class 1 def 11 end 17 if 1 return 2 else 2 for 1 in 1 while 1 do 1 case 1 when 4 then 4

Basics Minimal

Basics Verbose

JScript.NET 72

JScript.NET 118

import 1
class 1
var 7
function 12
get 3
return 5
set 3
this 3
private 1
if 1
else 1
for 1
while 1
switch 1
case 24
break 5
default 1
new 1

import 1
package 1
public 12
class 1
private 4
var 7
function 13
get 3
return 5
this 29
set 3
if 1
else 1
void 3
for 1
while 1
switch 1
case 24
break 5
default 1
new 1

Basics Minimal	Basics Verbose
Jython 51	Jython 53
from 2 import 2 class 1 def 11 return 5 if 2 else 2 for 1 in 2 print 4 while 1 or 16 elif 2	import 3 from 2 class 1 def 12 return 5 if 2 else 2 for 1 in 2 print 4 while 1 or 16 elif 2

Basics Minimal

Basics Verbose

Nemerle 33

Nemerle 67

using 1
class 1
mutable 5
public 8
this 5
private 1
if 1
else 1
void 3
for 1
while 1
def 2
match 1
_ 2

using 1
namespace 1
internal 1
class 1
private 4
mutable 6
public 10
this 29
if 1
else 1
void 4
for 1
while 1
def 1
match 1
_ 2
module 1
static 1

Basics Minimal

Basics Verbose

Phalanger 89

Phalanger 103

namespace 1
class 2
private 4
function 12
return 5
this 24
if 1
else 1
for 1
echo 4
while 1
switch 1
case 24
break 4
default 1
static 1
new 1
exit 1

namespace 2
class 2
private 4
public 11
function 12
return 6
this 24
if 1
else 1
for 1
echo 4
while 1
switch 1
case 24
break 5
default 1
static 1
new 1
exit 1

Basics Minimal

Basics Verbose

Scala 37

Scala 41

import 1
class 1
private 4
var 4
def 12
this 2
if 1
else 1
for 1
while 1
val 2
match 1
case 5
new 1

package 1
import 2
class 1
private 4
var 4
def 13
this 2
if 1
else 1
for 1
while 1
val 2
match 1
case 5
object 1
new 1

Basics Minimal

Basics Verbose

VB.NET 130

VB.NET 169

Imports 1
Friend 2
Class 2
Private 4
As 22
Property 6
Get 6
Return 5
End 21
Set 6
ByVal 11
Sub 12
New 3
Function 2
If 2
Then 1
Else 2
For 1
To 5
Next 1
Dim 3
While 2
Select 2
Case 6
Module 2

Imports 1
Namespace 2
Friend 2
Class 2
Private 4
As 22
Public 9
Property 6
Get 6
Return 5
Me 27
End 22
Set 6
ByVal 11
Sub 12
New 3
Function 2
If 2
Then 1
Else 2
For 1
To 5
Next 1
Dim 3
While 2
Select 2
Case 6
Module 2

Basics Minimal

Basics Verbose

Zonnon 66

Zonnon 90

module 1
import 1
type 1
object 1
var 5
procedure 10
begin 12
return 5
end 16
if 1
then 1
else 2
for 1
to 2
do 2
while 1
case 1
of 1
new 1
exit 1

module 1
import 1
type 1
object 1
var 5
procedure 10
begin 12
return 5
self 24
end 16
if 1
then 1
else 2
for 1
to 2
do 2
while 1
case 1
of 1
new 1
exit 1

What a horrible night to have a curse.

2010-12-09T05:18:00.000-08:00

Let's throw new Exception(); and instead of talking about programming languages or sharing some code, let me just write about some mixed stuff, and the blog's status.

No new posts in almost a month!?

Right... and the reason is that I'm back to WOW! haha... nah, I'm kidding, but I'm seriously thinking about it because of the new expansion Cataclysm! I ever wanted to be a Goblin Warrior! ooohhh yeah!

FOR THE HORDE!!!!!!

Anyway, it would be a little bit difficult because I have no Internet in our new apartment; the provider didn't active it even if I followed all they said to have it ready before moving, which bring us to the real reason of why there haven't been any new posts lately.

I have been very busy for the last few weeks because I was moving apartment and I must admit that I totally underestimated the physical, psychological and time effort the whole thing required! The night before the move we had a long night finishing all remaining packaging, wraps, baggages and then I came with this "What a horrible night to have a curse." text from "Castlevania II Simon's Quest" which made me laugh about the situation... so, I wanted to share it with anyone in case you also have good (or bad) memories about it:

What has been active?

I always keep an eye on the latest releases on several .NET and Java Programming Languages. If there are new releases in any of the languages listed in the Blog's Languages Page I tweet about them:

I also include some tweets about new releases of Programming IDEs such as Netbeans, Eclipse, IntelliJIDEA, VisualStudio and SharpDevelop, plus other interesting techy retweets. me :)

What to expect on the following posts

1. How many keywords to code the same PART 2! oh yes... based on the examples shown in the Basics by Example series, I will do again some counting and come back with the graphs showing if what we saw on the previous comparison keeps the same.

2. More about Language's features. I will keep showing simple language constructs and stuff and not getting into specifics or advance material so I can keep tracking keywords and lines metrics for the same set of functionality.

3. Keep updating this Blog's Pages (Languages, Keywords, eBooks). I'm still thinking in what to add on the IDE's section... for them moment I will just list the available IDEs and what languages each of them support in the base installation or via plug in.

4. Include implementation of basic Algorithms, useful code snippets, and so on in all languages.

5. Adding a new Page to show how to Install and Run the code examples on this blog on each of the ~20 languages. I usually do the examples using Notepad++ and then compile them using the command line so I can get the Output screen shot. The installation is usually Next Next but I want to include as well the process to install from scratch and install a new version (because sometimes a new release crashes the IDE or requires uninstalling first)

Gosu - Basics by Example

2010-11-13T12:02:00.000-08:00

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

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

// Gosu Basics
classpath "."
//package gsgreetprogram
uses java.util.Calendar
uses java.util.GregorianCalendar
uses java.util.Scanner
uses java.lang.System

public class Greet {
    // Fields or Attributes
    private var _message: String
    private var _name: String
    private var _loopMessage: int
    // Properties
    public property get Message(): String {
        return this._message
    }
    public property set Message(value: String) {
        this._message = this.capitalize(value)
    }
    public property get Name(): String {
        return this._name 
    }
    public property set Name(value: String) {
        this._name = this.capitalize(value)
    }
    public property get LoopMessage(): int {
        return this._loopMessage
    }
    public property set LoopMessage(value: int) {
        this._loopMessage = value
    }
    // Constructor
    public construct() {
        this._message = ""
        this._name = ""
        this._loopMessage = 0
    }
    // Overloaded Constructor
    public construct(pmessage: String, pname: String, ploopMessage: int) {
        this._message = pmessage
        this._name = pname
        this._loopMessage = ploopMessage
    }
    // Method 1
    private function capitalize(val: String): String {
        // "if-then-else" statement
        if(val.length >= 1) {
            return val.capitalize()
        }
        else {
            return ""
        }
    }
    // Method 2
    public function salute() {
        // "for" statement        
        for (i in 0..this._loopMessage) {
            print("${this._message} ${this._name}!")
        }
    }
    // Overloaded Method 2.1
    public function salute(pmessage: String, pname: String, ploopMessage: int) {
        // "while" statement
        var i: int = 0
        while (i < ploopMessage) {
            print("${this.capitalize(pmessage)} ${this.capitalize(pname)}!")
            i = i + 1
        }
    }
    // Overloaded Method 2.2    
 public function salute(pname: String) {    
  // "switch/case" statement    
  var dtNow = new GregorianCalendar()
  switch (dtNow.get(Calendar.HOUR_OF_DAY))
  {    
   case 6: case 7: case 8: case 9: case 10: case 11:    
    this._message = "good morning,"
    break
   case 12: case 13: case 14: case 15: case 16: case 17:    
    this._message = "good afternoon,"
    break
   case 18: case 19: case 20: case 21: case 22:    
    this._message = "good evening,"
    break
   case 23: case 0: case 1: case 2: case 3: case 4: case 5:    
    this._message = "good night,"
    break
   default:    
    this._message = "huh?"
  }    
  print("${this.capitalize(this._message)} ${this.capitalize(pname)}!")
 }    
}

// Console Program
// Define variable object of type Greet and Instantiate. Call Constructor        
var g = new Greet()
// Call Set Properties        
g.Message = "hello"            
g.Name = "world"            
g.LoopMessage = 5
// Call Method 2            
g.salute()        
// Call Method 2.1 and Get Properties            
g.salute(g.Message, "gosu", g.LoopMessage)        
// Call Method 2.2            
g.salute("carlos")            
// Stop and exit            
print("Press any key to exit...")
var sin = new Scanner(System.in)
var line = sin.nextLine()
sin.close()

Greetings Program - Minimal

// Gosu Basics
classpath "."
uses java.util.Calendar
uses java.util.GregorianCalendar
uses java.util.Scanner
uses java.lang.System

class Greet {
    // Fields or Attributes
    var _message: String
    var _name: String
    var _loopMessage: int
    // Properties
    property get Message(): String {
        return _message
    }
    property set Message(value: String) {
        _message = capitalize(value)
    }
    property get Name(): String {
        return _name 
    }
    property set Name(value: String) {
        _name = capitalize(value)
    }
    property get LoopMessage(): int {
        return _loopMessage
    }
    property set LoopMessage(value: int) {
        _loopMessage = value
    }
    // Constructor
    construct() {
        _message = ""
        _name = ""
        _loopMessage = 0
    }
    // Overloaded Constructor
    construct(pmessage: String, pname: String, ploopMessage: int) {
        _message = pmessage
        _name = pname
        _loopMessage = ploopMessage
    }
    // Method 1
    private function capitalize(val: String): String {
        // "if-then-else" statement
        if(val.length >= 1) {
            return val.capitalize()
        }
        else {
            return ""
        }
    }
    // Method 2
    function salute() {
        // "for" statement        
        for (i in 0.._loopMessage) {
            print("${_message} ${_name}!")
        }
    }
    // Overloaded Method 2.1
    function salute(pmessage: String, pname: String, ploopMessage: int) {
        // "while" statement
        var i = 0
        while (i < ploopMessage) {
            print("${capitalize(pmessage)} ${capitalize(pname)}!")
            i = i + 1
        }
    }
    // Overloaded Method 2.2    
    function salute(pname: String) {
        // "switch/case" statement    
        var dtNow = new GregorianCalendar()
        switch (dtNow.get(Calendar.HOUR_OF_DAY))
        {    
            case 6: case 7: case 8: case 9: case 10: case 11:    
                _message = "good morning,"
                break
            case 12: case 13: case 14: case 15: case 16: case 17:
                _message = "good afternoon,"
                break
            case 18: case 19: case 20: case 21: case 22:    
                _message = "good evening,"
                break
            case 23: case 0: case 1: case 2: case 3: case 4: case 5:    
                _message = "good night,"
                break    
            default:    
                _message = "huh?"
        }    
        print("${capitalize(_message)} ${capitalize(pname)}!")
    }    
}

// Console Program
// Define variable object of type Greet and Instantiate. Call Constructor        
var g = new Greet()
// Call Set Properties        
g.Message = "hello"            
g.Name = "world"            
g.LoopMessage = 5
// Call Method 2            
g.salute()        
// Call Method 2.1 and Get Properties            
g.salute(g.Message, "gosu", g.LoopMessage)        
// Call Method 2.2            
g.salute("carlos")            
// Stop and exit            
print("Press any key to exit...")
var sin = new Scanner(System.in)
var line = sin.nextLine()
sin.close()

And the Output is:

Auto-Implemented Properties in Gosu

Auto-implemented properties enable you to quickly specify a property of a class without having to write code to Get and Set the property. The following code shows how to use them just like with VB.NET, C#, C++/CLI and so on.

// Gosu Basics
class AutoImplementedProperties {
    // Fields + Auto-Implemented Properties
    var _message: String as Message
    var _name: String as Name
    var _loopMessage: int as LoopMessage
    // Methods
    function salute() {
        print("${_message.capitalize()} ${_name.capitalize()} ${_loopMessage}!")
    }
}

var g = new 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
print(g.Message + " " + g.Name + " " + g.LoopMessage + "!")

And the output is: