Besides removing the parenthesis from the class declaration, there is another simple type problem below:

        x = random(r, width-r);
        y = random(r, height-r);

Use the (int) cast operator just before random():

        x = (int) random(r, width-r);
        y = (int) random(r, height-r);

Great thanks! The first problem was a rookie mistake, but I don't understand what's going on here:

Besides removing the parenthesis from the class declaration, there is another simple type problem below:

        x = random(r, width-r);
        y = random(r, height-r);

Use the (int) cast operator just before  random() :

        x = (int) random(r, width-r);
        y = (int) random(r, height-r);

because I have no idea what a cast operator is. Google couldn't seem to help me with this one in the context of Processing. (At least not as to why it is necessary)

Hey Doc!

Processing/Java, like all of programming languages derived from C, is very strict about types. They are strongly static-typed!

You've declared the variables x & y as being type int. Problem is, the random() function/method returns type float.

To force that returned float to become an int, the simplest method is to use a cast operator; in this specific case -> (int). Otherwise, that float value can't be stored inside x nor y!

Ah! And even before replying that above, I had already tweaked your code to be more compact.
Check it out:

private static final byte  foodNum = 50;
private static final short foodInterval = 3000;
private static final byte  initialOrganismNum  = 10;
private static final byte  startingEnergyLevel = 100;

private static final ArrayList<Food> food = new ArrayList(foodNum);

void setup() {

    size(700, 500);
    frameRate(10);
    fill(128);

    for (byte i=0; i<foodNum; i++)
        food.add( new Food(15, 10) );

    for (Food foodie : food)
        foodie.place();
}

void draw() {

    background(255);

    for (Food foodie : food)
        foodie.display();
}

private final class Food {
    int x, y;
    int r;
    int energy;

    Food (int rad, int ie) {
        r = rad;
        energy = ie;
    }

    final void place() {
        x = (int) random(r, width  - r);
        y = (int) random(r, height - r);
    }

    final void display() {
        ellipse(x, y, r*2, r*2);
    }
}

Thanks, that's more readable and concise, and the cast operator thing makes sense. I thought that random() returned a random integer. Anyways, I have run into another problem. I created an organism class that (apart from looking different from the food class) is exactly the same. I also rewrote what I did to declare many instances of the food class during setup() and adapted it to the organism class. It is the exact same code, just with the word "food" replaced by the word "organsim." I checked to make sure that there were no misspellings, but it is telling me that "The constructor Natural_Selection.Organism(int, float, in, int) is undefined." Another stupid error I'm sure.

The static part is useless since there will be only one instance of the sketch's class anyway, so sharing these variables among instances isn't useful here.
Final means you cannot assign again a value to this variable. So for int values, it makes them constants, but the array list can still grow, etc. You just can't do again foo = new ArrayList<Food>();

" The constructor Natural_Selection.Organism(int, float, in, int) is undefined."
This means you have a constructor for the Organism class, but you call it with the wrong parameters.

Well... I don't use final, static or private for their "usefulness". Rather for a probability that those "hints" make the Java compiler decide for a more speed-wise aggressive optimization!

• final     -> hints to compiler that the value stored won't change anymore.
• static    -> hints this is a unique global copy, it's not subjected on being instantiated.
• private -> hints its contents can't be accessed from outside the "sketch".

DocBacon! Publish your derived code so we can see what's wrong. Probably you haven't instantiated the class Organism or you're calling it w/ wrong-typed arguments!

Thanks again. It's all working, it was the issue mentioned by PhiLho. But I'm sure I will run into more simple issues that I am unable to solve. I will remember how to appease the Java compiler in the future, as I imagine with big programs those things really make a difference. It was the random thing again, because I had a random value as an argument in the organism constructor, but it was looking for an int. I really should have seen that one coming.

Although at the time I write this it is outdated, I will do my best to keep an active version of the code online and visible at  http://pastebin.com/uD23dqk0 At the moment, though, it hasn't been updated with the more concise version from GoToLoop. It's too bad that PasteBin doesn't support Processing syntax highlighting.

Yet another question, this time not a problem though. Does this:

    for (Food foodie : food)
        foodie.place();

In your code act as a foreach would in PHP? (Foreach cycles through each part of an array and does the desired action once to each element of the array)

~Dr. Bacon

Dunno about PHP, but it is indeed an enhanced for each loop type.
It's like the variable foodie behaved as -> Food foodie[0].place()   up to  Food foodie[foodNum-1].place()
Or a better explanation -> up to Food foodie[food.size-1].place(); something like this.

There are many places for hosting your Processing sketches, like:

• OpenProcessing for Java applet hosting,
• and my favorite Studio Sketchpad, which auto-converts Processing's Java code into JavaScript!
  

It's much better this way, since every1 can watch your sketches running inside a browser!

So, could I find information on this type of "foreach" in the Processing reference or elsewhere? If so, would it be called a foreach? Also, how would this be done in the context of a regular one dimensional Array of integers, so that I can get a feel for the syntax not in the context of classes or the foodie instance of my class. Also, why the colon rather than the semicolon?

Searched and found a YouTube video explaining the for each / enhanced for loop thing:
Enhanced For Loop

Hello again!

I was able to fix the code to work on JavaScript @ Studio Sketchpad!
Apparently, the way variable food was declared would bug JavaScript interpreter later on within the program; perhaps not allowing to add elements into the ArrayList!

private static final ArrayList<Food> food = new ArrayList(foodNum);

Seems like JavaScript doesn't like a pre-defined initial size for ArrayList.
Solution : use vanilla ArrayList() w/o any pre-defined initial size!

private static final ArrayList<Food> food = new ArrayList();

Check it out your program working within your browser running in native JavaScript: 

Natural Selector Simulator

That works now, but Studio Sketchpad is still buggy (or at least for me) and it will not allow me to edit past sketches, nor does it recognize when I am logged on and trying to save a sketch. I like the idea of it and will post my stuff at the end, but unless I am overlooking something obvious, it just isn't working for me. I also appreciate your interest in the project, or at least in helping me because I still would be at the declaring instances of a class within an array part of my program without everyone. I will however work on getting the program running on OpenProcessing and hopefully that will work.

OpenProcessing.org uses Java plugin applets, which is much faster than JavaScript.
However, JavaScript is a native built-in script language present in any modern browser, thus no need for any plugins!

Apparently, Studio Sketchpad doesn't allow erasing past modifications. It's cumulative forward, storing every tweak made to the code!

If a program runs reasonably fast in JavaScript, I go to Studio Sketchpad, otherwise OpenProcessing.org.

P.S.: Seems like OpenProcessing.org is hosting code in HTML5/JavaScript as well!

At least for me, it required it to be in JavaScript format when I uploaded it right from the start. I plan to release an online version of the program if all goes well, and in that case I will be sure to use JavaScript for the general lack of necessity of plugins. Otherwise, I am satisfied with OpenProcessing. I mostly just needed a place to store the actual code as well as make it and the code visible to the public.

@ http://processingjs.org/tools/processing-helper.html, you can paste a Processing Java code, and it outputs & run its JavaScript equivalent!

Pedantic note: it is written JavaScript, not Javascript... My eyes bleed when I see the latter!

Side note: indeed, Java is supposed to be faster than JS, and JS has the added inconvenience of not being able to use Java libraries. But as said, it is easier to run on most modern browsers.

So sorry. I honestly didn't know. I was somewhat tempted to use JavaScript, b/c it was 2 words and such. But for the dear of me, didn't know that was its "official" naming!  
Well, fixed Javascript to correct JavaScript naming here! 

Note 1: random(0, 1) is like random(1) and will generate a floating-point number between 0 and 1, so it is quite unlikely, if ever, to be equal to zero. A better test, to have 50 % chances of choosing one side, is:
if (random(2) > 1)
for example (or random(1) > 0.5, etc.).
Note 2: likewise, it is unlikely that a number like ixspeed is really exactly zero (unless treating it like an integer).
You can test if (int(ixspeed) == 0) or if (abs(ixspeed) < 0.001) (or other little value, depending on your needs).

Hey Doc!

Dunno if you had realized yet, but I've forked your code @ OpenProcessing just to make some experiments for myself. 
And one of the things I had to deal w/ is that sometimes, one of your "alien virus" happen not to move.

So, I've re-written your class Organism and come to a solution practically like PhiLho's:

xSpd = (int) random(1, ixSpd+1) * ( random(2)<1 ? -1:1 );

Besides that, re-done the "alien bug" drawing to scale up to width & height fields!
Although the result was not the same as the original non-scalable one. 

Here's the modded class:

private final class Organism {
    int x, y;
    int w, h;
    int xSpd, ySpd;
    int eLvl, eLvlReq, eSurv;

    Organism (
    int iWidth, int iHeight, int ixSpd, int iySpd, 
    int ieLvl, int ieReq, int ieSurv )
    {
        xSpd = (int) random(1, ixSpd+1) * ( random(2)<1 ? -1:1 );
        ySpd = (int) random(1, iySpd+1) * ( random(2)<1 ? -1:1 );

        w  = iWidth;
        h  = iHeight;

        eLvl = ieLvl;
        eLvlReq = ieReq;
        eSurv = ieSurv;
    }
    
    final void place() {
        x = (int) random( w, width  - w );
        y = (int) random( h, height - h );
    }

    final void display() {
        fill(128);
        rect(x, y, w/3, h/3); //Body

        fill(fg);
        ellipse(x, y - (h>>2), w*7 >> 3, w*7 >> 3);  //Head

        fill(bg);
        ellipse(x - (w>>2), y - (h>>2), w/3, h/5);   //Eyes
        ellipse(x + (w>>2), y - (h>>2), w/3, h/5);

        line(x - w/6, y + h/6, x - w/3, y + (h>>2)); //Legs
        line(x + w/6, y + h/6, x + w/3, y + (h>>2));
    }

    final void update() {
        if (x < (w>>1) || x > width  - (w>>1))    xSpd *= -1;
        if (y < h/2.4f || y > height - (h>>2))    ySpd *= -1;

        x += xSpd;
        y += ySpd;
    }

    final void all() {
        update();
        display();
    }
}

PhiLho: It seems to be a recurring problem that I forget that random() returns a float rather than an int. I am fusing your idea with the code from GoToLoop and will be implementing bits and pieces shortly.

*Bump*

*Bumped?*

So sorry! I haven't realized your reply!!!
Gotta learn to use <<Follow this topic>> HEHE

1st of all, you can snag everything! I'm also trying to learning Processing.
It's just code for all of us to study from each other!!!

1. Those bit-wise operators are just cryptic code fun!
When I find num/2 or num*2 for example, I just replace them by num>>1 or num<<1.
They work only on whole numbers and always result in a whole number.
Replacement usage goes like this:
num1/num2 or num1*num2  <=>  num1>>2^x or num1<<2^x. w/ 2^x = num2.
So, only this sequence can be converted for bit-wise:
2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, etc.

2 & 3. About xSpd & ySpd -> In your original solution, you were trying to avoid a random speed = 0 and, at the same time, having negative movement speeds as well!
In my algorithm, the 1st random picks a number between (1 & passed_speed_parameter).
2nd one, it relies on the ternary operator ?: It's like a built-in if check.
If picked random(2) number is < 1, it results in a -1, otherwise, a 1.
So, when they are multiplied, 50% results as a positive speed, and 50% a negative speed. Problem solved!!!

4. Indeed, within update(), the ifs statements are responsible to check whether the bugs have crossed canvas limits and then switch their speed variables' signals if it is so.
Only after those verifications, their position coordinates are changed by their speeds!

Good luck on your artificial life experiments! 

P.S.: A ternary operator means it needs 3 operands. A binary operator 2, and a unary one, just 1!

I just "*bumped*" this thread to the front. I figured it had slipped through the cracks, so I brought it back to the attention of others. I have not been able to really focus on it for the past week or two as well, and that is why I did not "bump" it sooner. The bitwise operator thing now makes sense to me, after reading your explanation and application to the code as well as rereading the processing reference page on the right bitwise operator. I have yet to implement your code, for the same reason that I haven't worked on my project in a while, but it is far more efficient than what I wrote. I figure I'll only improve with time. I kind of got what was wrong with my original code, but I didn't actually know of a more efficient way to do it. Is there any chance you can link me to your "built in if check" statement syntax page in the reference tables? I couldn't find anything that seemed to match up after a quick scan. I want to reuse those later for the genomically based bounce patterns. I am glad that you came up with the idea to consolidate bounce() and move(), as the code grows, they would have become irritating.

Hey Doc!

You can see the conditional ternary operator ?: reference here -> ?: (conditional)
An explanation about arity operator classification @ Wikipedia -> Arity

P.S.: Bit-wise operators are themselves of binary type, as most other operators are as well!
That is, they need 2 operands to work -> operand1 << operand2