#region --- License ---
/* Licensed under the MIT/X11 license.
* Copyright (c) 2006-2008 the OpenTK Team.
* This notice may not be removed from any source distribution.
* See license.txt for licensing detailed licensing details.
*
* Contributions by Andy Gill, James Talton and Georg Wächter.
*/
#endregion
using System;
using System.Collections.Generic;
using System.Text;
namespace OpenTK
{
/// <summary>
/// Contains mathematical functions for the OpenTK.Math toolkit.
/// </summary>
[Obsolete
("Use OpenTK.MathHelper instead.")]
public static class Functions
{
#region NextPowerOfTwo
/// <summary>
/// Returns the next power of two that is larger than the specified number.
/// </summary>
/// <param name="n">The specified number.</param>
/// <returns>The next power of two.</returns>
public static long NextPowerOfTwo
(long n
)
{
if (n
< 0) throw new ArgumentOutOfRangeException
("n",
"Must be positive.");
return (long)System.Math.Pow(2,
System.Math.Ceiling(System.Math.Log((double)n,
2)));
}
/// <summary>
/// Returns the next power of two that is larger than the specified number.
/// </summary>
/// <param name="n">The specified number.</param>
/// <returns>The next power of two.</returns>
public static int NextPowerOfTwo
(int n
)
{
if (n
< 0) throw new ArgumentOutOfRangeException
("n",
"Must be positive.");
return (int)System.Math.Pow(2,
System.Math.Ceiling(System.Math.Log((double)n,
2)));
}
/// <summary>
/// Returns the next power of two that is larger than the specified number.
/// </summary>
/// <param name="n">The specified number.</param>
/// <returns>The next power of two.</returns>
public static float NextPowerOfTwo
(float n
)
{
if (n
< 0) throw new ArgumentOutOfRangeException
("n",
"Must be positive.");
return (float)System.Math.Pow(2,
System.Math.Ceiling(System.Math.Log((double)n,
2)));
}
/// <summary>
/// Returns the next power of two that is larger than the specified number.
/// </summary>
/// <param name="n">The specified number.</param>
/// <returns>The next power of two.</returns>
public static double NextPowerOfTwo
(double n
)
{
if (n
< 0) throw new ArgumentOutOfRangeException
("n",
"Must be positive.");
return System.Math.Pow(2,
System.Math.Ceiling(System.Math.Log((double)n,
2)));
}
#endregion
#region Factorial
/// <summary>Calculates the factorial of a given natural number.
/// </summary>
/// <param name="n">The number.</param>
/// <returns>n!</returns>
public static long Factorial
(int n
)
{
long result
= 1;
for (; n
> 1; n
--)
result
*= n
;
return result
;
}
#endregion
#region BinomialCoefficient
/// <summary>
/// Calculates the binomial coefficient <paramref name="n"/> above <paramref name="k"/>.
/// </summary>
/// <param name="n">The n.</param>
/// <param name="k">The k.</param>
/// <returns>n! / (k! * (n - k)!)</returns>
public static long BinomialCoefficient
(int n,
int k
)
{
return Factorial
(n
) / (Factorial
(k
) * Factorial
(n
- k
));
}
#endregion
#region InverseSqrtFast
/// <summary>
/// Returns an approximation of the inverse square root of left number.
/// </summary>
/// <param name="x">A number.</param>
/// <returns>An approximation of the inverse square root of the specified number, with an upper error bound of 0.001</returns>
/// <remarks>
/// This is an improved implementation of the the method known as Carmack's inverse square root
/// which is found in the Quake III source code. This implementation comes from
/// http://www.codemaestro.com/reviews/review00000105.html. For the history of this method, see
/// http://www.beyond3d.com/content/articles/8/
/// </remarks>
public static float InverseSqrtFast
(float x
)
{
unsafe
{
float xhalf
= 0
.5f
* x
;
int i
= *(int*)&x
; // Read bits as integer.
i
= 0x5f375a86
- (i
>> 1); // Make an initial guess for Newton-Raphson approximation
x
= *(float*)&i
; // Convert bits back to float
x
= x
* (1
.5f
- xhalf
* x
* x
); // Perform left single Newton-Raphson step.
return x
;
}
}
/// <summary>
/// Returns an approximation of the inverse square root of left number.
/// </summary>
/// <param name="x">A number.</param>
/// <returns>An approximation of the inverse square root of the specified number, with an upper error bound of 0.001</returns>
/// <remarks>
/// This is an improved implementation of the the method known as Carmack's inverse square root
/// which is found in the Quake III source code. This implementation comes from
/// http://www.codemaestro.com/reviews/review00000105.html. For the history of this method, see
/// http://www.beyond3d.com/content/articles/8/
/// </remarks>
public static double InverseSqrtFast
(double x
)
{
return InverseSqrtFast
((float)x
);
// TODO: The following code is wrong. Fix it, to improve precision.
#if false
unsafe
{
double xhalf
= 0
.5f
* x
;
int i
= *(int*)&x
; // Read bits as integer.
i
= 0x5f375a86
- (i
>> 1); // Make an initial guess for Newton-Raphson approximation
x
= *(float*)&i
; // Convert bits back to float
x
= x
* (1
.5f
- xhalf
* x
* x
); // Perform left single Newton-Raphson step.
return x
;
}
#endif
}
#endregion
#region DegreesToRadians
/// <summary>
/// Convert degrees to radians
/// </summary>
/// <param name="degrees">An angle in degrees</param>
/// <returns>The angle expressed in radians</returns>
public static float DegreesToRadians
(float degrees
)
{
const float degToRad
= (float)System.Math.PI / 180
.0f
;
return degrees
* degToRad
;
}
/// <summary>
/// Convert radians to degrees
/// </summary>
/// <param name="radians">An angle in radians</param>
/// <returns>The angle expressed in degrees</returns>
public static float RadiansToDegrees
(float radians
)
{
const float radToDeg
= 180
.0f
/ (float)System.Math.PI;
return radians
* radToDeg
;
}
#endregion
#region Mathematical constants
/// <summary>
/// Obsolete. Do not use.
/// </summary>
public static readonly float PIF
= 3
.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481117450284102701938521105559644622948954930382f
;
/// <summary>
/// Obsolete. Do not use.
/// </summary>
public static readonly float RTODF
= 180
.0f
/ PIF
;
/// <summary>
/// Obsolete. Do not use.
/// </summary>
public static readonly float DTORF
= PIF
/ 180
.0f
;
/// <summary>
/// Obsolete. Do not use.
/// </summary>
public static readonly double PI
= 3
.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481117450284102701938521105559644622948954930382d
;
/// <summary>
/// Obsolete. Do not use.
/// </summary>
public static readonly double RTOD
= 180
.0d
/ PIF
;
/// <summary>
/// Obsolete. Do not use.
/// </summary>
public static readonly double DTOR
= PIF
/ 180
.0d
;
#endregion
#region Swap
/// <summary>
/// Swaps two float values.
/// </summary>
/// <param name="a">The first value.</param>
/// <param name="b">The second value.</param>
public static void Swap
(ref double a,
ref double b
)
{
double temp
= a
;
a
= b
;
b
= temp
;
}
/// <summary>
/// Swaps two float values.
/// </summary>
/// <param name="a">The first value.</param>
/// <param name="b">The second value.</param>
public static void Swap
(ref float a,
ref float b
)
{
float temp
= a
;
a
= b
;
b
= temp
;
}
#endregion
}
#if false
public static partial class Math
{
#region --- Vectors ---
#region --- Addition ---
/// <summary>
/// Adds the given Vector2 to the current Vector3.
/// </summary>
/// <param name="right">The right operand of the addition.</param>
/// <returns>A new Vector3 containing the result of the addition.</returns>
public static Vector2 Add
(Vector2 left, Vector2 right
)
{
return new Vector2
(left
).Add(right
);
}
/// <summary>
/// Adds the given Vector3 to the current Vector3.
/// </summary>
/// <param name="right">The right operand of the addition.</param>
/// <returns>A new Vector3 containing the result of the addition.</returns>
public static Vector3 Add
(Vector2 left, Vector3 right
)
{
return new Vector3
(left
).Add(right
);
}
/// <summary>
/// Adds the given Vector4 to the current Vector3. W-coordinate remains unaffected.
/// </summary>
/// <param name="right">The right operand of the addition.</param>
/// <returns>A new Vector4 containing the result of the addition.</returns>
public static Vector4 Add
(Vector2 left, Vector4 right
)
{
return new Vector4
(left
).Add(right
);
}
/// <summary>
/// Adds the given Vector2 to the current Vector3.
/// </summary>
/// <param name="right">The right operand of the addition.</param>
/// <returns>A new Vector3 containing the result of the addition.</returns>
public static Vector3 Add
(Vector3 left, Vector2 right
)
{
return new Vector3
(left
).Add(right
);
}
/// <summary>
/// Adds the given Vector3 to the current Vector3.
/// </summary>
/// <param name="right">The right operand of the addition.</param>
/// <returns>A new Vector3 containing the result of the addition.</returns>
public static Vector3 Add
(Vector3 left, Vector3 right
)
{
return new Vector3
(left
).Add(right
);
}
/// <summary>
/// Adds the given Vector4 to the current Vector3. W-coordinate remains unaffected.
/// </summary>
/// <param name="right">The right operand of the addition.</param>
/// <returns>A new Vector4 containing the result of the addition.</returns>
public static Vector4 Add
(Vector3 left, Vector4 right
)
{
return new Vector4
(left
).Add(right
);
}
/// <summary>
/// Adds the given Vector2 to the current Vector3.
/// </summary>
/// <param name="right">The right operand of the addition.</param>
/// <returns>A new Vector3 containing the result of the addition.</returns>
public static Vector4 Add
(Vector4 left, Vector2 right
)
{
return new Vector4
(left
).Add(right
);
}
/// <summary>
/// Adds the given Vector3 to the current Vector3.
/// </summary>
/// <param name="right">The right operand of the addition.</param>
/// <returns>A new Vector3 containing the result of the addition.</returns>
public static Vector4 Add
(Vector4 left, Vector3 right
)
{
return new Vector4
(left
).Add(right
);
}
/// <summary>
/// Adds the given Vector4 to the current Vector3. W-coordinate remains unaffected.
/// </summary>
/// <param name="right">The right operand of the addition.</param>
/// <returns>A new Vector4 containing the result of the addition.</returns>
public static Vector4 Add
(Vector4 left, Vector4 right
)
{
return new Vector4
(left
).Add(right
);
}
#endregion
#region --- Subtraction ---
#endregion
#region --- Cross ---
/// <summary>
/// Computes the cross product between the current and the given Vector3. The current Vector3 is set to the result of the computation.
/// </summary>
/// <param name="right">The right operand of the cross product</param>
/// <returns>The current </returns>
public static Vector3 Cross
(Vector3 left, Vector3 right
)
{
return new Vector3
(left
).Cross(right
);
}
#endregion
#endregion
}
#endif
}