Refactoring a recursive function sounds interesting. We’d love to see an example of how you do that in ActionScript 3.0.

Thanks,
Bill

The point you make is certainly valid and it’s probably one I should have included. However, the Fibonacci is used to illustrate how recursion works, and while it is not the most efficient way to generate a Fibonacci sequence, it reveals the nature of the recursive function.

Of course you are quite right, though, that a recursive function is not the best way to generate a Fibonacci value. It’s just a fun way to show recursion.

Thanks for your insightful comment,
Bill

I really think this issue boils down to design. When an application is designed from the base up, constraints are found and implemented into the design.

I work with recursive functions quite a bit, Flash 5 -> now. When you run into problems with this is when you are creating a call stack that involves other methods being called indirectly from a recursive method.

IE dispatchEvent() is dangerous in a recursive method.

Once you get experience with the limits of the engine that runs your code (IE Flash Player), you know intuitively where the red line is and don’t even attempt some things (switch from defense to offense).

A lot of the time a recursive function can be refactored into a batch or other related pattern.

Experience gives forward vision and allows an abstract view before any emergency in code throws a stack overflow.

Mike

the fibonacci example above is the (no diss intended) naive way as it takes exponential time to compute as each recursion needs to calculate the whole sequence of numbers before it -recursively- (in the statement return fibo(r-1) + fibo(r-2); )
not nice ;)
Fibonacci is a case of a problem that can be handled generically with dynamic programming (or memoization), in which you would store the previous calculated output (for fibonacci, this can easily be done in an array to avoid recomputation. Making this change lets the calculation execute in lineair time !!!

Also, as the numbers grow exponentially, values grow very fast.
fibo(45) is actually the largest number that can be represented by a 32 bit integer!

Thanks for taking the time on that. Love those Fibonacci sequences!

Kindest regards,
Bill

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

package {
	import flash.display.Sprite;
 
	/**
	 * @author alex.gvozden
	 */
	public class Recursion extends Sprite {
 
		private var _fib : Number = 0;
		private var _fib2 : Number = 1;
		private var _maxLevel : Number = 2050;
 
		public function Recursion() {
			fibonacci(0);
		}
 
		private function fibonacci(level : Number) : void {
 
			trace("level : " + level + " " + _fib);
			_fib2 += _fib;
			_fib = _fib2-_fib;
			level++;
			if (level < _maxLevel)
				fibonacci(level);
 
		}
	}
}

level : 1112 1.10858999763490e+232
[Fault] exception, information=undefined
Fault, fibonacci() at Recursion.as:24


it’s pretty good looking how it was before fp10, I think even 9 had lower limits
so yep recursion is great thing, should be used carefully but in flash you don’t need hardcore recusion, and with simple one you can gain a lot
goin from recursion to iteration is important step in learning programming anyway, at least it helped me a lot on complex algebra problems

Thank you for your comments. I had not considered the impact of a recursive function on the timeline. One of the main reasons I prefer to subclass to the Sprite class and not the MovieClip class is that the former has no timeline. The nice thing about Flash/Flex with ActionScript 3.0 is that you can choose to use the Timeline or not.

Would either of you be interested in providing an example of where a recursive function runs into problems with the Timeline? Or how you might use a recursive function with a timer?

Thank you both for your insights,
Bill

also, important thing is that any recursion can be transformed to iteration function, which needs a little bit more writing but it’s very nice programming problem