Code:
/ FXUpdate3074 / FXUpdate3074 / 1.1 / untmp / whidbey / QFE / ndp / clr / src / BCL / System / Math.cs / 1 / Math.cs
// ==++==
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// ==--==
/*============================================================
**
** Class: Math
**
**
** Purpose: Some floating-point math operations
**
**
===========================================================*/
namespace System {
//This class contains only static members and doesn't require serialization.
using System;
using System.Runtime.CompilerServices;
using System.Runtime.ConstrainedExecution;
public static class Math {
private static double doubleRoundLimit = 1e16d;
private const int maxRoundingDigits = 15;
// This table is required for the Round function which can specify the number of digits to round to
private static double[] roundPower10Double = new double[] {
1E0, 1E1, 1E2, 1E3, 1E4, 1E5, 1E6, 1E7, 1E8,
1E9, 1E10, 1E11, 1E12, 1E13, 1E14, 1E15
};
public const double PI = 3.14159265358979323846;
public const double E = 2.7182818284590452354;
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static extern double Acos(double d);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static extern double Asin(double d);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static extern double Atan(double d);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static extern double Atan2(double y,double x);
public static Decimal Ceiling(Decimal d) {
return Decimal.Ceiling(d);
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static extern double Ceiling(double a);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static extern double Cos (double d);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static extern double Cosh(double value);
public static Decimal Floor(Decimal d) {
return Decimal.Floor(d);
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static extern double Floor(double d);
private static unsafe double InternalRound(double value, int digits, MidpointRounding mode) {
if (Abs(value) < doubleRoundLimit) {
Double power10 = roundPower10Double[digits];
value *= power10;
if (mode == MidpointRounding.AwayFromZero) {
double fraction = SplitFractionDouble(&value);
if (Abs(fraction) >= 0.5d) {
value += Sign(fraction);
}
}
else {
// On X86 this can be inlined to just a few instructions
value = Round(value);
}
value /= power10;
}
return value;
}
private unsafe static double InternalTruncate(double d) {
SplitFractionDouble(&d);
return d;
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static extern double Sin(double a);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static extern double Tan(double a);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static extern double Sinh(double value);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static extern double Tanh(double value);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static extern double Round(double a);
public static double Round(double value, int digits)
{
if ((digits < 0) || (digits > maxRoundingDigits))
throw new ArgumentOutOfRangeException("digits", Environment.GetResourceString("ArgumentOutOfRange_RoundingDigits"));
return InternalRound(value, digits, MidpointRounding.ToEven);
}
public static double Round(double value, MidpointRounding mode) {
return Round(value, 0, mode);
}
public static double Round(double value, int digits, MidpointRounding mode) {
if ((digits < 0) || (digits > maxRoundingDigits))
throw new ArgumentOutOfRangeException("digits", Environment.GetResourceString("ArgumentOutOfRange_RoundingDigits"));
if (mode < MidpointRounding.ToEven || mode > MidpointRounding.AwayFromZero) {
throw new ArgumentException(Environment.GetResourceString("Argument_InvalidEnumValue", mode, "MidpointRounding"), "mode");
}
return InternalRound(value, digits, mode);
}
public static Decimal Round(Decimal d) {
return Decimal.Round(d,0);
}
public static Decimal Round(Decimal d, int decimals) {
return Decimal.Round(d,decimals);
}
public static Decimal Round(Decimal d, MidpointRounding mode) {
return Decimal.Round(d, 0, mode);
}
public static Decimal Round(Decimal d, int decimals, MidpointRounding mode) {
return Decimal.Round(d, decimals, mode);
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
private static unsafe extern double SplitFractionDouble(double* value);
public static Decimal Truncate(Decimal d) {
return Decimal.Truncate(d);
}
public static double Truncate(double d) {
return InternalTruncate(d);
}
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static extern double Sqrt(double d);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static extern double Log (double d);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static extern double Log10(double d);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static extern double Exp(double d);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static extern double Pow(double x, double y);
public static double IEEERemainder(double x, double y) {
double regularMod = x % y;
if (Double.IsNaN(regularMod)) {
return Double.NaN;
}
if (regularMod == 0) {
if (Double.IsNegative(x)) {
return Double.NegativeZero;
}
}
double alternativeResult;
alternativeResult = regularMod - (Math.Abs(y) * Math.Sign(x));
if (Math.Abs(alternativeResult) == Math.Abs(regularMod)) {
double divisionResult = x/y;
double roundedResult = Math.Round(divisionResult);
if (Math.Abs(roundedResult) > Math.Abs(divisionResult)) {
return alternativeResult;
}
else {
return regularMod;
}
}
if (Math.Abs(alternativeResult) < Math.Abs(regularMod)) {
return alternativeResult;
}
else {
return regularMod;
}
}
/*================================Abs=========================================
**Returns the absolute value of it's argument.
============================================================================*/
[CLSCompliant(false)]
public static sbyte Abs(sbyte value) {
if (value >= 0)
return value;
else
return AbsHelper(value);
}
private static sbyte AbsHelper(sbyte value)
{
BCLDebug.Assert(value < 0, "AbsHelper should only be called for negative values! (hack for JIT inlining)");
if (value == SByte.MinValue)
throw new OverflowException(Environment.GetResourceString("Overflow_NegateTwosCompNum"));
return ((sbyte)(-value));
}
public static short Abs(short value) {
if (value >= 0)
return value;
else
return AbsHelper(value);
}
private static short AbsHelper(short value) {
BCLDebug.Assert(value < 0, "AbsHelper should only be called for negative values! (hack for JIT inlining)");
if (value == Int16.MinValue)
throw new OverflowException(Environment.GetResourceString("Overflow_NegateTwosCompNum"));
return (short) -value;
}
public static int Abs(int value) {
if (value >= 0)
return value;
else
return AbsHelper(value);
}
private static int AbsHelper(int value) {
BCLDebug.Assert(value < 0, "AbsHelper should only be called for negative values! (hack for JIT inlining)");
if (value == Int32.MinValue)
throw new OverflowException(Environment.GetResourceString("Overflow_NegateTwosCompNum"));
return -value;
}
public static long Abs(long value) {
if (value >= 0)
return value;
else
return AbsHelper(value);
}
private static long AbsHelper(long value) {
BCLDebug.Assert(value < 0, "AbsHelper should only be called for negative values! (hack for JIT inlining)");
if (value == Int64.MinValue)
throw new OverflowException(Environment.GetResourceString("Overflow_NegateTwosCompNum"));
return -value;
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
extern public static float Abs(float value);
// This is special code to handle NaN (We need to make sure NaN's aren't
// negated). In CSharp, the else clause here should always be taken if
// value is NaN, since the normal case is taken if and only if value < 0.
// To illustrate this completely, a compiler has translated this into:
// "load value; load 0; bge; ret -value ; ret value".
// The bge command branches for comparisons with the unordered NaN. So
// it runs the else case, which returns +value instead of negating it.
// return (value < 0) ? -value : value;
[MethodImplAttribute(MethodImplOptions.InternalCall)]
extern public static double Abs(double value);
// This is special code to handle NaN (We need to make sure NaN's aren't
// negated). In CSharp, the else clause here should always be taken if
// value is NaN, since the normal case is taken if and only if value < 0.
// To illustrate this completely, a compiler has translated this into:
// "load value; load 0; bge; ret -value ; ret value".
// The bge command branches for comparisons with the unordered NaN. So
// it runs the else case, which returns +value instead of negating it.
// return (value < 0) ? -value : value;
public static Decimal Abs(Decimal value)
{
return Decimal.Abs(value);
}
/*================================MAX=========================================
**Returns the larger of val1 and val2
============================================================================*/
[CLSCompliant(false)]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static sbyte Max(sbyte val1, sbyte val2) {
return (val1>=val2)?val1:val2;
}
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static byte Max(byte val1, byte val2) {
return (val1>=val2)?val1:val2;
}
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static short Max(short val1, short val2) {
return (val1>=val2)?val1:val2;
}
[CLSCompliant(false)]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static ushort Max(ushort val1, ushort val2) {
return (val1>=val2)?val1:val2;
}
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static int Max(int val1, int val2) {
return (val1>=val2)?val1:val2;
}
[CLSCompliant(false)]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static uint Max(uint val1, uint val2) {
return (val1>=val2)?val1:val2;
}
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static long Max(long val1, long val2) {
return (val1>=val2)?val1:val2;
}
[CLSCompliant(false)]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static ulong Max(ulong val1, ulong val2) {
return (val1>=val2)?val1:val2;
}
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static float Max(float val1, float val2) {
if (val1 > val2)
return val1;
if (Single.IsNaN(val1))
return val1;
return val2;
}
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static double Max(double val1, double val2) {
if (val1 > val2)
return val1;
if (Double.IsNaN(val1))
return val1;
return val2;
}
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static Decimal Max(Decimal val1, Decimal val2) {
return Decimal.Max(val1,val2);
}
/*================================MIN=========================================
**Returns the smaller of val1 and val2.
============================================================================*/
[CLSCompliant(false)]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static sbyte Min(sbyte val1, sbyte val2) {
return (val1<=val2)?val1:val2;
}
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static byte Min(byte val1, byte val2) {
return (val1<=val2)?val1:val2;
}
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static short Min(short val1, short val2) {
return (val1<=val2)?val1:val2;
}
[CLSCompliant(false)]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static ushort Min(ushort val1, ushort val2) {
return (val1<=val2)?val1:val2;
}
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static int Min(int val1, int val2) {
return (val1<=val2)?val1:val2;
}
[CLSCompliant(false)]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static uint Min(uint val1, uint val2) {
return (val1<=val2)?val1:val2;
}
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static long Min(long val1, long val2) {
return (val1<=val2)?val1:val2;
}
[CLSCompliant(false)]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static ulong Min(ulong val1, ulong val2) {
return (val1<=val2)?val1:val2;
}
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static float Min(float val1, float val2) {
if (val1 < val2)
return val1;
if (Single.IsNaN(val1))
return val1;
return val2;
}
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static double Min(double val1, double val2) {
if (val1 < val2)
return val1;
if (Double.IsNaN(val1))
return val1;
return val2;
}
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static Decimal Min(Decimal val1, Decimal val2) {
return Decimal.Min(val1,val2);
}
/*=====================================Log======================================
**
==============================================================================*/
public static double Log(double a, double newBase) {
if (newBase == 1)
return Double.NaN;
if (a != 1 && (newBase == 0 || Double.IsPositiveInfinity(newBase)))
return Double.NaN;
return (Log(a)/Log(newBase));
}
// Sign function for VB. Returns -1, 0, or 1 if the sign of the number
// is negative, 0, or positive. Throws for floating point NaN's.
[CLSCompliant(false)]
public static int Sign(sbyte value)
{
if (value < 0)
return -1;
else if (value > 0)
return 1;
else
return 0;
}
// Sign function for VB. Returns -1, 0, or 1 if the sign of the number
// is negative, 0, or positive. Throws for floating point NaN's.
public static int Sign(short value)
{
if (value < 0)
return -1;
else if (value > 0)
return 1;
else
return 0;
}
// Sign function for VB. Returns -1, 0, or 1 if the sign of the number
// is negative, 0, or positive. Throws for floating point NaN's.
public static int Sign(int value)
{
if (value < 0)
return -1;
else if (value > 0)
return 1;
else
return 0;
}
public static int Sign(long value)
{
if (value < 0)
return -1;
else if (value > 0)
return 1;
else
return 0;
}
public static int Sign (float value)
{
if (value < 0)
return -1;
else if (value > 0)
return 1;
else if (value == 0)
return 0;
throw new ArithmeticException(Environment.GetResourceString("Arithmetic_NaN"));
}
public static int Sign(double value)
{
if (value < 0)
return -1;
else if (value > 0)
return 1;
else if (value == 0)
return 0;
throw new ArithmeticException(Environment.GetResourceString("Arithmetic_NaN"));
}
public static int Sign(Decimal value)
{
if (value < 0)
return -1;
else if (value > 0)
return 1;
else
return 0;
}
public static long BigMul(int a, int b) {
return ((long)a) * b;
}
public static int DivRem(int a, int b, out int result) {
result = a%b;
return a/b;
}
public static long DivRem(long a, long b, out long result) {
result = a%b;
return a/b;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- WorkflowClientDeliverMessageWrapper.cs
- FontFamily.cs
- errorpatternmatcher.cs
- TranslateTransform.cs
- FontFamilyValueSerializer.cs
- Msmq4PoisonHandler.cs
- XmlSchemaResource.cs
- DataContext.cs
- Vector3D.cs
- NetworkStream.cs
- DbUpdateCommandTree.cs
- StateInitialization.cs
- SelectionRange.cs
- ControlAdapter.cs
- TypeReference.cs
- WebPartZone.cs
- ParallelTimeline.cs
- SystemFonts.cs
- CalendarSelectionChangedEventArgs.cs
- IconHelper.cs
- _AutoWebProxyScriptHelper.cs
- CorrelationManager.cs
- AlphaSortedEnumConverter.cs
- InteropBitmapSource.cs
- TimeSpanMinutesConverter.cs
- XPathBinder.cs
- XmlNullResolver.cs
- ISO2022Encoding.cs
- LayoutManager.cs
- FixedDSBuilder.cs
- XhtmlConformanceSection.cs
- HexParser.cs
- CodeAccessSecurityEngine.cs
- DataViewManager.cs
- AppDomainFactory.cs
- DataGridViewColumnConverter.cs
- Tile.cs
- EncodingInfo.cs
- httpapplicationstate.cs
- WeakReference.cs
- HttpHandlerActionCollection.cs
- ResourceSetExpression.cs
- ActivityDesignerAccessibleObject.cs
- ArrayList.cs
- UnknownBitmapEncoder.cs
- ValueCollectionParameterReader.cs
- XmlNodeChangedEventArgs.cs
- BuildProvider.cs
- SpecularMaterial.cs
- DataGridViewUtilities.cs
- BrowserCapabilitiesCodeGenerator.cs
- RequestResponse.cs
- DesignBindingConverter.cs
- WindowsFormsHostPropertyMap.cs
- DropDownButton.cs
- CodeTryCatchFinallyStatement.cs
- Formatter.cs
- OverflowException.cs
- CodeCompiler.cs
- XPathConvert.cs
- Operators.cs
- GlobalItem.cs
- ClientBuildManager.cs
- SiteMapProvider.cs
- XsdDuration.cs
- Tokenizer.cs
- FocusChangedEventArgs.cs
- CachingHintValidation.cs
- ContentDefinition.cs
- CaseInsensitiveComparer.cs
- RemoveFromCollection.cs
- ErrorInfoXmlDocument.cs
- UpDownEvent.cs
- CacheVirtualItemsEvent.cs
- Win32Interop.cs
- ToolStripProgressBar.cs
- MsmqIntegrationChannelListener.cs
- ServiceXNameTypeConverter.cs
- MarginCollapsingState.cs
- SqlCommand.cs
- ActivityInfo.cs
- GroupDescription.cs
- GuidConverter.cs
- IntegrationExceptionEventArgs.cs
- EntityCommand.cs
- HttpHandlerAction.cs
- XmlSchemaExporter.cs
- SupportsEventValidationAttribute.cs
- GeometryHitTestParameters.cs
- UiaCoreApi.cs
- QueryStringParameter.cs
- ComponentGlyph.cs
- MenuEventArgs.cs
- PropertyMappingExceptionEventArgs.cs
- DrawingImage.cs
- CustomAttributeFormatException.cs
- RequestCacheEntry.cs
- CriticalHandle.cs
- OleDbWrapper.cs
- QilReference.cs