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)));
}

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.

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. :)