Hello there,

I have currently implemented the following as my means of accessing x,y,z in a vector3 as an index:


The problem with this method is the ref parameter will not allow me to use properties or indexers (such as get/set).  I also cannot find a way to overload the [] operator to allow accessing x,y,z through [i].

Can you folks please tell me how you would suggest tackling this problem and implementing this idea?

Thanks

Forgive me but what are you trying to do? Access variable x,y or z inside the vector? Why can't you access it with something like vector.X from outside?

David Amador:

Forgive me but what are you trying to do? Access variable x,y or z inside the vector? Why can't you access it with something like vector.X from outside?

Because there are situations where it can be handy to index a Vector3 or Vector4 using C-style array indexing.

As for the original poster.  I don't necessarily have an answer or even a suggestion for you, but I certainly feel your pain.

I'm pretty sure what you are asking cannot be done. You could make an extension method out of the first function you provided, but it will lose the ref which will likely have performance implications.

Any fancy syntactical sugar you try and wrapper around a struct is likely not worth the effort.

Rhys Perkins:

The problem with this method is the ref parameter will not allow me to use properties or indexers (such as get/set)

So drop the ref keyword and it'll work just fine. There's no need to have a ref there.

Awesome stuff Nick, I've changed mine to the following just because I think switch case is more legible.


Incidently, I have one for Matrix too now.  If anyone would like to see it, please shout!

Thanks for your answers everyone.

Rhys Perkins:

I have one for Matrix too now.  If anyone would like to see it, please shout!

*shout*

Try to beat this:


:D

I had this as a feature request 3 years ago when XNA 1.0 was still in beta and the devs were asking for suggestions and feedback: Vector and Matrix should provide overloaded indexer. But this is the first time it comes up in the forum, so I guess it really isn't used that often.

Here you go dude:


Reasons why it is better:

- No ref (thanks to Nick for pointing that out)
- Switch statement is more efficient (thanks to switfcoder from GameDev.net for our conversation a while back on bitwise and binary)
  At the lowest optimisation level, GCC transforms row * 16 + col into a shift + add, and at -O3 row * 16 + col is rendered in fewer instructions than row << 4 | col.

David Amador:

Forgive me but what are you trying to do? Access variable x,y or z inside the vector? Why can't you access it with something like vector.X from outside?

All my C++ Vector classes had unions where you could access the components by X,Y,Z(,W) or 0,1,2(,3). A vector IS an array after all. It helps to be able to access it like one in loops.

Rhys Perkins:

No ref (thanks to Nick for pointing that out)

Not using ref doesn't necessarily make it better. Ref is your friend when passing around large structs, which a Matrix qualifies as. You probably lose as much performance copying in the matrix data as you gain from the shifting logic.

A likely scenario for the use of this method if in a loop, the very place where ref would be most beneficial.

 

Not using ref means that I will have to make a local copy of any get/set indexer.  Does that not balance things out?

In the case of using properties it does, because the copy happens anyway when you access the struct via a property.

The way the built-in structs (Vector2, Vector3, etc) have versions of that use ref and out and versions that don't is a good indication that no solution will be best in all cases when it comes to dealing with value types. For most cases and most games it won't make any difference.

To throw something unsafe into the crazyness (note: this has not been tested and will most likely format your HDD, RRoD your 360 and do other bad stuff):

Rhys Perkins:

           switch ((row << 4) + col)  

Why multiply the row by 16? There are only four columns per row, so this just needs to multiply by 4 (or shift by 2). It's a minor detail, but making the switch values consecutive without any gaps increases the chance that this will end up translating to an efficient jump table rather than a slower series of conditional branches.

Also, the framework designer in me is bothered by the potential overflow where you could pass out of range column values that would wrap around to the next row without causing an error. I'd be tempted to explicitly validate the indices up front to avoid that.

Benchmark with 100,000,000 x 16 calls to the method

Mine: 12.12 seconds (11.72 ngen'd)
Yours: 15.89 seconds (16.56 ngen'd)

Whatever GCC does, addition or bitwise or doesn't seem to make a difference to the .NET jitter or ngen.

Given the marginal difference, I'd use the extension method any day, but I'm still targeting .NET 2.0 because of the size of the .NET 3.5 redistributable.

Shawn Hargreaves:

Why multiply the row by 16? There are only four columns per row, so this just needs to multiply by 4 (or shift by 2). It's a minor detail, but making the switch values consecutive without any gaps increases the chance that this will end up translating to an efficient jump table rather than a slower series of conditional branches.

Also, the framework designer in me is bothered by the potential overflow where you could pass out of range column values that would wrap around to the next row without causing an error. I'd be tempted to explicitly validate the indices up front to avoid that.

Good point, I've updated the method to the following:


When you sat you would be tempted to validate the indices up front, would the method of clamping the row/col values be ok?  Or did you have something else in mind?

Cygon4:

Benchmark with 100,000,000 x 16 calls to the method

What benchmarking tool would you recommend for this type of procedure?

Thanks again.

Shawn Hargreaves:

Why multiply the row by 16? There are only four columns per row, so this just needs to multiply by 4 (or shift by 2). It's a minor detail, but making the switch values consecutive without any gaps increases the chance that this will end up translating to an efficient jump table rather than a slower series of conditional branches.

I used 16 so the cases say 0x(row)(column) - the first hex digit is the matrix row, the second one the matrix column.

Shawn Hargreaves:

Also, the framework designer in me is bothered by the potential overflow where you could pass out of range column values that would wrap around to the next row without causing an error. I'd be tempted to explicitly validate the indices up front to avoid that.

True. It will catch off-by-one errors, but may not consistently fail in other cases.

So with your changes, we get this:


Let the games commence! :D

Cygon: 12.12 seconds (ngen'd 11.72 seconds)
Rhys: 15.89 seconds (ngen'd 16.56 seconds)
Shawn: 11.47 seconds (ngen'd 11.11 seconds)
Bjoern: 10.48 seconds (ngen'd 11.45 seconds)
Bjoern2: 6.2 seconds (ngen'd 5.98 seconds)

The first two implementations should probably disqualified because they don't detect all invalid inputs.
Bjoern is Bjoern's unsafe Vector3 code converted to the Matrix class.
Bjoern2 is the same but passing the matrix as a ref parameter.

There indeed seems to be some optimization .NET can perform in contiguous values for switch cases. Interesting!

Also shows that unsafe code certainly has its strengths. It's both shorter and faster. I don't know whether XNA games already require a full trust environment to run, but if so, there would be no drawbacks. If I'm not mistaken, it should even work on the XBox 360.

Rhys Perkins:

Good point, I've updated the method to the following:

// Clamp to the range [0,3]

row = (row > 3) ? 3 : row;

row = (row < 0) ? 0 : row;

Hm, I'd prefer to have it fail upon encountering invalid indices. Also, that's 4 additional branches.

Rhys Perkins:

Cygon4:

Benchmark with 100,000,000 x 16 calls to the method

What benchmarking tool would you recommend for this type of procedure?

I just wrote a short ad-hoc benchmark and made sure the compiler could not optimize anything away by sending the matrix through an external library call each round and summing up the matrix' fields:

Cygon4:

I don't know whether XNA games already require a full trust environment to run, but if so, there would be no drawbacks.

I don't believe you need full trust to use unsafe code in .NET.

Cygon4:

If I'm not mistaken, it should even work on the XBox 360.

Unsafe code works just fine on 360. :)

Nick Gravelyn:

Cygon4:

I don't know whether XNA games already require a full trust environment to run, but if so, there would be no drawbacks.

I don't believe you need full trust to use unsafe code in .NET.

Unsafe code is not verifiable by the common language runtime.

Bjoern Graf:

Nick Gravelyn:

Cygon4:

I don't know whether XNA games already require a full trust environment to run, but if so, there would be no drawbacks.

I don't believe you need full trust to use unsafe code in .NET.

Unsafe code is not verifiable by the common language runtime.

I stand corrected. :) Though this is probably the better link: http://msdn.microsoft.com/en-us/library/t2yzs44b.aspx:

In the common language runtime (CLR), unsafe code is referred to as unverifiable code. Unsafe code in C# is not necessarily dangerous; it is just code whose safety cannot be verified by the CLR. The CLR will therefore only execute unsafe code if it is in a fully trusted assembly. If you use unsafe code, it is your responsibility to ensure that your code does not introduce security risks or pointer errors.

Nick Gravelyn:

Bjoern Graf:

Nick Gravelyn:

Cygon4:

I don't know whether XNA games already require a full trust environment to run, but if so, there would be no drawbacks.

I don't believe you need full trust to use unsafe code in .NET.

Unsafe code is not verifiable by the common language runtime.

I stand corrected. :) Though this is probably the better link: http://msdn.microsoft.com/en-us/library/t2yzs44b.aspx:

In the common language runtime (CLR), unsafe code is referred to as unverifiable code. Unsafe code in C# is not necessarily dangerous; it is just code whose safety cannot be verified by the CLR. The CLR will therefore only execute unsafe code if it is in a fully trusted assembly. If you use unsafe code, it is your responsibility to ensure that your code does not introduce security risks or pointer errors.

Indeed. And to add something more: If my memory is not mistaken (although it is likely to fail here) the XNA FX already requires full trust anyway.

Cygon4:

/// <summary>Retrieves an element of the matrix by its column and row index</summary>

/// <param name="matrix">Matrix of which to retrieve an element</param>

/// <param name="row">Index of the row from which to retrieve the element</param>

/// <param name="col">Index of the column to retrieve</param>

/// <returns>The element at the given row and column</returns>

public static float Get(ref Matrix matrix, int row, int col) {

if((col < 0) || (col > 3)) {

throw new ArgumentOutOfRangeException("col", "Matrix column index out of range");

}

switch(row << 2 | col) {

case 0: { return matrix.M11; }

case 1: { return matrix.M12; }

You should validate the row input as well.  There's another overflow issue here where row could be 0x10000000 and the fn would incorrectly return Matrix.M1x
--
Danny

Cygon4:

  if((col < 0) || (col > 3)) {      throw new ArgumentOutOfRangeException("col", "Matrix column index out of range");    } 

Ok, let the microoptimization games commence :-)  I wouldn't normally write such code because it's much less obvious and therefore more likely to contain subtle errors, but this version does the same thing a little faster (just two bitwise operations and one conditional branch) and also avoiding the potential row overflow mentioned earlier:

Can something like this extend the Vector3 class, or would I have to code one from the ground up?


Vector v = new Vector();

X can now be returned with v[0].

What do you guys think?