Here below a little program in Fantom that implements 2 classes (in fact, they are 3 + an extra utility Stopwatch class from my previous post http://carlosqt.blogspot.com/2011/05/stopwatch-class-for-java.html). There is the main class, called Fiborial (Fibo(nnacci)+(Facto)rial) that implements the Fibonacci and the Factorial algorithms in two ways, one Recursive (using recursion) and the other Imperative (using loops and states). The second class is just an instance class that does the same thing, but its there just to show the difference between static and instance classes, and finally the third one (which will not appear in other languages) is the Program class which has the static execution method "main".
You can also find 3 more little examples at the bottom. One prints out the Factorial's Series and Fibonacci's Series, the second one just shows a class that mixes both: static and instance members, and finally the third one that uses different return types (including java.math.BigInteger) for the Factorial method to compare the timing and result.
As with the previous posts, you can copy and paste the code below in your favorite IDE/Editor and start playing and learning with it. This little "working" program will teach you some more basics of the Programming Language.
There are some "comments" on the code added just to tell you what are or how are some features called. In case you want to review the theory, you can read my previous post, where I give a definition of each of the concepts mentioned on the code. You can find it here: http://carlosqt.blogspot.com/2011/01/new-series-factorial-and-fibonacci.html
The Fiborial Program
// Factorial and Fibonacci in Fantom
using [java] com.carlosqt.util::Stopwatch
using [java] java.math::BigInteger
// static is not a valid class modifier
// Instanced Class
class StaticFiborial
{
// (Constant) Static Field - Static fields must be const - this ensures thread safety
private const static Str className
// Class/Static Constructor/Initializer
// It is permissible to have multiple static initializers; they run in order of declaration
static
{
className = "Static Constructor"
echo(className)
}
// Static Method - Factorial Recursive
static BigInteger factorialR(Int n)
{
if (n == 1)
return BigInteger.ONE
else
return BigInteger.valueOf(n).multiply(factorialR(n - 1))
}
// Static Method - Factorial Imperative
static BigInteger factorialI(Int n)
{
BigInteger res := BigInteger.ONE
for (i := n; i >= 1; i--)
{
res = res.multiply(BigInteger.valueOf(i))
}
return res
}
// Static Method - Fibonacci Recursive
static Int fibonacciR(Int n)
{
if (n < 2)
return 1
else
return fibonacciR(n - 1) + fibonacciR(n - 2)
}
// Static Method - Fibonacci Imperative
static Int fibonacciI(Int n)
{
Int pre := 1
Int cur := 1
Int tmp := 0
for (i := 2; i <= n; i++)
{
tmp = cur + pre
pre = cur
cur = tmp
}
return cur
}
// Class/Static Method - Benchmarking Algorithms
static Void benchmarkAlgorithm(Int algorithm, List values)
{
Stopwatch timer := Stopwatch()
Int testValue := 0
BigInteger facTimeResult := BigInteger.ZERO
Int fibTimeResult := 0
// "Switch" Flow Control Statement
switch (algorithm)
{
case 1:
echo("\nFactorial Imperative:")
// "For" Loop Statement
for (i := 0; i < values.size; i++)
{
testValue = values.get(i)
// Taking Time
timer.start()
facTimeResult = factorialI(testValue)
timer.stop()
// Getting Time
echo(" ($testValue) = ${timer.getElapsed()}")
}
case 2:
echo("\nFactorial Recursive:")
// "While" Loop Statement
Int i := 0
while (i < values.size)
{
testValue = values.get(i)
// Taking Time
timer.start()
facTimeResult = factorialR(testValue)
timer.stop()
// Getting Time
echo(" ($testValue) = ${timer.getElapsed()}")
i++
}
case 3:
echo("\nFibonacci Imperative:")
// "While" Loop Statement
Int i := 0
while (i < values.size)
{
testValue = values.get(i)
// Taking Time
timer.start()
fibTimeResult = fibonacciI(testValue)
timer.stop()
// Getting Time
echo(" ($testValue) = ${timer.getElapsed()}")
i++
}
case 4:
echo("\nFibonacci Recursive:")
// "For" Loop Statement
for (i := 0; i < values.size; i++)
{
testValue = values.get(i)
// Taking Time
timer.start()
fibTimeResult = fibonacciR(testValue)
timer.stop()
// Getting Time
echo(" ($testValue) = ${timer.getElapsed()}")
}
default:
echo("DONG!")
}
}
}
// Instance Class
class InstanceFiborial
{
// Instance Field
private Str className
// Instance Constructor
new make()
{
this.className = "Instance Constructor"
echo(this.className)
}
// Instance Method - Factorial Recursive
BigInteger factorialR(Int n)
{
// Calling Static Method
return StaticFiborial.factorialR(n)
}
// Instance Method - Factorial Imperative
BigInteger factorialI(Int n)
{
// Calling Static Method
return StaticFiborial.factorialI(n)
}
// Instance Method - Fibonacci Recursive
Int fibonacciR(Int n)
{
// Calling Static Method
return StaticFiborial.fibonacciR(n)
}
// Instance Method - Factorial Imperative
Int fibonacciI(Int n)
{
// Calling Static Method
return StaticFiborial.fibonacciI(n)
}
}
// Console Program
public class FiborialApp
{
public static Void main()
{
echo("\nStatic Class")
// Calling Static Class and Methods
// No instantiation needed. Calling method directly from the class
echo("FacImp(5) = ${StaticFiborial.factorialI(5)}")
echo("FacRec(5) = ${StaticFiborial.factorialR(5)}")
echo("FibImp(11)= ${StaticFiborial.fibonacciI(11)}")
echo("FibRec(11)= ${StaticFiborial.fibonacciR(11)}")
echo("\nInstance Class")
// Calling Instance Class and Methods
// Need to instantiate before using. Calling method from instantiated object
InstanceFiborial ff := InstanceFiborial.make()
echo("FacImp(5) = ${ff.factorialI(5)}")
echo("FacRec(5) = ${ff.factorialR(5)}")
echo("FibImp(11)= ${ff.fibonacciI(11)}")
echo("FibRec(11)= ${ff.fibonacciR(11)}")
// Create a list of integer values to test
// From 5 to 50 by 5
Int[] values := Int[,]
for(i := 5; i <= 50; i += 5)
values.add(i)
// Benchmarking Fibonacci
// 1 = Factorial Imperative
StaticFiborial.benchmarkAlgorithm(1, values)
// 2 = Factorial Recursive
StaticFiborial.benchmarkAlgorithm(2, values)
// Benchmarking Factorial
// 3 = Fibonacci Imperative
StaticFiborial.benchmarkAlgorithm(3, values)
// 4 = Fibonacci Recursive
StaticFiborial.benchmarkAlgorithm(4, values)
// Stop and exit
echo("Press any key to exit...")
console := Env.cur
userInput := console.in.readLine
}
}
And the Output is:
Printing the Factorial and Fibonacci Series
using [java] java.math::BigInteger
using [java] java.lang::StringBuffer
class Fiborial
{
// Using a StringBuffer as a list of string elements
// because of the following compile error:
// Ambiguous call append(sys::Str) FiborialSeries.fan ... Fantom Problem
// I had to use StringBuffer.apend(s, 0, s.length) instead of just StringBuffer.apend(CharSequence s)
static Str getFactorialSeries(Int n)
{
// Create the String that will hold the list
StringBuffer series := StringBuffer()
// We begin by concatenating the number you want to calculate
// in the following format: "!# ="
series.append("!", 0, "!".size)
series.append(n.toStr, 0, n.toStr.size)
series.append(" = ", 0, 3)
// We iterate backwards through the elements of the series
for (i := n; i <= n && i > 0; i--)
{
// and append it to the list
series.append(i.toStr, 0, i.toStr.size)
if (i > 1)
series.append(" * ", 0, 3)
else
series.append(" = ", 0, 3)
}
// Get the result from the Factorial Method
// and append it to the end of the list
Str fac := factorial(n).toStr
series.append(fac, 0, fac.size)
// return the list as a string
return series.toStr
}
// Using a StringBuffer as a list of string elements
static Str getFibonnaciSeries(Int n)
{
// Create the String that will hold the list
StringBuffer series := StringBuffer()
// We begin by concatenating the first 3 values which
// are always constant
series.append("0, 1, 1", 0, 7)
// Then we calculate the Fibonacci of each element
// and add append it to the list
Str fib := ""
for (i := 2; i <= n; i++)
{
if (i < n)
series.append(", ", 0, 2)
else
series.append(" = ", 0, 3)
fib = fibonacci(i).toStr
series.append(fib, 0, fib.size)
}
// return the list as a string
return series.toStr
}
static BigInteger factorial(Int n)
{
if (n == 1)
return BigInteger.ONE
else
return BigInteger.valueOf(n).multiply(factorial(n - 1))
}
static Int fibonacci(Int n)
{
if (n < 2)
return 1
else
return fibonacci(n - 1) + fibonacci(n - 2)
}
}
// Console Program
public class FiborialSeriesApp
{
public static Void main()
{
// Printing Factorial Series
echo("")
echo(Fiborial.getFactorialSeries(5))
echo(Fiborial.getFactorialSeries(7))
echo(Fiborial.getFactorialSeries(9))
echo(Fiborial.getFactorialSeries(11))
echo(Fiborial.getFactorialSeries(40))
// Printing Fibonacci Series
echo("")
echo(Fiborial.getFibonnaciSeries(5))
echo(Fiborial.getFibonnaciSeries(7))
echo(Fiborial.getFibonnaciSeries(9))
echo(Fiborial.getFibonnaciSeries(11))
echo(Fiborial.getFibonnaciSeries(40))
}
}
And the Output is:
Mixing Instance and Static Members in the same Class
Instance classes can contain both, instance and static members such as: fields, getters, constructors/initializers, methods, etc.
// Instance Class
class Fiborial
{
// Instance Field
private Int instanceCount
// Static Field
// Static field 'staticCount' must be const
private const static Int staticCount
// Instance Read-Only Property
Int InstanceCount
{
get { return &instanceCount }
}
// Static Fields need to be const. A static const cannot have getter
// using Static Read-Only Getter instead
// As with Static Methods, you cannot reference your class members
// with the "this" reference pointer since static members are not
// instantiated.
/*static Int StaticCount
{
get { return &staticCount }
}*/
static Int getStaticCount()
{
return staticCount
}
// Instance Constructor
new make()
{
this.instanceCount = 0
echo("\nInstance Constructor ${this.instanceCount}")
}
// Static Constructor
// Static constructors are methods executed to initialize the class itself.
// They are typically used to initialize static fields.
static
{
staticCount = 0
echo("\nStatic Constructor $staticCount")
}
// Instance Method
Void factorial(Int n)
{
this.instanceCount += 1
echo("\nFactorial($n)")
}
// Static Method
static Void fibonacci(Int n)
{
// Error:
// Cannot set const static field 'staticCount' outside of static initializer
// (static constructor) so we cannot increment staticCount
// staticCount += 1
echo("\nFibonacci($n)")
}
}
public class FiborialExtrasApp
{
public static Void main()
{
// Calling Static Constructor and Methods
// No need to instantiate
Fiborial.fibonacci(5)
// Calling Instance Constructor and Methods
// Instance required
Fiborial fib := Fiborial()
fib.factorial(5)
Fiborial.fibonacci(15)
fib.factorial(5)
// Calling Instance Constructor and Methods
// for a second object
Fiborial fib2 := Fiborial()
fib2.factorial(5)
echo("")
// Calling Static Property
echo("Static Count = ${Fiborial.getStaticCount}")
// Calling Instance Property of object 1 and 2
echo("Instance 1 Count = ${fib.InstanceCount}")
echo("Instance 2 Count = ${fib2.InstanceCount}")
}
}
And the Output is:
Factorial using java.lang.Long/sys::Int, java.lang.Double/sys::Float, java.math.BigInteger
using [java] com.carlosqt.util::Stopwatch
using [java] java.math::BigInteger
public class FiborialTypesApp
{
public static Void main()
{
Stopwatch timer := Stopwatch()
Int facIntResult := 0
Float facDblResult := 0f
BigInteger facBigResult := BigInteger.ZERO
echo("\nFactorial using Int64")
// Benchmark Factorial using Int64
for (i := 5; i <= 50; i += 5)
{
timer.start
facIntResult = factorialInt64(i)
timer.stop
echo(" ($i) = ${timer.getElapsed} : $facIntResult")
}
echo("\nFactorial using Float/Double")
// Benchmark Factorial using Double
for (i := 5; i <= 50; i += 5)
{
timer.start
facDblResult = factorialDouble(i)
timer.stop
echo(" ($i) = ${timer.getElapsed} : $facDblResult")
}
echo("\nFactorial using BigInteger")
// Benchmark Factorial using BigInteger
for (i := 5; i <= 50; i += 5)
{
timer.start();
facBigResult = factorialBigInteger(i);
timer.stop();
echo(" ($i) = ${timer.getElapsed} : $facBigResult")
}
}
// Int64 Factorial
static Int factorialInt64(Int n)
{
if (n == 1)
return 1
else
return n * factorialInt64(n - 1)
}
// Float Factorial
static Float factorialDouble(Int n)
{
if (n == 1)
return 1f
else
return n * factorialDouble(n - 1)
}
// BigInteger Factorial
static BigInteger factorialBigInteger(Int n)
{
if (n == 1)
return BigInteger.ONE
else
return BigInteger.valueOf(n).multiply(factorialBigInteger(n - 1))
}
}
And the Output is:
No comments:
Post a Comment