It's for precision. The double data-type has a 53 bit mantissa. Among other things that means that a double can represent all whole up to 2^53 without precision loss.

If you store such a large number in an integer you will get an overflow. Integers only have 32 bits.

Returning the integer as a double is the right thing to do here because it offers a much wider usefull number-range than a integer could.

I guess it safe to assume it is never negative, given that doing so would be reading outside the confine of the array. If that the case, simply rotate the bits 6 times which gives the same results but is far faster than using the int divide counterpart.

int x
int y

public void myFunction()
{
     getTile(x >> 6, y >> 6).doOperation();
}

Perhaps it's an error and they really wanted Math.floor(val*100)/100.0?

I cannot reproduce the same results. Using this simple Java code below, the function without the call to Math.floor is consistently faster:

with floor elapsed milliseconds: 7354
without floor elapsed milliseconds: 4252


public class TestCast {
    private static final int REPS = Integer.MAX_VALUE / 4;

    private static void withFloor() {
        long sum = 0;
        long start = System.currentTimeMillis();
        for (int i = REPS;  i != 0;  --i) {
            sum += (int)Math.floor(Math.sqrt(i));
        }
        long end = System.currentTimeMillis();
        long elapsed = end - start;
        System.out.println("with floor elapsed milliseconds: " + elapsed);
        System.out.println(sum);
    }

    private static void withoutFloor() {
        long sum = 0;
        long start = System.currentTimeMillis();
        for (int i = REPS;  i != 0;  --i) {
            sum += (int)Math.sqrt(i);
        }
        long end = System.currentTimeMillis();
        long elapsed = end - start;
        System.out.println("without floor elapsed milliseconds: " + elapsed);
        System.out.println(sum);
    }

    public static void main(String[] args) {
        withFloor();
        withoutFloor();
    }
}

Also, looking at the disassembled byte code we can clearly see the call to Math.floor in the first function and no call in the second. There must be something else going on in your code. Perhaps you can post your code or a shortened version of it that shows the results that you are seeing.

private static void withFloor();
  Code:
     0: lconst_0      
     1: lstore_0      
     2: invokestatic  #2                  // Method java/lang/System.currentTimeMillis:()J
     5: lstore_2      
     6: ldc           #3                  // int 536870911
     8: istore        4
    10: iload         4
    12: ifeq          35
    15: lload_0       
    16: iload         4
    18: i2d           
    19: invokestatic  #4                  // Method java/lang/Math.sqrt:(D)D
    22: invokestatic  #5                  // Method java/lang/Math.floor:(D)D
    25: d2i           
    26: i2l           
    27: ladd          
    28: lstore_0      
    29: iinc          4, -1
    32: goto          10
    35: invokestatic  #2                  // Method java/lang/System.currentTimeMillis:()J
    38: lstore        4
    40: lload         4
    42: lload_2       
    43: lsub          
    44: lstore        6
    46: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
    49: new           #7                  // class java/lang/StringBuilder
    52: dup           
    53: invokespecial #8                  // Method java/lang/StringBuilder."<init>":()V
    56: ldc           #9                  // String with floor elapsed milliseconds: 
    58: invokevirtual #10                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
    61: lload         6
    63: invokevirtual #11                 // Method java/lang/StringBuilder.append:(J)Ljava/lang/StringBuilder;
    66: invokevirtual #12                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
    69: invokevirtual #13                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
    72: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
    75: lload_0       
    76: invokevirtual #14                 // Method java/io/PrintStream.println:(J)V
    79: return        

private static void withoutFloor();
  Code:
     0: lconst_0      
     1: lstore_0      
     2: invokestatic  #2                  // Method java/lang/System.currentTimeMillis:()J
     5: lstore_2      
     6: ldc           #3                  // int 536870911
     8: istore        4
    10: iload         4
    12: ifeq          32
    15: lload_0       
    16: iload         4
    18: i2d           
    19: invokestatic  #4                  // Method java/lang/Math.sqrt:(D)D
    22: d2i           
    23: i2l           
    24: ladd          
    25: lstore_0      
    26: iinc          4, -1
    29: goto          10
    32: invokestatic  #2                  // Method java/lang/System.currentTimeMillis:()J
    35: lstore        4
    37: lload         4
    39: lload_2       
    40: lsub          
    41: lstore        6
    43: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
    46: new           #7                  // class java/lang/StringBuilder
    49: dup           
    50: invokespecial #8                  // Method java/lang/StringBuilder."<init>":()V
    53: ldc           #15                 // String without floor elapsed milliseconds: 
    55: invokevirtual #10                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
    58: lload         6
    60: invokevirtual #11                 // Method java/lang/StringBuilder.append:(J)Ljava/lang/StringBuilder;
    63: invokevirtual #12                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
    66: invokevirtual #13                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
    69: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
    72: lload_0       
    73: invokevirtual #14                 // Method java/io/PrintStream.println:(J)V
    76: return        

Simple divide and cast to an integer value. Use long to achieve greater range for your numbers.

int res = (int) floatValue;
long res = (long) floatValue;

Java will always round towards zero.

• If the number's greater than zero, it'll round down.
• If the number's less than zero, it'll round up.

The trick you're 'using' helps with achieving rounding to certain digits. Again, use double for improved accurarcy and range.

public class RoundWithDigits {

    public static void main(final String[] args) {
        final double[] testNumbers = new double[] { -3, -2, -1, 0, 1, 2, 3, 5343554, 15.7 };

        for (int preserveDigits = 0; preserveDigits < 5; preserveDigits++) {
            System.out.println("Preserving digits: " + preserveDigits);
            for (int i = 0; i < testNumbers.length + 5; i++) {
                final double randomNumber = (i < testNumbers.length) ? testNumbers[i] : Math.random() * 100 - 50;
                System.out.println("\tRandom:\t" + randomNumber);
                System.out.println("\tRound:\t" + round(randomNumber, preserveDigits));
                System.out.println("\tRTZero:\t" + roundTowardsZero(randomNumber, preserveDigits));
                System.out.println("\tRUp:\t" + roundCeiling(randomNumber, preserveDigits));
                System.out.println("\tRDown:\t" + roundFloor(randomNumber, preserveDigits));
                System.out.println();
            }
            System.out.println();
        }
        System.out.println("All done.");
    }



    static public double round(final double pValue, final int pPreserveDigits) {
        final long factor = (long) Math.pow(10, pPreserveDigits);
        final long roundedMult = Math.round(pValue * factor);
        return (double) roundedMult / factor;
    }
    static public double roundTowardsZero(final double pValue, final int pPreserveDigits) {
        final long factor = (long) Math.pow(10, pPreserveDigits);
        final long roundedMult = (long) (pValue * factor);
        return (double) roundedMult / factor;
    }
    static public double roundCeiling(final double pValue, final int pPreserveDigits) {
        final long factor = (long) Math.pow(10, pPreserveDigits);
        long roundedMult = (long) (pValue * factor);
        if (roundedMult != pValue * factor && pValue > 0) ++roundedMult;
        return (double) roundedMult / factor;
    }
    static public double roundFloor(final double pValue, final int pPreserveDigits) {
        final long factor = (long) Math.pow(10, pPreserveDigits);
        long roundedMult = (long) (pValue * factor);
        if (roundedMult != pValue * factor && pValue < 0) --roundedMult;
        return (double) roundedMult / factor;
    }

}