mcs/class/corlib/System/Math.cs

   1 //
   2 // System.Math.cs
   3 //
   4 // Authors:
   5 //   Bob Smith (bob@thestuff.net)
   6 //   Dan Lewis (dihlewis@yahoo.co.uk)
   7 //   Pedro Martínez Juliá (yoros@wanadoo.es)
   8 //   Andreas Nahr (ClassDevelopment@A-SoftTech.com)
   9 //
  10 // (C) 2001 Bob Smith.  http://www.thestuff.net
  11 // Copyright (C) 2003 Pedro Martínez Juliá <yoros@wanadoo.es>
  12 // Copyright (C) 2004 Novell (http://www.novell.com)
  13 //
  14 // Permission is hereby granted, free of charge, to any person obtaining
  15 // a copy of this software and associated documentation files (the
  16 // "Software"), to deal in the Software without restriction, including
  17 // without limitation the rights to use, copy, modify, merge, publish,
  18 // distribute, sublicense, and/or sell copies of the Software, and to
  19 // permit persons to whom the Software is furnished to do so, subject to
  20 // the following conditions:
  21 //
  22 // The above copyright notice and this permission notice shall be
  23 // included in all copies or substantial portions of the Software.
  24 //
  25 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  26 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  27 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  28 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  29 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  30 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  31 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  32 //
  33
  34 using System.Runtime.CompilerServices;
  35
  36 namespace System
  37 {
  38         public sealed class Math
  39         {
  40                 public const double E = 2.7182818284590452354;
  41                 public const double PI = 3.14159265358979323846;
  42
  43                 private Math ()
  44                 {
  45                 }
  46
  47                 public static decimal Abs (decimal value)
  48                 {
  49                         return (value < 0)? -value: value;
  50                 }
  51
  52                 public static double Abs (double value)
  53                 {
  54                         return (value < 0)? -value: value;
  55                 }
  56
  57                 public static float Abs (float value)
  58                 {
  59                         return (value < 0)? -value: value;
  60                 }
  61
  62                 public static int Abs (int value)
  63                 {
  64                         if (value == Int32.MinValue)
  65                                 throw new OverflowException (Locale.GetText ("Value is too small."));
  66                         return (value < 0)? -value: value;
  67                 }
  68
  69                 public static long Abs (long value)
  70                 {
  71                         if (value == Int64.MinValue)
  72                                 throw new OverflowException (Locale.GetText ("Value is too small."));
  73                         return (value < 0)? -value: value;
  74                 }
  75
  76                 [CLSCompliant (false)]
  77                 public static sbyte Abs (sbyte value)
  78                 {
  79                         if (value == SByte.MinValue)
  80                                 throw new OverflowException (Locale.GetText ("Value is too small."));
  81                         return (sbyte)((value < 0)? -value: value);
  82                 }
  83
  84                 public static short Abs (short value)
  85                 {
  86                         if (value == Int16.MinValue)
  87                                 throw new OverflowException (Locale.GetText ("Value is too small."));
  88                         return (short)((value < 0)? -value: value);
  89                 }
  90
  91                 public static double Ceiling (double a)
  92                 {
  93                         double result = Floor(a);
  94                         if (result != a) {
  95                                 result++;
  96                         }
  97                         return result;
  98                 }
  99
 100                 // The following methods are defined in ECMA specs but they are
 101                 // not implemented in MS.NET. However, they are in MS.NET 1.1
 102
 103 #if (!NET_1_0)
 104                 public static long BigMul (int a, int b)
 105                 {
 106                         return ((long)a * (long)b);
 107                 }
 108
 109                 public static int DivRem (int a, int b, out int result)
 110                 {
 111                         result = (a % b);
 112                         return (int)(a / b);
 113                 }
 114
 115                 public static long DivRem (long a, long b, out long result)
 116                 {
 117                         result = (a % b);
 118                         return (long)(a / b);
 119                 }
 120 #endif
 121
 122                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 123                 public extern static double Floor (double value);
 124
 125                 public static double IEEERemainder (double x, double y)
 126                 {
 127                         double r;
 128                         if (y == 0)
 129                                 return Double.NaN;
 130                         r = x - (y * Math.Round(x/y));
 131                         if (r != 0)
 132                                 return r;
 133                         return (x > 0) ? 0: (BitConverter.Int64BitsToDouble (Int64.MinValue));
 134                 }
 135
 136                 public static double Log (double a, double newBase)
 137                 {
 138                         double result = Log(a) / Log(newBase);
 139                         return (result == -0)? 0: result;
 140                 }
 141
 142                 public static byte Max (byte val1, byte val2)
 143                 {
 144                         return (val1 > val2)? val1: val2;
 145                 }
 146
 147                 public static decimal Max (decimal val1, decimal val2)
 148                 {
 149                         return (val1 > val2)? val1: val2;
 150                 }
 151
 152                 public static double Max (double val1, double val2)
 153                 {
 154                         if (Double.IsNaN (val1) || Double.IsNaN (val2)) {
 155                                 return Double.NaN;
 156                         }
 157                         return (val1 > val2)? val1: val2;
 158                 }
 159
 160                 public static float Max (float val1, float val2)
 161                 {
 162                         if (Single.IsNaN (val1) || Single.IsNaN (val2)) {
 163                                 return Single.NaN;
 164                         }
 165                         return (val1 > val2)? val1: val2;
 166                 }
 167
 168                 public static int Max (int val1, int val2)
 169                 {
 170                         return (val1 > val2)? val1: val2;
 171                 }
 172
 173                 public static long Max (long val1, long val2)
 174                 {
 175                         return (val1 > val2)? val1: val2;
 176                 }
 177
 178                 [CLSCompliant (false)]
 179                 public static sbyte Max (sbyte val1, sbyte val2)
 180                 {
 181                         return (val1 > val2)? val1: val2;
 182                 }
 183
 184                 public static short Max (short val1, short val2)
 185                 {
 186                         return (val1 > val2)? val1: val2;
 187                 }
 188
 189                 [CLSCompliant (false)]
 190                 public static uint Max (uint val1, uint val2)
 191                 {
 192                         return (val1 > val2)? val1: val2;
 193                 }
 194
 195                 [CLSCompliant (false)]
 196                 public static ulong Max (ulong val1, ulong val2)
 197                 {
 198                         return (val1 > val2)? val1: val2;
 199                 }
 200
 201                 [CLSCompliant (false)]
 202                 public static ushort Max (ushort val1, ushort val2)
 203                 {
 204                         return (val1 > val2)? val1: val2;
 205                 }
 206
 207                 public static byte Min (byte val1, byte val2)
 208                 {
 209                         return (val1 < val2)? val1: val2;
 210                 }
 211
 212                 public static decimal Min (decimal val1, decimal val2)
 213                 {
 214                         return (val1 < val2)? val1: val2;
 215                 }
 216
 217                 public static double Min (double val1, double val2)
 218                 {
 219                         if (Double.IsNaN (val1) || Double.IsNaN (val2)) {
 220                                 return Double.NaN;
 221                         }
 222                         return (val1 < val2)? val1: val2;
 223                 }
 224
 225                 public static float Min (float val1, float val2)
 226                 {
 227                         if (Single.IsNaN (val1) || Single.IsNaN (val2)) {
 228                                 return Single.NaN;
 229                         }
 230                         return (val1 < val2)? val1: val2;
 231                 }
 232
 233                 public static int Min (int val1, int val2)
 234                 {
 235                         return (val1 < val2)? val1: val2;
 236                 }
 237
 238                 public static long Min (long val1, long val2)
 239                 {
 240                         return (val1 < val2)? val1: val2;
 241                 }
 242
 243                 [CLSCompliant (false)]
 244                 public static sbyte Min (sbyte val1, sbyte val2)
 245                 {
 246                         return (val1 < val2)? val1: val2;
 247                 }
 248
 249                 public static short Min (short val1, short val2)
 250                 {
 251                         return (val1 < val2)? val1: val2;
 252                 }
 253
 254                 [CLSCompliant (false)]
 255                 public static uint Min (uint val1, uint val2)
 256                 {
 257                         return (val1 < val2)? val1: val2;
 258                 }
 259
 260                 [CLSCompliant (false)]
 261                 public static ulong Min (ulong val1, ulong val2)
 262                 {
 263                         return (val1 < val2)? val1: val2;
 264                 }
 265
 266                 [CLSCompliant (false)]
 267                 public static ushort Min (ushort val1, ushort val2)
 268                 {
 269                         return (val1 < val2)? val1: val2;
 270                 }
 271
 272                 public static decimal Round (decimal d)
 273                 {
 274                         // Just call Decimal.Round(d, 0); when it rounds well.
 275                         decimal int_part = Decimal.Floor(d);
 276                         decimal dec_part = d - int_part;
 277                         if (((dec_part == 0.5M) &&
 278                                 ((2.0M * ((int_part / 2.0M) -
 279                                 Decimal.Floor(int_part / 2.0M))) != 0.0M)) ||
 280                                 (dec_part > 0.5M)) {
 281                                 int_part++;
 282                         }
 283                         return int_part;
 284                 }
 285
 286                 public static decimal Round (decimal d, int decimals)
 287                 {
 288                         return Decimal.Round (d, decimals);
 289                 }
 290
 291                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 292                 public extern static double Round (double d);
 293
 294                 public static double Round (double value, int digits)
 295                 {
 296                         if (digits < 0 || digits > 15)
 297                                 throw new ArgumentOutOfRangeException (Locale.GetText ("Value is too small or too big."));
 298
 299                         return Round2(value, digits);
 300                 }
 301
 302                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 303                 private extern static double Round2 (double value, int digits);
 304
 305                 public static int Sign (decimal value)
 306                 {
 307                         if (value > 0) return 1;
 308                         return (value == 0)? 0: -1;
 309                 }
 310
 311                 public static int Sign (double value)
 312                 {
 313                         if (Double.IsNaN (value))
 314                                 throw new ArithmeticException ("NAN");
 315                         if (value > 0) return 1;
 316                         return (value == 0)? 0: -1;
 317                 }
 318
 319                 public static int Sign (float value)
 320                 {
 321                         if (Single.IsNaN (value))
 322                                 throw new ArithmeticException ("NAN");
 323                         if (value > 0) return 1;
 324                         return (value == 0)? 0: -1;
 325                 }
 326
 327                 public static int Sign (int value)
 328                 {
 329                         if (value > 0) return 1;
 330                         return (value == 0)? 0: -1;
 331                 }
 332
 333                 public static int Sign (long value)
 334                 {
 335                         if (value > 0) return 1;
 336                         return (value == 0)? 0: -1;
 337                 }
 338
 339                 [CLSCompliant (false)]
 340                 public static int Sign (sbyte value)
 341                 {
 342                         if (value > 0) return 1;
 343                         return (value == 0)? 0: -1;
 344                 }
 345
 346                 public static int Sign (short value)
 347                 {
 348                         if (value > 0) return 1;
 349                         return (value == 0)? 0: -1;
 350                 }
 351
 352                 // internal calls
 353                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 354                 public extern static double Sin (double x);
 355
 356                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 357                 public extern static double Cos (double x);
 358
 359                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 360                 public extern static double Tan (double x);
 361
 362                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 363                 public extern static double Sinh (double x);
 364
 365                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 366                 public extern static double Cosh (double x);
 367
 368                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 369                 public extern static double Tanh (double x);
 370
 371                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 372                 public extern static double Acos (double x);
 373
 374                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 375                 public extern static double Asin (double x);
 376
 377                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 378                 public extern static double Atan (double x);
 379
 380                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 381                 public extern static double Atan2 (double y, double x);
 382
 383                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 384                 public extern static double Exp (double x);
 385
 386                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 387                 public extern static double Log (double x);
 388
 389                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 390                 public extern static double Log10 (double x);
 391
 392                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 393                 public extern static double Pow (double x, double y);
 394
 395                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 396                 public extern static double Sqrt (double x);
 397         }
 398 }