use .ceil

math.ceil(x).toInt()

You're doing arbitrary rounding, so no there's nothing like that built in - only functions for rounding to the nearest integer in various ways.

You could write a basic rounding function like this:

fun Int.roundToClosest(step: Int): Int {
    require(step > 0)
    // in this case 'lower' meaning 'closer to zero'
    val lower = this - (this % step)
    val upper = lower + if (this >= 0) step else -step
    return if (this - lower < upper - this) lower else upper
}

println(-5.roundToClosest(10))

>> -10

In this case it "rounds up" away from zero, so for negative numbers it increases their magnitude instead of rounding up towards positive infinity. If you want ceil behaviour (rounding to positive infinity) I'll leave that as an exercise for the reader!

What is missing is ceilDiv. Although whether std lib should implement that is still (in discussion), we could implement with the help of floorDiv:

/** Divides this value by the other value, ceiling the result to an integer that is closer to positive infinity. */
fun Int.ceilDiv(other: Int): Int {
    return this.floorDiv(other) + this.rem(other).sign.absoluteValue
}

fun main() {
    println((-2).ceilDiv(2)) // -1
    println((-1).ceilDiv(2)) // 0
    println(0.ceilDiv(2)) // 0
    println(1.ceilDiv(2)) // 1
    println(2.ceilDiv(2)) // 1
    println(3.ceilDiv(2)) // 2
    println(4.ceilDiv(2)) // 2
    println("-----")
    println((-2).ceilDiv(-2)) // 1
    println((-1).ceilDiv(-2)) // 1
    println(0.ceilDiv(-2)) // 0
    println(1.ceilDiv(-2)) // 0
    println(2.ceilDiv(-2)) // -1
    println(3.ceilDiv(-2)) // -1
    println(4.ceilDiv(-2)) // -2
}

No, Math.ceil() won't work on its own because the problem occurs earlier. a and b are both integers, so dividing them evaluates to an integer which is the floor of the actual result of the division. For a = 3 and b = 2, the result is 1. The ceiling of one is also one - hence you won't get the desired result.

You must fix your division first. By casting one of the operands to a floating point number, you get a non-integer result as desired. Then you can use Math.ceil to round it up. This code should work:

Math.ceil((double)a / b);