• Create Account

# FrozenSnake

Member Since 07 Aug 2008
Offline Last Active Jan 14 2015 07:41 AM

06 January 2015 - 03:56 PM

I have made these two, guess I need a MyVector version of the second one

```public static MyVector operator*(MyVector a, MyVector b)
{
return (new MyVector(a.mX * b.mX, a.mY * b.mY, a.mZ * b.mZ));
}

public static float operator*(MyVector a, float b)
{
return (a.mX * b + a.mY * b + a.mZ * b);
}
// Edit
public static MyVector operator *(MyVector a, float b)
{
return (new MyVector(a.mX * b, a.mY * b, a.mZ * b));
}
// Edit```

*Edit* now that Calc works too. Hopefully all the operators will work from now on

If you see anything I do that should be done a different way feel free to point it out.

06 January 2015 - 03:24 PM

I do stuff like this in the C++ version:

```void Body::AddForce(const MyVector& x)		{ mForce += x; }
void Body::SetVelocity(const sf::Vector2f& vec) { mPrevPos = mPos - vec * mFrames; }
void Body::Update()
{
if (mID == 0) mForce.SetZ(0);
if (mCanMove)
{
mForce.SetZ(0);
mBodyShape.setPosition(mPos);
MyVector tempPos1(mPos);
MyVector tempPos2(mPrevPos);
MyVector calc = (tempPos1 * 2.0f - tempPos2 + mForce * mInvertedMass * (mFrames * mFrames));
mPrevPos = mPos;

mPos.x = calc.GetX();
mPos.y = calc.GetY();
}
mWindow.draw(mBodyShape);
DrawTrace();
ClearForce();
}
```

At the moment I can't get this code

```MyVector calc = (tempPos1 * 2.0f - tempPos2 + mForce * mInvertedMass * (mFrames * mFrames));
```

To work in the C# version the "tempPos1 * 2.0f - tempPos2" part gives me

Operator "-" cannot be applied to operands of type 'float' and 'SFMLapp.MyVector'

This will probably complain about something else in this line if I fix the first problem. But this is quite confusing.

```public static MyVector operator-(MyVector a, MyVector b)
{
a.mX -= b.mX;
a.mY -= b.mY;
a.mZ -= b.mZ;
return a;
}

public static float operator -(MyVector a, float b)
{
return (a.mX - b + a.mY - b + a.mZ - b);
}
```

I am doing a solar system simulation and it works like a charm in C++ and I am trying to translate it to C# and mainly the operators are acting up :/

*EDIT* Currently rewriting the operators to this format:

```public static MyVector operator x(MyVector a, MyVector b)
{
return (new MyVector(a.mX x b.mX, a.mY x b.mY, a.mZ x b.mZ));
}
```

06 January 2015 - 01:11 PM

```
public static void operator+(MyVector vec)
{
MyVector mv = new MyVector();
mv.mX += vec.mX;
mv.mY += vec.mY;
mv.mZ += vec.mZ;
}```
Will my example above work as it should or should I alter that as well?

- Create a new vector (likely with mX=0,mY=0,mZ=0).
- Add vec to the new vector.
- Won't return a value, so all the work it's doing will be lost.

In C#, all overloaded operators have to be static and have to return a value (they never modify a "this" object like you might do in C++).

I have done this now

```        public static MyVector operator+(MyVector a, MyVector b)
{
a.mX += b.mX;
a.mY += b.mY;
a.mZ += b.mZ;
return a;
}```

Hopefully that works better

06 January 2015 - 11:59 AM

This makes me a bit confused:

``` public static void operator+(MyVector vec)
{
MyVector mv = new MyVector();
mv.mX += vec.mX;
mv.mY += vec.mY;
mv.mZ += vec.mZ;
}```

Will it keep the value from mForce in this example. So I actually add 'x' to w/e value mForce already have or will the "new MyVector()" mess things up?

`mForce = mForce + x;`

*EDIT BELOW*

Since operators are static, the argument list should take both the left-hand and right-hand operands:

public static MyVector operator+(MyVector a, MyVector b)
{
return new MyVector(a.X + b.X, a.Y + b.Y, a.Z + b.Z);
}

Thanks for clarifying! Will my example above work as it should or should I alter that as well?

06 January 2015 - 11:28 AM

In .Net the modify-assignment operators are automatically overloaded for you to use your implementation of the appropriate operator.

That is... operator += is provided for you when you provide operator +.

In general, for complex value types I would recommend not using operators in that manner (although it can be trivial and simple for starting). If you want a good idea of how to design a math library, look at SlimMath.

Note that with RyuJIT just around the corner, we will soon have SIMD instructions inline in .Net which will replace many of these operations.

I'll take a look and see if I can figure it out.

That is because C# silently converts the code:

x += y;

into the code:

x = x + y;

Part of that is to help avoid the beginner's c++ bug of forgetting to implement all the corresponding operators, or the more nuanced bug of having slightly different behavior between the two operators.

You just implement your addition operator, subtraction operator, and the rest. The +=, -=, *=, /=, %=, &=, |=, ^=, and other "op plus assign" operators will use your overloaded operation.

So I should do something like the code below to get the same behavior?

I haven't been poking around in C# before so a lot of this is new to me.

```        public static MyVector operator +(MyVector vec)
{
MyVector mv = new MyVector();
return (new MyVector(mv.mX + vec.mX, mv.mY + vec.mY, mv.mZ + vec.mZ));
}

// This doesn't work, Type 'SFMLapp.MyVector' already defines a member called 'op_UnaryPlus' with the same parameter types
public static void operator+(MyVector vec) // += in the c++ code
{
MyVector mv = new MyVector();
mv.mX += vec.mX;
mv.mY += vec.mY;
mv.mZ += vec.mZ;
}
```

PARTNERS