First, I might have been inattentive, but I fail to see recursion in your description. Iteration, yes, but no recursion, which consists of a function calling itself, directly or indirectly.

Second, totally unrelated to your problem, I suggest to use the modern facilities of the newest Processing versions, namely typed collections and for-each loops:

1. // Somewhere, declaration
2. ArrayList<Agent> population = new ArrayList<Agent>();
   
3. // Usage:
   
4. for (Agent a : population) {
5.    a.updatePlane();
6.  }

Concise and readable.

Now, back to your problem, I don't get what you mean by " the z-plane is being updated way too much". Is that something global or are you meaning the z coordinate for the agents augments too fast?

I am not sure to get the global picture of your sketch, and why this function is called too often, but perhaps you can put a damp tied to the time or the frame count. Eg. for each agent, memorize when this function has been last called, and return immediately if the last update is too soon.

yeah, that's not recursion. 

Right... sorry. I meant Iteration, not recursion... 

what about

1. void updatePlane() {
2.   aPos.z += 0.5;  // or     += 0.05
   
3. }

you could consider to get rid of the for loop in draw and instead use the looping of draw() itself to iterate over your arraylist

when you write to a file anyway, speed shouldn't be an issue because you can write a second program, load the results there and display them there. So you have 2 programs, one preparing slowly, one drawing quick.

Greetings, Chrisir

I suspect that the problem is not that the function is called too often rather it is the way you "comparing one agent to every other agent".

When doing this you need to avoid 2 things

1. testing the agent against itself
2. duplicationg tests between 2 agents i.e. A compare with B followed by B compare to A

In the first case the distance between them is always zero so bumping z becomes continuous, in the second case the danger is that the agents 'leapfrog' each others z value.

Taking your code and phi.lho's suggestions and aviding the two prblems above you get

1. // Somewhere, declaration
2. ArrayList<Agent> population = new ArrayList<Agent>();
   
3. // Usage: 
4. Agent a, b;
   
5. for (int i = 0; i < population.size() - 1; i++) {
6.   a = population.get(i);
   
7.   for(int j = i; j < population.size(); j++) {
8.     b = population.get(j);
9.     if(a and b are too close)
10.       a.updatePlane();
11.   }
12. }

This will test every agnt against every other agents avoid self-comparison and duplicate comparisons.

There is still a danger that agent 'a' gets updated too much but that depends on the density of agents