Factorial and Fibonacci in IronRuby

Tweet

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

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

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

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

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

The Fiborial Program

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

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

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

And the Output is:

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

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

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

And the Output is:

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

require "mscorlib"  

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

And the Output is:

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

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

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

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

gets

And the Output is:

Factorial and Fibonacci in IronPython

Tweet

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_float(n - 1))

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

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

Console.Read()

And the Output is: