How do I round to the nearest 0.5?

I have to display ratings and for that, I need increments as follows:

Input	Rounded
1.0	1
1.1	1
1.2	1
1.3	1.5
1.4	1.5
1.5	1.5
1.6	1.5
1.7	1.5
1.8	2.0
1.9	2.0
2.0	2.0
2.1	2.0

and so on...

Is there a simple way to compute the required values?

Multiply your rating by 2, then round using Math.Round(rating, MidpointRounding.AwayFromZero), then divide that value by 2.

Math.Round(value * 2, MidpointRounding.AwayFromZero) / 2

Multiply by 2, round, then divide by 2

if you want nearest quarter, multiply by 4, divide by 4, etc

Here are a couple of methods I wrote that will always round up or down to any value.

public static Double RoundUpToNearest(Double passednumber, Double roundto)
{
	// 105.5 up to nearest 1 = 106
	// 105.5 up to nearest 10 = 110
	// 105.5 up to nearest 7 = 112
	// 105.5 up to nearest 100 = 200
	// 105.5 up to nearest 0.2 = 105.6
	// 105.5 up to nearest 0.3 = 105.6

	//if no rounto then just pass original number back
	if (roundto == 0)
	{
		return passednumber;
	}
	else
	{
		return Math.Ceiling(passednumber / roundto) * roundto;
	}
}

public static Double RoundDownToNearest(Double passednumber, Double roundto)
{
	// 105.5 down to nearest 1 = 105
	// 105.5 down to nearest 10 = 100
	// 105.5 down to nearest 7 = 105
	// 105.5 down to nearest 100 = 100
	// 105.5 down to nearest 0.2 = 105.4
	// 105.5 down to nearest 0.3 = 105.3

	//if no rounto then just pass original number back
	if (roundto == 0)
	{
		return passednumber;
	}
	else
	{
		return Math.Floor(passednumber / roundto) * roundto;
	}
}

There are several options. If performance is a concern, test them to see which works fastest in a large loop.

double Adjust(double input)
{
    double whole = Math.Truncate(input);
    double remainder = input - whole;
    if (remainder < 0.3)
    {
        remainder = 0;
    }
    else if (remainder < 0.8)
    {
        remainder = 0.5;
    }
    else
    {
        remainder = 1;
    }
    return whole + remainder;
}

decimal d = // your number..

decimal t = d - Math.Floor(d);
if(t >= 0.3d && t <= 0.7d)
{
    return Math.Floor(d) + 0.5d;
}
else if(t>0.7d)
    return Math.Ceil(d);
return Math.Floor(d);

Sounds like you need to round to the nearest 0.5. I see no version of round in the C# API that does this (one version takes a number of decimal digits to round to, which isn't the same thing).

Assuming you only have to deal with integer numbers of tenths, it's sufficient to calculate round (num * 2) / 2. If you're using arbitrarily precise decimals, it gets trickier. Let's hope you don't.

These lines of code snap a float dx to nearest snap:

if (snap <= 1f)
    dx = Mathf.Floor(dx) + (Mathf.Round((dx - Mathf.Floor(dx)) * (1f / snap)) * snap);
else
    dx = Mathf.Round(dx / snap) * snap;

So if snap is 0.5, value gets rounded to nearest 0.5 value (1.37 goes to 1.5), if it is 0.02, value is rounded to nearest 0.02 ((1.37 goes to 1.38)). If snap is 3, value is rounded to nearest 3 (7.4 goes to 6, 7.6 goes to 9) etc... I use it to quickly snap objects on scene in unity because unity default snapping doesn't seem to work well for me.

Public Function Round(ByVal text As TextBox) As Integer
    Dim r As String = Nothing
    If text.TextLength > 3 Then
        Dim Last3 As String = (text.Text.Substring(text.Text.Length - 3))
        If Last3.Substring(0, 1) = "." Then
            Dim dimcalvalue As String = Last3.Substring(Last3.Length - 2)
            If Val(dimcalvalue) >= 50 Then
                text.Text = Val(text.Text) - Val(Last3)
                text.Text = Val(text.Text) + 1
            ElseIf Val(dimcalvalue) < 50 Then
                text.Text = Val(text.Text) - Val(Last3)
            End If
        End If
    End If
    Return r
End Function

This answer is taken from Rosdi Kasim's comment in the answer that John Rasch provided.

John's answer works but does have an overflow possibility.

Here is my version of Rosdi's code:

I also put it in an extension to make it easy to use. The extension is not necessary and could be used as a function without issue.

<Extension>
Public Function ToHalf(value As Decimal) As Decimal
    Dim integerPart = Decimal.Truncate(value)
    Dim fractionPart = value - Decimal.Truncate(integerPart)
    Dim roundedFractionPart = Math.Round(fractionPart * 2, MidpointRounding.AwayFromZero) / 2
    Dim newValue = integerPart + roundedFractionPart
    Return newValue
End Function

The usage would then be:

Dim newValue = CDec(1.26).ToHalf

This would return 1.5

I had difficulty with this problem as well. I code mainly in Actionscript 3.0 which is base coding for the Adobe Flash Platform, but there are simularities in the Languages:

The solution I came up with is the following:

//Code for Rounding to the nearest 0.05
var r:Number = Math.random() * 10;  // NUMBER - Input Your Number here
var n:int = r * 10;   // INTEGER - Shift Decimal 2 places to right
var f:int = Math.round(r * 10 - n) * 5;// INTEGER - Test 1 or 0 then convert to 5
var d:Number = (n + (f / 10)) / 10; //  NUMBER - Re-assemble the number

trace("ORG No: " + r);
trace("NEW No: " + d);

Thats pretty much it. Note the use of 'Numbers' and 'Integers' and the way they are processed.

Good Luck!