Math library methods for ICSE: what each one returns, and where the marks slip.

int a = Math.round(3.7);      // line 3
int b = Math.pow(2, 5);       // line 4
int c = Math.sqrt(36);        // line 5

// javac says:
E.java:3: error: incompatible types: possible lossy conversion from long to int
E.java:4: error: incompatible types: possible lossy conversion from double to int
E.java:5: error: incompatible types: possible lossy conversion from double to int

Java will not quietly shrink a long or a double into an int. This is a favourite error-finding question.

int d = Math.round(3.7f);     // float in, int out
long e = Math.round(3.7);     // double in, long out
int f = (int) Math.pow(2, 5); // explicit cast
System.out.println(d + " " + e + " " + f);

// Output:
4 4 32

Pick the variable type that matches the return type, or cast on purpose. A cast truncates: (int) 4.99 is 4.

import java.util.Scanner;
class NumberReport {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        double x = sc.nextDouble();
        double ab = Math.abs(x);
        System.out.println("Absolute value: " + ab);
        System.out.println("Square root of |x|: "
            + Math.round(Math.sqrt(ab) * 100) / 100.0);
        System.out.println("Cube root of x: "
            + Math.round(Math.cbrt(x) * 100) / 100.0);
        System.out.println("Rounded: " + Math.round(x));
        System.out.println("Ceiling: " + Math.ceil(x));
        System.out.println("Floor: " + Math.floor(x));
        System.out.println("Square: " + Math.pow(x, 2));
    }
}

sqrt gets the absolute value, because a negative input would give NaN. cbrt can take x itself.

import java.util.Scanner;
class NearSquare {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a positive integer: ");
        int n = sc.nextInt();
        double root = Math.sqrt(n);
        if (root == Math.floor(root)) {
            System.out.println(n + " is a perfect square of " + (int) root);
        } else {
            int below = (int) Math.pow(Math.floor(root), 2);
            int above = (int) Math.pow(Math.ceil(root), 2);
            System.out.println("Squares either side: " + below + " and " + above);
            if (Math.abs(n - below) < Math.abs(above - n))
                System.out.println("Nearest: " + below);
            else
                System.out.println("Nearest: " + above);
        }
    }
}

No "equally near" branch is needed: neighbouring squares are always an odd distance apart, so a whole number can never sit exactly halfway.

Enter a positive integer: 196
196 is a perfect square of 14

Enter a positive integer: 90
Squares either side: 81 and 100
Nearest: 81

Enter a positive integer: 115
Squares either side: 100 and 121
Nearest: 121

root == Math.floor(root) is the perfect square test: the root has no fractional part. The casts to int are needed because pow returns double.