mcs/class/corlib/System/Math.cs

   1 //
   2 // System.Math.cs
   3 //
   4 // Author:
   5 //   Bob Smith (bob@thestuff.net)
   6 //   Dan Lewis (dihlewis@yahoo.co.uk)
   7 //
   8 // (C) 2001 Bob Smith.  http://www.thestuff.net
   9 //
  10
  11 using System;
  12 using System.Globalization;
  13 using System.Runtime.CompilerServices;
  14
  15 namespace System
  16 {
  17         [CLSCompliant(false)]
  18         public sealed class Math
  19         {
  20                 public const double E = 2.7182818284590452354;
  21                 public const double PI = 3.14159265358979323846;
  22                 public static decimal Abs(decimal value)
  23                 {
  24                         return (value < 0)? -value: value;
  25                 }
  26                 public static double Abs(double value)
  27                 {
  28                         return (value < 0)? -value: value;
  29                 }
  30                 public static float Abs(float value)
  31                 {
  32                         return (value < 0)? -value: value;
  33                 }
  34                 public static int Abs(int value)
  35                 {
  36                         if (value == Int32.MinValue)
  37                                 throw new OverflowException (Locale.GetText (Locale.GetText ("Value is too small")));
  38                         return (value < 0)? -value: value;
  39                 }
  40                 public static long Abs(long value)
  41                 {
  42                         if (value == Int64.MinValue)
  43                                 throw new OverflowException(Locale.GetText ("Value is too small"));
  44                         return (value < 0)? -value: value;
  45                 }
  46                 public static sbyte Abs(sbyte value)
  47                 {
  48                         if (value == SByte.MinValue)
  49                                 throw new OverflowException(Locale.GetText ("Value is too small"));
  50                         return (sbyte)((value < 0)? -value: value);
  51                 }
  52                 public static short Abs(short value)
  53                 {
  54                         if (value == Int16.MinValue)
  55                                 throw new OverflowException(Locale.GetText ("Value is too small"));
  56                         return (short)((value < 0)? -value: value);
  57                 }
  58
  59                 public static double Ceiling(double a)
  60                 {
  61                         double b = (double)((long)a);
  62                         return (b < a)? b+1: b;
  63                 }
  64                 public static double Floor(double d) {
  65                     return (double)((long)d) ;
  66                 }
  67                 public static double IEEERemainder(double x, double y)
  68                 {
  69                         double r;
  70                         if (y == 0) return Double.NaN;
  71                         r = x - (y * Math.Round(x/y));
  72                         if (r != 0) return r;
  73                         return (x > 0)? 0: -0;
  74                 }
  75                 public static double Log(double a, double newBase)
  76                 {
  77                         if (a == 0) return Double.NegativeInfinity;
  78                         else if (a < 0) return Double.NaN;
  79                         return Log(a)/Log(newBase);
  80                 }
  81
  82                 public static byte Max(byte val1, byte val2)
  83                 {
  84                         return (val1 > val2)? val1: val2;
  85                 }
  86                 public static decimal Max(decimal val1, decimal val2)
  87                 {
  88                         return (val1 > val2)? val1: val2;
  89                 }
  90                 public static double Max(double val1, double val2)
  91                 {
  92                         return (val1 > val2)? val1: val2;
  93                 }
  94                 public static float Max(float val1, float val2)
  95                 {
  96                         return (val1 > val2)? val1: val2;
  97                 }
  98                 public static int Max(int val1, int val2)
  99                 {
 100                         return (val1 > val2)? val1: val2;
 101                 }
 102                 public static long Max(long val1, long val2)
 103                 {
 104                         return (val1 > val2)? val1: val2;
 105                 }
 106                 public static sbyte Max(sbyte val1, sbyte val2)
 107                 {
 108                         return (val1 > val2)? val1: val2;
 109                 }
 110                 public static short Max(short val1, short val2)
 111                 {
 112                         return (val1 > val2)? val1: val2;
 113                 }
 114                 public static uint Max(uint val1, uint val2)
 115                 {
 116                         return (val1 > val2)? val1: val2;
 117                 }
 118                 public static ulong Max(ulong val1, ulong val2)
 119                 {
 120                         return (val1 > val2)? val1: val2;
 121                 }
 122                 public static ushort Max(ushort val1, ushort val2)
 123                 {
 124                         return (val1 > val2)? val1: val2;
 125                 }
 126                 public static byte Min(byte val1, byte val2)
 127                 {
 128                         return (val1 < val2)? val1: val2;
 129                 }
 130                 public static decimal Min(decimal val1, decimal val2)
 131                 {
 132                         return (val1 < val2)? val1: val2;
 133                 }
 134                 public static double Min(double val1, double val2)
 135                 {
 136                         return (val1 < val2)? val1: val2;
 137                 }
 138                 public static float Min(float val1, float val2)
 139                 {
 140                         return (val1 < val2)? val1: val2;
 141                 }
 142                 public static int Min(int val1, int val2)
 143                 {
 144                         return (val1 < val2)? val1: val2;
 145                 }
 146                 public static long Min(long val1, long val2)
 147                 {
 148                         return (val1 < val2)? val1: val2;
 149                 }
 150                 public static sbyte Min(sbyte val1, sbyte val2)
 151                 {
 152                         return (val1 < val2)? val1: val2;
 153                 }
 154                 public static short Min(short val1, short val2)
 155                 {
 156                         return (val1 < val2)? val1: val2;
 157                 }
 158                 public static uint Min(uint val1, uint val2)
 159                 {
 160                         return (val1 < val2)? val1: val2;
 161                 }
 162                 public static ulong Min(ulong val1, ulong val2)
 163                 {
 164                         return (val1 < val2)? val1: val2;
 165                 }
 166                 public static ushort Min(ushort val1, ushort val2)
 167                 {
 168                         return (val1 < val2)? val1: val2;
 169                 }
 170
 171                 public static decimal Round(decimal d)
 172                 {
 173                         decimal r = (decimal)((long)d);
 174                         decimal a = d-r;
 175                         if (a > .5M) return ++r;
 176                         else if (a <.5M) return r;
 177                         else
 178                         {
 179                                 if (r%2 == 0) return r;
 180                                 else return ++r;
 181                         }
 182                 }
 183                 public static decimal Round(decimal d, int decimals)
 184                 {
 185                         long p = 10;
 186                         int c;
 187                         decimal retval = d;
 188                         if (decimals < 0 || decimals > 15)
 189                                 throw new ArgumentOutOfRangeException(Locale.GetText (
 190                                         "Value is too small or too big."));
 191                         else if (decimals == 0)
 192                                 return Math.Round(d);
 193                         for (c=0; c<decimals; c++) p*=10;
 194                         retval*=p;
 195                         retval=Math.Round(retval);
 196                         retval/=p;
 197                         return retval;
 198                 }
 199                 public static double Round(double d)
 200                 {
 201                         double r = (double)((long)d);
 202                         double a = d-r;
 203                         if (a > .5) return ++r;
 204                         else if (a <.5) return r;
 205                         else
 206                         {
 207                                 if (r%2 == 0) return r;
 208                                 else return ++r;
 209                         }
 210                 }
 211                 public static double Round(double value, int digits) {
 212                         long p = 10;
 213                         int c;
 214                         double retval = value;
 215                         if (digits < 0 || digits > 15)
 216                                 throw new ArgumentOutOfRangeException(Locale.GetText (
 217                                         "Value is too small or too big."));
 218                         else if (digits == 0)
 219                                 return Math.Round(value);
 220                         for (c=0; c<digits; c++) p*=10;
 221                         retval*=p;
 222                         retval=Math.Round(retval);
 223                         retval/=p;
 224                         return retval;
 225                 }
 226                 public static int Sign(decimal value)
 227                 {
 228                         if (value > 0) return 1;
 229                         return (value == 0)? 0: -1;
 230                 }
 231                 public static int Sign(double value)
 232                 {
 233                         if (value > 0) return 1;
 234                         return (value == 0)? 0: -1;
 235                 }
 236                 public static int Sign(float value)
 237                 {
 238                         if (value > 0) return 1;
 239                         return (value == 0)? 0: -1;
 240                 }
 241                 public static int Sign(int value)
 242                 {
 243                         if (value > 0) return 1;
 244                         return (value == 0)? 0: -1;
 245                 }
 246                 public static int Sign(long value)
 247                 {
 248                         if (value > 0) return 1;
 249                         return (value == 0)? 0: -1;
 250                 }
 251                 public static int Sign(sbyte value)
 252                 {
 253                         if (value > 0) return 1;
 254                         return (value == 0)? 0: -1;
 255                 }
 256                 public static int Sign(short value)
 257                 {
 258                         if (value > 0) return 1;
 259                         return (value == 0)? 0: -1;
 260                 }
 261
 262                 // internal calls
 263
 264                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 265                 public extern static double Sin (double x);
 266
 267                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 268                 public extern static double Cos (double x);
 269
 270                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 271                 public extern static double Tan (double x);
 272
 273                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 274                 public extern static double Sinh (double x);
 275
 276                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 277                 public extern static double Cosh (double x);
 278
 279                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 280                 public extern static double Tanh (double x);
 281
 282                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 283                 public extern static double Acos (double x);
 284
 285                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 286                 public extern static double Asin (double x);
 287
 288                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 289                 public extern static double Atan (double x);
 290
 291                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 292                 public extern static double Atan2 (double y, double x);
 293
 294                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 295                 public extern static double Exp (double x);
 296
 297                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 298                 public extern static double Log (double x);
 299
 300                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 301                 public extern static double Log10 (double x);
 302
 303                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 304                 public extern static double Pow (double x, double y);
 305
 306                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 307                 public extern static double Sqrt (double x);
 308         }
 309 }