Mon Dec 5 15:14:59 CET 2005 Paolo Molaro <lupus@ximian.com>

[mono.git] / mcs / class / corlib / System / Math.cs

diff --git a/mcs/class/corlib/System/Math.cs b/mcs/class/corlib/System/Math.cs
index db788210aa5bb210f31ef2a8d6437a0ea5727696..9311c2b4628720ead82894194e3ad7526bb94704 100644 (file)
--- a/mcs/class/corlib/System/Math.cs
+++ b/mcs/class/corlib/System/Math.cs
@@ -33,6 +33,10 @@
 
 using System.Runtime.CompilerServices;
 
+#if NET_2_0
+using System.Runtime.ConstrainedExecution;
+#endif
+
 namespace System
 {
        public sealed class Math
@@ -139,16 +143,25 @@ namespace System
                        return (result == -0)? 0: result;
                }
 
+#if NET_2_0
+               [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
+#endif
                public static byte Max (byte val1, byte val2)
                {
                        return (val1 > val2)? val1: val2;
                }
 
+#if NET_2_0
+               [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
+#endif
                public static decimal Max (decimal val1, decimal val2)
                {
                        return (val1 > val2)? val1: val2;
                }
 
+#if NET_2_0
+               [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
+#endif
                public static double Max (double val1, double val2)
                {
                        if (Double.IsNaN (val1) || Double.IsNaN (val2)) {
@@ -157,6 +170,9 @@ namespace System
                        return (val1 > val2)? val1: val2;
                }
 
+#if NET_2_0
+               [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
+#endif
                public static float Max (float val1, float val2)
                {
                        if (Single.IsNaN (val1) || Single.IsNaN (val2)) {
@@ -165,55 +181,85 @@ namespace System
                        return (val1 > val2)? val1: val2;
                }
 
+#if NET_2_0
+               [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
+#endif
                public static int Max (int val1, int val2)
                {
                        return (val1 > val2)? val1: val2;
                }
 
+#if NET_2_0
+               [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
+#endif
                public static long Max (long val1, long val2)
                {
                        return (val1 > val2)? val1: val2;
                }
 
+#if NET_2_0
+               [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
+#endif
                [CLSCompliant (false)]
                public static sbyte Max (sbyte val1, sbyte val2)
                {
                        return (val1 > val2)? val1: val2;
                }
 
+#if NET_2_0
+               [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
+#endif
                public static short Max (short val1, short val2)
                {
                        return (val1 > val2)? val1: val2;
                }
 
+#if NET_2_0
+               [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
+#endif
                [CLSCompliant (false)]
                public static uint Max (uint val1, uint val2)
                {
                        return (val1 > val2)? val1: val2;
                }
 
+#if NET_2_0
+               [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
+#endif
                [CLSCompliant (false)]
                public static ulong Max (ulong val1, ulong val2)
                {
                        return (val1 > val2)? val1: val2;
                }
 
+#if NET_2_0
+               [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
+#endif
                [CLSCompliant (false)]
                public static ushort Max (ushort val1, ushort val2)
                {
                        return (val1 > val2)? val1: val2;
                }
 
+#if NET_2_0
+               [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
+#endif
                public static byte Min (byte val1, byte val2)
                {
                        return (val1 < val2)? val1: val2;
                }
 
+#if NET_2_0
+               [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
+#endif
                public static decimal Min (decimal val1, decimal val2)
                {
                        return (val1 < val2)? val1: val2;
                }
 
+#if NET_2_0
+               [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
+#endif
                public static double Min (double val1, double val2)
                {
                        if (Double.IsNaN (val1) || Double.IsNaN (val2)) {
@@ -222,6 +268,9 @@ namespace System
                        return (val1 < val2)? val1: val2;
                }
 
+#if NET_2_0
+               [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
+#endif
                public static float Min (float val1, float val2)
                {
                        if (Single.IsNaN (val1) || Single.IsNaN (val2)) {
@@ -230,39 +279,60 @@ namespace System
                        return (val1 < val2)? val1: val2;
                }
 
+#if NET_2_0
+               [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
+#endif
                public static int Min (int val1, int val2)
                {
                        return (val1 < val2)? val1: val2;
                }
 
+#if NET_2_0
+               [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
+#endif
                public static long Min (long val1, long val2)
                {
                        return (val1 < val2)? val1: val2;
                }
 
+#if NET_2_0
+               [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
+#endif
                [CLSCompliant (false)]
                public static sbyte Min (sbyte val1, sbyte val2)
                {
                        return (val1 < val2)? val1: val2;
                }
 
+#if NET_2_0
+               [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
+#endif
                public static short Min (short val1, short val2)
                {
                        return (val1 < val2)? val1: val2;
                }
 
+#if NET_2_0
+               [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
+#endif
                [CLSCompliant (false)]
                public static uint Min (uint val1, uint val2)
                {
                        return (val1 < val2)? val1: val2;
                }
 
+#if NET_2_0
+               [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
+#endif
                [CLSCompliant (false)]
                public static ulong Min (ulong val1, ulong val2)
                {
                        return (val1 < val2)? val1: val2;
                }
 
+#if NET_2_0
+               [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
+#endif
                [CLSCompliant (false)]
                public static ushort Min (ushort val1, ushort val2)
                {
@@ -288,6 +358,30 @@ namespace System
                        return Decimal.Round (d, decimals);
                }
 
+#if NET_2_0
+               [MonoTODO]
+               public static decimal Round (decimal d, MidpointRounding mode)
+               {
+                       if ((mode != MidpointRounding.ToEven) && (mode != MidpointRounding.AwayFromZero))
+                               throw new ArgumentException ("The value '" + mode + "' is not valid for this usage of the type MidpointRounding.", "mode");
+
+                       if (mode == MidpointRounding.ToEven)
+                               return Round (d);
+                       throw new NotImplementedException ();
+               }
+
+               [MonoTODO]
+               public static decimal Round (decimal d, int decimals, MidpointRounding mode)
+               {
+                       if ((mode != MidpointRounding.ToEven) && (mode != MidpointRounding.AwayFromZero))
+                               throw new ArgumentException ("The value '" + mode + "' is not valid for this usage of the type MidpointRounding.", "mode");
+
+                       if (mode == MidpointRounding.ToEven)
+                               return Round (d, decimals);
+                       throw new NotImplementedException ();
+               }
+#endif
+
                [MethodImplAttribute (MethodImplOptions.InternalCall)]
                public extern static double Round (double d);
 
@@ -302,6 +396,33 @@ namespace System
                [MethodImplAttribute (MethodImplOptions.InternalCall)]
                private extern static double Round2 (double value, int digits);
 
+
+#if NET_2_0
+               public static double Round (double value, MidpointRounding mode)
+               {
+                       if ((mode != MidpointRounding.ToEven) && (mode != MidpointRounding.AwayFromZero))
+                               throw new ArgumentException ("The value '" + mode + "' is not valid for this usage of the type MidpointRounding.", "mode");
+
+                       if (mode == MidpointRounding.ToEven)
+                               return Round (value);
+                       if (value > 0)
+                               return Floor (value + 0.5);
+                       else
+                               return Ceiling (value - 0.5);
+               }
+
+               [MonoTODO]
+               public static double Round (double value, int digits, MidpointRounding mode)
+               {
+                       if ((mode != MidpointRounding.ToEven) && (mode != MidpointRounding.AwayFromZero))
+                               throw new ArgumentException ("The value '" + mode + "' is not valid for this usage of the type MidpointRounding.", "mode");
+
+                       if (mode == MidpointRounding.ToEven)
+                               return Round (value, digits);
+                       throw new NotImplementedException ();
+               }
+#endif
+
                public static int Sign (decimal value)
                {
                        if (value > 0) return 1;
@@ -393,6 +514,9 @@ namespace System
                public extern static double Pow (double x, double y);
 
                [MethodImplAttribute (MethodImplOptions.InternalCall)]
+#if NET_2_0
+               [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
+#endif
                public extern static double Sqrt (double x);
        }
 }