# Converting recursive function to iterative [Solved]

#### TheSnidr

##### Heavy metal viking dentist
GMC Elder
I've created a recursive script for casting a ray onto an octree and finding the nearest intersection. It performs recursion with the following format (pseudocode):
Code:
``````/// @description recursion(stuff)
/// @param stuff
if conditionA
{
//End recursion
return thing;
}
if conditionB
{
something = recursion(stuff);
}
if conditionC
{
something = recursion(stuff);
}
if conditionD
{
something = recursion(stuff);
}
if conditionE
{
something = recursion(stuff);
}
return something;``````
Here's the actual script in case you're interested:
Code:
``````/// @description smf_collision_cast_ray_recursive(collisionBuffer, lineStart, lineEnd, regionSize, regionPos)
/// @param collisionBuffer
/// @param lineStart
/// @param lineEnd
/// @param regionSize
/// @param regionPos
var i, j, k, r, t, n, a, b, colBuffer, rayStart, rayEnd, regionSize, halfRegionSize, regionPos, checkPos, intersect, newPos, region, tris, tri, ret;
colBuffer = argument0;
rayStart = argument1;
rayEnd = argument2;
regionSize = argument3;
halfRegionSize = regionSize / 2;
regionPos = argument4;

//Exit condition
if (!r)
{
buffer_seek(colBuffer, buffer_seek_start, -r);
for (i = 0; i < n; i ++){tris[i] = buffer_read(colBuffer, buffer_u16);}
for (i = 0; i < n; i ++)
{
//Find intersection with triangle plane
tri = smf_get_triangle(colBuffer, tris[i]);
t = dot_product_3d(tri, tri, tri, rayEnd - rayStart, rayEnd - rayStart, rayEnd - rayStart);
if (t == 0){continue;}
t = dot_product_3d(tri, tri, tri, tri - rayStart, tri - rayStart, tri - rayStart) / t;
if ((t <= 0) or (t >= 1)){continue;}
ret = lerp(rayStart, rayEnd, t);
ret = lerp(rayStart, rayEnd, t);
ret = lerp(rayStart, rayEnd, t);

//Check if the intersection is inside the triangle. If not, discard and continue.
a = ret - tri; a = ret - tri; a = ret - tri;
b = tri - tri; b = tri - tri; b = tri - tri;
if (dot_product_3d(tri, tri, tri, a * b - a * b, a * b - a * b, a * b - a * b) < 0){continue;}
a = ret - tri; a = ret - tri; a = ret - tri;
b = tri - tri; b = tri - tri; b = tri - tri;
if (dot_product_3d(tri, tri, tri, a * b - a * b, a * b - a * b, a * b - a * b) < 0){continue;}
a = ret - tri; a = ret - tri; a = ret - tri;
b = tri - tri; b = tri - tri; b = tri - tri;
if (dot_product_3d(tri, tri, tri, a * b - a * b, a * b - a * b, a * b - a * b) < 0){continue;}

//The line intersects the triangle. The ray is altered by a tiny amount to make sure the returned value is on the correct side of the triangle
t += 1 / dot_product_3d(tri, tri, tri, ret - rayStart, ret - rayStart, ret - rayStart);
rayEnd = lerp(rayStart, rayEnd, t);
rayEnd = lerp(rayStart, rayEnd, t);
rayEnd = lerp(rayStart, rayEnd, t);
}
return rayEnd;
}

//Find starting region of the line segment
region = (rayStart > regionPos + halfRegionSize);
region = (rayStart > regionPos + halfRegionSize);
region = (rayStart > regionPos + halfRegionSize);
for (i = 0; i < 3; i ++)
{
if (rayEnd[i] == rayStart[i]){continue;}
if ((rayStart[i] < regionPos[i]) or (rayStart[i] > regionPos[i] + regionSize))
{
checkPos = regionPos;
checkPos[i] += region[i] * regionSize;
t = (checkPos[i] - rayStart[i]) / (rayEnd[i] - rayStart[i]);
if ((t <= 0) or (t >= 1)){continue;}
j = (i + 1) mod 3;
k = (i + 2) mod 3;
ret[j] = lerp(rayStart[j], rayEnd[j], t);
ret[k] = lerp(rayStart[k], rayEnd[k], t);
if  ((ret[j] < regionPos[j]) or (ret[j] > regionPos[j] + regionSize) or (ret[k] < regionPos[k]) or (ret[k] > regionPos[k] + regionSize)){continue;}
region[j] = (ret[j] > regionPos[j] + halfRegionSize);
region[k] = (ret[k] > regionPos[k] + halfRegionSize);
break;
}
}

//Check for collisions in the starting region of the line segment
buffer_seek(colBuffer, buffer_seek_start, r + region * 4 + region * 8 + region * 16);
newPos = regionPos + halfRegionSize * region;
newPos = regionPos + halfRegionSize * region;
newPos = regionPos + halfRegionSize * region;
rayEnd = smf_collision_cast_ray_recursive(colBuffer, rayStart, rayEnd, halfRegionSize, newPos);

//Check for intersections along the middle axis in all three dimensions
for (i = 0; i < 3; i ++)
{
if (rayEnd[i] == rayStart[i]){continue;}
t = (regionPos[i] + halfRegionSize - rayStart[i]) / (rayEnd[i] - rayStart[i]);
if ((t <= 0) or (t >= 1)){continue;}
j = (i + 1) mod 3;
k = (i + 2) mod 3;
intersect[j] = lerp(rayStart[j], rayEnd[j], t) - regionPos[j];
intersect[k] = lerp(rayStart[k], rayEnd[k], t) - regionPos[k];
if ((intersect[j] < 0) or (intersect[j] > regionSize) or (intersect[k] < 0) or (intersect[k] > regionSize)){continue;}
region[i] = (rayStart[i] < regionPos[i] + halfRegionSize);
region[j] = (intersect[j] >= halfRegionSize);
region[k] = (intersect[k] >= halfRegionSize);
newPos = regionPos + halfRegionSize * region;
newPos = regionPos + halfRegionSize * region;
newPos = regionPos + halfRegionSize * region;
buffer_seek(colBuffer, buffer_seek_start, r + region * 4 + region * 8 + region * 16);
rayEnd = smf_collision_cast_ray_recursive(colBuffer, rayStart, rayEnd, halfRegionSize, newPos);
}
return rayEnd;``````
I just can't see any ways of converting this to an iterative script. I've read multiple places that "any recursive function can be rewritten to an iterative one", but I'm kinda lost on this one.
And even if it's possible, is it feasible? The maximal recursive depth in this function is 10, it will never go deeper and will rarely even reach 10.

What I'm currently trying to get working is to store my progress in ds_stacks. Once I reach the exit condition, I pop the stack and contionue iterating. If I get it to work I'll post the solution, but I seem to be far away still...

EDIT:
OMG I managed to turn it into an iterative function! The stack method I mentioned works like a charm. Instead of recursively performing the function, I made a "while true"-loop and go back and forth in this with the help of a ds_stack. It's ridiculously much faster than the recursive function, and can be performed with a single script call.
In essence, this is what it does:
Code:
``````stack = ds_stack_create();
progress = 0;
conditionA = false;
stuff = something;
while true
{
if conditionA
{
//If we're at the lowest level, perform collision checks
//This is the same as the exit condition for the recursive function
perform_collision_check(stuff);

//Go back up to the previous level
progress = ds_stack_pop(stack);
stuff = ds_stack_pop(stack);
}
if progress == 0 and functionA(stuff)
{
ds_stack_push(stack, progress + 1);
ds_stack_push(stack, stuff);
if functionB(stuff){conditionA = true;} //If certain conditions are met, perform the recursive exit condition in the next loop
progress = 0;
continue; //Continue makes the loop start over again, effectively jumping back to the start - but with the new variables
}
if progress == 1 and functionC(stuff)
{
ds_stack_push(stack, progress + 1);
ds_stack_push(stack, stuff);
if functionD(stuff){conditionA = true;} //If certain conditions are met, perform the recursive exit condition in the next loop
progress = 0;
continue; //Continue makes the loop start over again, effectively jumping back to the start - but with the new variables
}
if progress == 2 and functionE(stuff)
{
ds_stack_push(stack, progress + 1);
ds_stack_push(stack, stuff);
if functionF(stuff){conditionA = true;} //If certain conditions are met, perform the recursive exit condition in the next loop
progress = 0;
continue; //Continue makes the loop start over again, effectively jumping back to the start - but with the new variables
}
if progress == 3 and functionG(stuff)
{
ds_stack_push(stack, progress + 1);
ds_stack_push(stack, stuff);
if functionH(stuff){conditionA = true;} //If certain conditions are met, perform the recursive exit condition in the next loop
progress = 0;
continue; //Continue makes the loop start over again, effectively jumping back to the start - but with the new variables
}

//If the stack is empty, we're done iterating
if ds_stack_size(stack) == 0{break;}

//If we're done in this level, go back up one level
progress = ds_stack_pop(stack);
stuff = ds_stack_pop(stack);
}
ds_stack_destroy(stack);``````
And here's the iterative script in its entirety:
Code:
``````/// @description smf_collision_cast_ray(collisionBuffer, x1, y1, z1, x2, y2, z2)
/// @param collisionBuffer
/// @param x1
/// @param y1
/// @param z1
/// @param x2
/// @param y2
/// @param z2
/*
Casts a ray from one point to another and returns the position of the first collision with geometry

www.TheSnidr.com
*/
var colBuffer = argument0, regionSize = 65535, progress = 0, stack = ds_stack_create();
var a, b, n, i, j, k, l, t, tri, tris, modelX, modelY, modelZ, modelSize, transformScale, lineStart, lineEnd, regionPos, bufferPos, halfRegionSize, region, intersect;
buffer_seek(colBuffer, buffer_seek_start, 0);
transformScale = 65535 / modelSize;
lineStart = transformScale * (argument1 - modelX);
lineStart = transformScale * (argument2 - modelY);
lineStart = transformScale * (argument3 - modelZ);
lineEnd = transformScale * (argument4 - modelX);
lineEnd = transformScale * (argument5 - modelY);
lineEnd = transformScale * (argument6 - modelZ);
regionPos = 0;
returnNormal = -1;
returnNormal = 1;
while true
{
if (bufferPos > 0)
{   //Iterate through the octree
halfRegionSize = regionSize / 2;
for (l = progress; l < 4; l ++)
{
if l == 0
{   //Check either the starting region of the ray or the first region it intersects
region = (lineStart > regionPos + halfRegionSize);
region = (lineStart > regionPos + halfRegionSize);
region = (lineStart > regionPos + halfRegionSize);
for (i = 0; i < 3; i ++)
{
if (lineEnd[i] == lineStart[i]) continue;
if (lineStart[i] >= regionPos[i] and lineStart[i] <= regionPos[i] + regionSize) continue;
t = (regionPos[i] + region[i] * regionSize - lineStart[i]) / (lineEnd[i] - lineStart[i]);
if (t < 0 or t > 1) continue;
j = (i + 1) mod 3; k = (i + 2) mod 3;
intersect[j] = lerp(lineStart[j], lineEnd[j], t) - regionPos[j];
intersect[k] = lerp(lineStart[k], lineEnd[k], t) - regionPos[k];
if (intersect[j] < 0 or intersect[j] > regionSize or intersect[k] < 0 or intersect[k] > regionSize) continue;
region[j] = (intersect[j] > halfRegionSize);
region[k] = (intersect[k] > halfRegionSize);
break;
}
}
else
{   //Check for intersections with the middle plane of each dimension
i = l - 1;
if (lineEnd[i] == lineStart[i]) continue;
t = (regionPos[i] + halfRegionSize - lineStart[i]) / (lineEnd[i] - lineStart[i]);
if (t < 0 or t > 1) continue;
j = (i + 1) mod 3; k = (i + 2) mod 3;
intersect[j] = lerp(lineStart[j], lineEnd[j], t) - regionPos[j];
intersect[k] = lerp(lineStart[k], lineEnd[k], t) - regionPos[k];
if (intersect[j] < 0 or intersect[j] > regionSize or intersect[k] < 0 or intersect[k] > regionSize) continue;
region[i] = lineStart[i] < regionPos[i] + halfRegionSize;
region[j] = intersect[j] >= halfRegionSize;
region[k] = intersect[k] >= halfRegionSize;
}

//Push this region to stack
ds_stack_push(stack, bufferPos);
ds_stack_push(stack, regionPos);
ds_stack_push(stack, regionPos);
ds_stack_push(stack, regionPos);
ds_stack_push(stack, l);

//Go to intersected child region
if (region){regionPos += halfRegionSize; bufferPos += 4;}
if (region){regionPos += halfRegionSize; bufferPos += 8;}
if (region){regionPos += halfRegionSize; bufferPos += 16;}
buffer_seek(colBuffer, buffer_seek_start, bufferPos);
regionSize /= 2;
progress = 0;
break;
}
if (l < 4) continue; //If we ended the for-loop prematurely, we should also restart the while-loop
}
else
{   //If this is a leaf region, check for intersections with the triangles in this leaf
l = 0;
buffer_seek(colBuffer, buffer_seek_start, -bufferPos);
repeat l
{   //Find intersection with triangle plane
tri = smf_get_triangle(colBuffer, tris[--l]);
t = dot_product_3d(tri, tri, tri, lineEnd - lineStart, lineEnd - lineStart, lineEnd - lineStart);
if (t == 0) continue;
t = dot_product_3d(tri, tri, tri, tri - lineStart, tri - lineStart, tri - lineStart) / t;
if (t <= 0 or t >= 1) continue;
intersect = lerp(lineStart, lineEnd, t);
intersect = lerp(lineStart, lineEnd, t);
intersect = lerp(lineStart, lineEnd, t);

//Check if the intersection is inside the triangle. If not, discard and continue.
a = intersect - tri; a = intersect - tri; a = intersect - tri;
b = tri - tri; b = tri - tri; b = tri - tri;
if (dot_product_3d(tri, tri, tri, a * b - a * b, a * b - a * b, a * b - a * b) < 0) continue;
a = intersect - tri; a = intersect - tri; a = intersect - tri;
b = tri - tri; b = tri - tri; b = tri - tri;
if (dot_product_3d(tri, tri, tri, a * b - a * b, a * b - a * b, a * b - a * b) < 0) continue;
a = intersect - tri; a = intersect - tri; a = intersect - tri;
b = tri - tri; b = tri - tri; b = tri - tri;
if (dot_product_3d(tri, tri, tri, a * b - a * b, a * b - a * b, a * b - a * b) < 0) continue;

//The line intersects the triangle. Save the triangle normal and intersection.
returnNormal = tri;
returnNormal = tri;
returnNormal = tri;
lineEnd = intersect;
intersect = -1;
}
}
if !ds_stack_size(stack) break; //If the stack is empty, break the loop

//Pop the previous region from stack
progress = ds_stack_pop(stack) + 1;
regionPos = ds_stack_pop(stack);
regionPos = ds_stack_pop(stack);
regionPos = ds_stack_pop(stack);
bufferPos = ds_stack_pop(stack);
regionSize *= 2;
}
ds_stack_destroy(stack);
returnX = modelX + lineEnd / transformScale;
returnY = modelY + lineEnd / transformScale;
returnZ = modelZ + lineEnd / transformScale;``````
It is in essence still a recursive script, but instead of jumping deeper and deeper into recursion depth, it jumps back and forth within the while-loop itself in a controlled manner. It performs the same number of checks in the exact same order as it did while it was recursive, but it's a lot faster since it doesn't have to pass variables back and forth.

Last edited:

#### csanyk

##### Member
How much faster is it?

#### MishMash

##### Member
Just wanted to spice this topic up a bit. First of all, it is not possible for every recursive function to be represented iteratively (it is possible for any iterative function to be represented recursively however). What I mean here isn't so much to do with "recursion" in terms of function calls, but recursion in terms of using a stack. (When I say recursion, I'm talking about either recursion using the system stack with function calls, and also iteration over some form of stack structure).

Fundamentally, recursion is essential if you NEED to maintain your old stack frames, that is, if the computation in older frames needs to be re-visited and re-used later on. Any function where this information can be thrown away can be made iterative. In some cases, you can also cheat the system with Memoisation in the case of dynamic programming optimisation, which essentially stores previous results in an alternative datastructure like a grid.

In the case of navigating an octree, it is a little harder given the multiple possible end-states you can end up in, however given that you have full information of the structure, and once you have reached a particular layer, you no longer care about the previous layer, it is reasonable to assume an iterative solution that is simpler than emulating recursion exists.

A more efficient iterative solution would require knowledge of how you implemented your octree, as there are many different ways of doing it:
- Whether you have a fixed depth, and at each depth, you store a list of intersecting primitives:
- Even for this one, each node in the octree could either store a cascading subset of primitives, or only the final layer could store primitives, with it being possible for a triangle to exist in the list belonging to multiple nodes.
(In this case, empty nodes would just end, however any node with a triangle in it would reach maximum spacial depth).
- Whether you have an infinite depth, and each branch ends on one single primitive.
- Whether you have a minimal spacial size, and you're quantizing your model down to a voxel style structure where each node simply represents a "yes-no" collision, and you don't actually test on the original geometry, just whether there is or isn't something in a given cube at each level.

As a note, neither of these would be massively far off a stack, implementations I have done in the past have worked off of building up a list of visited nodes in the tree, and then maintaining a list of final triangle IDs to test against. However, they can be faster than a stack-based method as you have both control over the search pattern and the type of data you are storing.

As a rough example algorithm, assuming each node in your octree is accessible via an index, and that index subsequently points to 8 other indices, you can simply maintain a list of nodes to visit, then at each node, test whether any of the 8 sub-sections are valid (i.e. there is an intersection with the cube), if they are, add them to the "to-visit" list. Loop through until the to-visit list is empty whilst simultaneously building up a list of triangle IDs to test against later on (presumably found at the lowest level nodes).

Then once you have accumulated all of the triangles in all of the boxes that a ray intersects with through the first pass, you can then perform your nearest intersection on that small subset of triangles extracted from the model. Or alternatively, you dont nede to make a list of triangles, but can instead do the test in the previous step, maintaining a global reference to the currently closest intersection.

Using this is more optimal for a few reasons:
- We can minimise iterations, and therefore jumps by removal of the "continue" steps.
- We can control whether the structure is searched depth-first or breadth-first based on where we insert parameters in the "to-visit" list. (This may have implications depending on the situation or re-use of algorithm. Depth first for example is faster if you just want to check if the ray collides with anything at all, whereas breadth first might be a more pragmatic of finding the specific nearest intersection).
- Minimise the amount of data that needs to be stored in the "stack", as the list only needs to store IDs. This can save a fair bit of time from function calls.

There's probably no need for you to actually go away and implement this, your current solution is perfectly reasonable anyway! Just wanted to share some thoughts on the matter!

#### GMWolf

##### aka fel666
First of all, it is not possible for every recursive function to be represented iteratively
Pretty sure you can! After all, How does the compiler do it?
you have to use a stack most of the time though.
There is a theorem about it. dont remember which one.

#### FrostyCat

##### Member
First of all, it is not possible for every recursive function to be represented iteratively (it is possible for any iterative function to be represented recursively however).
Pretty sure you can! After all, How does the compiler do it?
you have to use a stack most of the time though.
There is a theorem about it. dont remember which one.
All recursive functions can be represented iteratively, it is a direct consequence of the Church-Turing Thesis. However, the choice of language can make it more difficult to convert some of them. With imperative languages, functions that are already tail-recursive generally have the easiest time converting, and the opening post demonstrates the general form that the conversion uses. Those that aren't are typically rewritten in tail-recursive form and then converted from there, which can either be manual or compiler-mediated.

#### MishMash

##### Member
Pretty sure you can! After all, How does the compiler do it?
you have to use a stack most of the time though.
There is a theorem about it. dont remember which one.
In the very next sentence: "What I mean here isn't so much to do with "recursion" in terms of function calls, but recursion in terms of using a stack. (When I say recursion, I'm talking about either recursion using the system stack with function calls, and also iteration over some form of stack structure)." I clarify that I was talking about creating an iterative representation that does not use a stack. Though it depends on how you look at it, a stack could be considered any structure that requires space complexity to store progressive information that the algorithm uses during computation. For example, you can traverse tree structures non-recursively and without using a specific stack datastructure, but each node of the tree might then need to be extended to store some progressive value. This is not true for all algorithms, and I may be wrong, but I think the Ackerman function is one definitive example of a problem that needs some form of structure to store progressive values.

So to conclude, what I mean is that the concept of what "recursion" is, is merely a form of describing an algorithm. Iterative forms are one type of function that can be represented in this form. So I guess a better discussion would be on the space complexity of an algorithm, rather than this. (As some algorithms require more space to store intermediate values than the size of the structure. Not necessarily in terms of bytes, but in terms of scalability)

Edit: So yeah, I realise my definition of recursion is incorrect, I was talking about what most programmers refer to as recursion and its implications, but the point I meant to make was with regard to the space complexity of the algorithm. Where say an algorithm with a running counter has a space complexity of O(1), however there are many algorithm's which demand a stack, which could be O(n^2) space complexity. (As my thinking is, if you are just implementing it with a stack anyway, that's functionally the same as what the hardware is doing with nested function calls and creating stack frames of the local variables, which is what you are trying to avoid by converting how the algorithm is represented.)