That doesn't work, since your vector is normalized so a direction of (1, 1) is not possible since it has length greater than 1. What you can do is calculate the angle of your vector (possibly one of the few places were angles are worthwhile) and then do interval checks e.g. if the angle is "near" zero degrees, the direction is E, etc.. for all eight cardinal directions. But I suspect you are doing this for an UI to create a directional arrow depending on the mouse position or something, if so you can just check each half-quadrant, i.e. (in degrees for ease of understanding):

angle -22.25 to +22.5 => E

angle +22.5 to +67.5 => NE

angle +67.5 to 112.5 => N

and so on, that way every vector has a direction. But this may not be what you want. If your vector can only have eight discrete directions, then enforce it in your vector class, don't overcomplicate things. If not, properly specify your requirements so you know exactly what you need out of this function (because having a function that can return null on valid inputs is almost certainly a design flaw).

(what I mean is, if you only need eight directions but need vectors for e.g. drawing things, then you might be better off working entirely with directions and converting them to vectors as needed, which is easy, i.e. the opposite of what you're doing here - but you haven't given enough information so this is merely speculation)

I like your idea with the rounding But as you can see it doesn't work, because the transition between your conditions doesn't happen when you want them.

So back to how to properly do it, I don't know C#, really, but I would use Atan2: http://msdn.microsoft.com/en-us/library/system.math.atan2(v=vs.110).aspx .

Once you have the angle you can just use ranges as Bacterious suggested. I think this is the most legible way and efficiency-wise it not that bad.

EDIT: And if you indeed care about performance, C0lumbo has an appropriate answer below.

People are probably correct suggesting that you shouldn't end up needing this function, but to implement it I would perhaps do something like:

float fThreshold = cos(PI / 8);

If (x > fThreshold)

return East;

else if (x < -fThreshold)

return West;

else if (y > fThreshold)

return North;

else if (y < -fThreshold)

return South;

else if (x > 0 && y > 0)

return NorthEast

else if (x > 0 && y < 0)

return SouthEast

else if (x < 0 && y > 0)

return NorthWest

else if (x < 0 && y < 0)

return SouthWest

(this is assuming positive x is east and positivie y is north)

Take a normalized vector for each direction eg. 0,1 is up.

Dot product each with your normalized direction.

Find the largest value and that should be the closest direction.

That would work, of course, but does it have any advange over the Atan2 or the cosine-threshold methods? I find it more expensive and less legible than both...

Well, I guess it is more generalizable to more directions, but still...

Take a normalized vector for each direction eg. 0,1 is up.

Dot product each with your normalized direction.

Find the largest value and that should be the closest direction.

That would work, of course, but does it have any advange over the Atan2 or the cosine-threshold methods? I find it more expensive and less legible than both...

Well, I guess it is more generalizable to more directions, but still...

The dot product is only 2 multiplications and an addition in 2D so i would expect it to be faster than trigonometric functions...

It's very simple really.

float cos30 = sqrt(3.0f) / 2.0f;
float cos60 = 0.5f;

int quadrantx = (x >= cos30)? 0 : (x >= cos60)? 1 : (x >= 0.0f)? 2 : (x >= -cos60)? 3 : (x >= -cos30)? 4 : 5;
int quadranty = (y >= 0.0f)? 0 : 1;

Direction directions[12] = { Direction.E, Direction.NE, Direction.N, Direction.N, Direction.NW, Direction.W, Direction.W, Direction.SW, Direction.S, Direction.S, Direction.SE, Direction.E };

int quadrant = quadranty * 6 + quadrantx;

return directions[quadrant];