Rounding integers to nearest multiple of 10

A general method to round a number to a multiple of another number, rounding away from zero.

For integer

int RoundNum(int num, int step)
{
    if (num >= 0)
        return ((num + (step / 2)) / step) * step;
    else
        return ((num - (step / 2)) / step) * step;
}

For float

float RoundNum(float num, float step)
{
    if (num >= 0)
        return floor((num + step / 2) / step) * step;
    else
        return ceil((num - step / 2) / step) * step;
}

I know some parts might seem counter-intuitive or not very optimized. I tried casting (num + step / 2) to an int, but this gave wrong results for negative floats ((int) -12.0000 = -11 and such). Anyways these are a few cases I tested:

• any number rounded to step 1 should be itself
• -3 rounded to step 2 = -4
• -2 rounded to step 2 = -2
• 3 rounded to step 2 = 4
• 2 rounded to step 2 = 2
• -2.3 rounded to step 0.2 = -2.4
• -2.4 rounded to step 0.2 = -2.4
• 2.3 rounded to step 0.2 = 2.4
• 2.4 rounded to step 0.2 = 2.4

You don't need to use modulus (%) or floating point...

This works:

public static int RoundUp(int value)
{
    return 10*((value + 9)/10);
}

public static int RoundDown(int value)
{
    return 10*(value/10);
}

This code rounds to the nearest multiple of 10:

int RoundNum(int num)
{
     int rem = num % 10;
     return rem >= 5 ? (num - rem + 10) : (num - rem);
}

Very simple usage :

Console.WriteLine(RoundNum(143)); // prints 140
Console.WriteLine(RoundNum(193)); // prints 190

I would just create a couple methods;

int RoundUp(int toRound)
{
     if (toRound % 10 == 0) return toRound;
     return (10 - toRound % 10) + toRound;
}

int RoundDown(int toRound)
{
    return toRound - toRound % 10;
}

Modulus gives us the remainder, in the case of rounding up 10 - r takes you to the nearest tenth, to round down you just subtract r. Pretty straight forward.