Math Helpers

Another useful one that I just thought I'd share is the distance between two points. Requires two 2 dimensional vector variables (Point, Vector2, etc) in order to work. This method uses the Square method included above.

public static float GetDistance(Point Point1, Point Point2) {
	return SquareRoot(Square((Point2.X - Point1.X)) + Square((Point2.Y - Point1.Y)));
}

Yea GetDistance is very useful,

I had a project where I used this alot,

this is usful when using 2D or more

Some of those overlap with the standard C# library, what's the benefit of using your versions?

There is no benefit from using my versions, but some beginners don't exactly know about the Math class in C#, also others can study the algorithms or return methods or even just the logic to see different programming styles, understand how a specific formula works completely, and other means of being useful.

On another note, I've re-written the SquareRoot method to accept different roots other than two. Special thanks to Momerath for pointing out issues with the original algorithm.

// Uses the ToPower method, and the AbsoluteValue methods provided above.
        public static float NthRoot(float Base, int Index) {
            float Δ = Index;
            float Ω = Base / Δ;

            while (AbsoluteValue(Base - ToPower(Ω, (int)Δ)) > 0.00001f) {
                Ω = (1.0f / Δ) * ((Δ - 1) * Ω + (Base / ToPower(Ω, (int)(Index - 1))));
            }

            return Ω;
        }

Another couple re-writes and useful methods are:

/// <summary>
        /// Wrap an angle between π and -π.
        /// </summary>
        /// <param name="Value">The value to wrap.</param>
        /// <returns>The wrapped value between π and -π.</returns>
        public static float Wrap(float Value) {
            while (Value < MathConstants.π)
                Value += MathConstants.π2;

            while (Value > MathConstants.π)
                Value -= MathConstants.π2;

            return Value;
        }

        /// <summary>
        /// Returns the absolute value of a floating point value.
        /// </summary>
        /// <param name="Value">A floating point number representing the value to test.</param>
        /// <returns>The absolute value of the value given.</returns>
        public static float AbsoluteValue(float Value) {
            return Value > 0 ? Value : Value * -1;
        }

        /// <summary>
        /// Holds a specified value between a minimum and maximum value.
        /// </summary>
        /// <param name="Value">The value to hold.</param>
        /// <param name="Minimum">The minimum value.</param>
        /// <param name="Maximum">The maximum value.</param>
        /// <returns>The held value between the minimum and maximum.</returns>
        public static float Hold(float Value, float Minimum, float Maximum) {
            Value = Value < Minimum ? Minimum : Value;
            Value = Value > Maximum ? Maximum : Value;
            return Value;
        }

    public class MathConstants {
        /// <summary>
        /// The numerical value of the Pi constant down to the 20th decimal place.
        /// </summary>
        public const float π = 3.1415926535897932384f;

        /// <summary>
        /// Two times Pi.
        /// </summary>
        public const float π2 = π * 2;

        /// <summary>
        /// Pi divided by 2.
        /// </summary>
        public const float πOver2 = π / 2;

        /// <summary>
        /// Pi divided by 4.
        /// </summary>
        public const float πOver4 = π / 4;

        /// <summary>
        /// The Golden Ratio, approx: 1.61803398874.
        /// </summary>
        public const float φ = (1 + MathHelper.NthRoot(5, 2)) / 2;

        /// <summary>
        /// The Omega constant, approx: 0.5671432904.
        /// </summary>
        public const float Ω = 0.5671432904f;
    }

Will be posting some physics formulas that are useful in game development later this week.

The following line needs to be converted over to the second line if anyone is using it.

public const float φ = (1 + MathHelper.NthRoot(5, 2)) / 2;
public const float φ = 1.61803398874;

Because you can't call methods apparently while assigning values to constants.

Anyways, I haven't had time to post anymore useful snippets, but I do have an archive on my laptop. This is a public computer so I don't have access to it right now. As soon as I get back to my place next week I'll post them.

While you are at it, what about reciprocal?

Good Idea; I'll generate an algorithm for that too. :)

@ddanbe Which would you perfer to see as an algorithim? I mean I can do them all but, if you had to choose one. :)

Multiplicative Inverse (Also known as Reciprocal)
Reciprocal of a Spiral
Reciprocal of a Polynomial

Sorry it took so long to get back to work on this, I got caught up in requested work. :)

Ummm. Aren't all of those the same thing? (1 / input)

There are good reasons for not using these functions. They're fine as a learning excercise for the original poster, but they're nowhere near production quality. QuadraticFomula crashes if a is zero, AbsoluteValue has an unneccesary multiplication (which the optimizer might replace) and involves unnecessary coercions if called with anything but a float. NthRoot is an inefficient way of doing what Math.Pow could do for itself (and crashes for Index==0), the SquareRoot algorithm is inefficient, and so on. The solution to beginners not knowing about the Math class in C# is to point them to the Math class, not to reinvent an inferior version.

QuadraticFomula crashes if a is zero,

It's not a quadratic equation if a is zero :) I do agree, though, that some error checking needs to be included.

There are good reasons for not using these functions. They're fine as a learning excercise for the original poster, but they're nowhere near production quality. QuadraticFomula crashes if a is zero, AbsoluteValue has an unneccesary multiplication (which the optimizer might replace) and involves unnecessary coercions if called with anything but a float. NthRoot is an inefficient way of doing what Math.Pow could do for itself (and crashes for Index==0), the SquareRoot algorithm is inefficient, and so on. The solution to beginners not knowing about the Math class in C# is to point them to the Math class, not to reinvent an inferior version.

I agree. Another thing I would like to point out, there are far too many unnecessary function calls. For instance:

public static float Square(float Value) { return Value * Value; }
public static float Cube(float Value) { return Square(Value) * Value; }

Is it really necessary to add the extra overhead of a function call when you could simply write Value * Value * Value? I do realize that the compiler will likely, with optimizations enabled, remove these calls, but when the term game development is used, it makes me think of an attempt at efficiency. While I'm on this though, I think the worst offender is:

public static float CubedSquared_Divided(float Value) { return Cube(Value) / Square(Value); }

That is 3 function calls, 1 division and some multiplication operations that could simply be replaced with:

public static float CubedSquared_Divided(float Value) { return Value; }

I'm thinking this whole post was to show us how cool pi theta and delta characters look.