I'm planning to use this function to combine hashCodes. Does it make sense?

fun bitLength(n: Int) = floor(log2(n.toFloat())).toInt() + 1

fun combine(vararg numbers: Int): Int {
    var total = 0
    var prevBitLength = 0
    
    for (num in numbers) {
        total += num shl prevBitLength
        prevBitLength += bitLength(num)
    }
    
    return total
}

You might want to check out the source code for

java.util.Arrays.hashCode

I realized that two numbers could overlap, so I changed it to

private fun bitCombine(vararg numbers: Int): Int {
        var total = 0
        var prevBitLength = 0

        for (num in numbers) {
            total += num shl prevBitLength
            prevBitLength += Int.SIZE_BITS
        }

        return total
    }

I think you're going to want to xor things rather than + them. also the for loop does an allocation. and the vararg.

Why xor?

I guess I don't understand how that method doesn't int overflow immediately, since the second element is shifting left by the number of bits int supports

Thank you!

xor because there aren't a lot of ways to combine ints of size 0-2^32 without overflowing, and if you're just going for unique, it's fine

That makes sense, I guess

xor is not good for combining hashes either

Why not?

because if the two hashes are equal you get zero

good point

so it has a huge blind spot

I think if you multiplied by a prime first the xor might be okay. but yeah, it's one reason why I like data classes -- I don't have to think about it, and it doesn't get out of sync with new fields

yeah a dataclass is a pretty simple solution for this

Yeah, I just get a warning in the IDE that I shouldn't be allocating in onDraw when I use a dataclass