I think it just stands for float as in
http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

write 256.0 or
1.0

That's just an indication that the number is actually a float.

That was indeed simple.
Thanks a lot !

From that Java datatypes link, there is an interesting tidbit:

Actually, the storage space (and precision!) is determined by the type of the declaration of the variable, not by the type of the literal, unlike what is done in most dynamically typed language where that's the value which holds the type.
If you write:
double x = 1.0f;
you still use 64 bits for storing the value, the float value is converted on the fly (implicit conversion).
The literal notation is useful in some cases, for example to lift an ambiguity, eg. in parameter types:

1. void f(float x)
2. {
3.   println("F");
4. }
5. void f(double x)
6. {
7.   println("D");
8. }
9. void setup()
10. {
11.   f(1); // F
12.   f(1.0); // F! Specific to Processing, not in Java
13.   f(1.0f); // F
14.   f(1.0d); // D
15. }

Note that 1.0 in Java is a double, while in Processing, it is a float (it uses float for all functions, never double). That's because the pre-processor of Processing adds automatically a f after each literal number with a decimal point... Export the sketch and look at the generated .java file to see this.
That's why you will rarely, if ever, see this f notation in Processing sketches (but you can find it in libraries for Processing, written in pure Java).