In your example the condition is true if the mouse is over a square of size 50 centred about the position [100,100].

A couple of ways you could do this
(1) get rid of the any extra parenthesis - this works but does not affect efficiency

if (mouseX >= cirLocx - cirSize * .5 && mouseX <= cirLocx + cirSize * .5 && mouseY >= cirLocy - cirSize * .5 && mouseY <= cirLocy + cirSize * .5) {

(2) each of the conditions have duplicated calculations - do the calculation once before the if statement - improves efficiency slightly
cirHalfSize = cirSize * 0.5f;
if (mouseX >= cirLocx - cirHalfSize && mouseX <= cirLocx + cirHalfSize && mouseY >= cirLocy - cirHalfSize && mouseY <= cirLocy + cirHalfSize) {

The Java compiler like many language compilers will also apply code optimisations and this will happen here.

To explain you have 4 conditions that must ALL be true if the overall result is true i.e. the mouse is over the square.

C1 && C2 && C3 && C4

if ANY of these are false then the overall result will be false. Java will evaluate each condition in turn (left to right) if one of the is false it stops. So if C1 is true it does C2 if this is false it does NOT evaluate C3 and C4 because they cannot affect the overall result.

If you are going to to lots of tests with different values then it would be worth creating a separate method for the etst e.g.

1. boolean isOverSquare(float x, float y, float cx, float cy, float size){
2.   float hsize = size * 0.5f;
3.   return (x >= cx - hsize && x <= cx + hsize && y >= cy - hsize && y <= cy + hsize );
4. }

then your test becomes

1. if(isOverSquare(mouseX, mouseY, cirLocx, cirLocy, cirSize)== true) {
2.   executeSomeCode();
3. }

HTH

there are 4 calculations in this like:
(cirLocx - (cirSize * .5))

that's in theory time consuming.
Do those once in setup and store as borderLeft, borderRight etc.


(sorry for being late with my reply - haven't seen the other replies)

A minor point: Note x*0.5 is less efficient than x/2, though I would hope the java optimization would convert the multiply to a divide. Dividing by powers of 2 is just bit shift. 

put the four tests you're doing

1. x >= cx - hsize && x <= cx + hsize && y >= cy - hsize && y <= cy + hsize

on different threads for the processor... 

wow, thanks for all the info!  

sure, I was kidding.

I don't know anything about threads and the overhead to start a thread would be much much bigger than the time you save. Unless you start the 4 threads in setup() once and for all and then... no, kidding again...

but the other guys gave good advice already.


Good luck!

I believe the PVector approach is more elegant, although I'm not sure it is any more efficient per se.

We should never ignore the need elegant code.

Although it is a sensible approach to find algorithms that are effiecient in processing time and/or memory usage we should not forget that software must be maintainable. The best aid to maintainability is code that is clear as to its' purpose and this should not be sacrificed for the sake of efficiency (unless there is no alternative.)

A small example of what I mean

1.   PVector v = PVector.sub(sb, new PVector(mouseX, mouseY));
2.   if(abs(v.x) <= 20 && abs(v.y) <= 10) fill(200);
3.   else fill(50);
4.   rect(sb.x, sb.y, 40, 20);

is better written as

1.    PVector v = PVector.sub(sb, new PVector(mouseX, mouseY));
2.   if(abs(v.x) <= 20 && abs(v.y) <= 10)
   
3.     fill(200);
4.   else
5.     fill(50);
6.   rect(sb.x, sb.y, 40, 20);

In terms of efficiency there is no difference (apart from the source code file being 2 bytes longer) but the structure of the if statement is much clearer making the purpose of the if statement clearer.