mcs/class/corlib/System/Math.cs

   1 //
   2 // System.Math.cs
   3 //
   4 // Author:
   5 //   Bob Smith (bob@thestuff.net)
   6 //
   7 // (C) 2001 Bob Smith.  http://www.thestuff.net
   8 //
   9
  10 using System;
  11 using System.PAL;
  12 using System.Globalization;
  13 using System.Runtime.InteropServices;
  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 Acos(double d)
  60                 {
  61                         if (d < -1 || d > 1) return Double.NaN;
  62                         return OpSys.Acos(d);
  63                 }
  64
  65                 public static double Asin(double d)
  66                 {
  67                         if (d < -1 || d > 1) return Double.NaN;
  68                         return OpSys.Asin(d);
  69                 }
  70
  71                 public static double Atan(double d)
  72                 {
  73                         return OpSys.Atan(d);
  74                 }
  75
  76                 public static double Atan2(double y, double x)
  77                 {
  78                         return OpSys.Atan2(y, x);
  79                 }
  80
  81                 public static double Ceiling(double a)
  82                 {
  83                         double b = (double)((long)a);
  84                         return (b < a)? b+1: b;
  85                 }
  86
  87                 public static double Cos(double d)
  88                 {
  89                         return OpSys.Cos(d);
  90                 }
  91
  92                 public static double Cosh(double value)
  93                 {
  94                         return OpSys.Cosh(value);
  95                 }
  96
  97                 public static double Exp(double d)
  98                 {
  99                         return OpSys.Exp(d);
 100                 }
 101
 102                 public static double Floor(double d) {
 103                     return (double)((long)d) ;
 104                 }
 105                 public static double IEEERemainder(double x, double y)
 106                 {
 107                         double r;
 108                         if (y == 0) return Double.NaN;
 109                         r = x - (y * Math.Round(x/y));
 110                         if (r != 0) return r;
 111                         return (x > 0)? 0: -0;
 112                 }
 113
 114                 public static double Log(double d)
 115                 {
 116                         if (d == 0) return Double.NegativeInfinity;
 117                         else if (d < 0) return Double.NaN;
 118                         return OpSys.Log(d);
 119                 }
 120                 public static double Log(double a, double newBase)
 121                 {
 122                         if (a == 0) return Double.NegativeInfinity;
 123                         else if (a < 0) return Double.NaN;
 124                         return OpSys.Log(a)/OpSys.Log(newBase);
 125                 }
 126
 127                 public static double Log10(double d)
 128                 {
 129                         if (d == 0) return Double.NegativeInfinity;
 130                         else if (d < 0) return Double.NaN;
 131                         return OpSys.Log10(d);
 132                 }
 133                 public static byte Max(byte val1, byte val2)
 134                 {
 135                         return (val1 > val2)? val1: val2;
 136                 }
 137                 public static decimal Max(decimal val1, decimal val2)
 138                 {
 139                         return (val1 > val2)? val1: val2;
 140                 }
 141                 public static double Max(double val1, double val2)
 142                 {
 143                         return (val1 > val2)? val1: val2;
 144                 }
 145                 public static float Max(float val1, float val2)
 146                 {
 147                         return (val1 > val2)? val1: val2;
 148                 }
 149                 public static int Max(int val1, int val2)
 150                 {
 151                         return (val1 > val2)? val1: val2;
 152                 }
 153                 public static long Max(long val1, long val2)
 154                 {
 155                         return (val1 > val2)? val1: val2;
 156                 }
 157                 public static sbyte Max(sbyte val1, sbyte val2)
 158                 {
 159                         return (val1 > val2)? val1: val2;
 160                 }
 161                 public static short Max(short val1, short val2)
 162                 {
 163                         return (val1 > val2)? val1: val2;
 164                 }
 165                 public static uint Max(uint val1, uint val2)
 166                 {
 167                         return (val1 > val2)? val1: val2;
 168                 }
 169                 public static ulong Max(ulong val1, ulong val2)
 170                 {
 171                         return (val1 > val2)? val1: val2;
 172                 }
 173                 public static ushort Max(ushort val1, ushort val2)
 174                 {
 175                         return (val1 > val2)? val1: val2;
 176                 }
 177                 public static byte Min(byte val1, byte val2)
 178                 {
 179                         return (val1 < val2)? val1: val2;
 180                 }
 181                 public static decimal Min(decimal val1, decimal val2)
 182                 {
 183                         return (val1 < val2)? val1: val2;
 184                 }
 185                 public static double Min(double val1, double val2)
 186                 {
 187                         return (val1 < val2)? val1: val2;
 188                 }
 189                 public static float Min(float val1, float val2)
 190                 {
 191                         return (val1 < val2)? val1: val2;
 192                 }
 193                 public static int Min(int val1, int val2)
 194                 {
 195                         return (val1 < val2)? val1: val2;
 196                 }
 197                 public static long Min(long val1, long val2)
 198                 {
 199                         return (val1 < val2)? val1: val2;
 200                 }
 201                 public static sbyte Min(sbyte val1, sbyte val2)
 202                 {
 203                         return (val1 < val2)? val1: val2;
 204                 }
 205                 public static short Min(short val1, short val2)
 206                 {
 207                         return (val1 < val2)? val1: val2;
 208                 }
 209                 public static uint Min(uint val1, uint val2)
 210                 {
 211                         return (val1 < val2)? val1: val2;
 212                 }
 213                 public static ulong Min(ulong val1, ulong val2)
 214                 {
 215                         return (val1 < val2)? val1: val2;
 216                 }
 217                 public static ushort Min(ushort val1, ushort val2)
 218                 {
 219                         return (val1 < val2)? val1: val2;
 220                 }
 221
 222                 public static double Pow(double x, double y)
 223                 {
 224                         return OpSys.Pow(x, y);
 225                 }
 226
 227                 public static decimal Round(decimal d)
 228                 {
 229                         decimal r = (decimal)((long)d);
 230                         decimal a = d-r;
 231                         if (a > .5M) return ++r;
 232                         else if (a <.5M) return r;
 233                         else
 234                         {
 235                                 if (r%2 == 0) return r;
 236                                 else return ++r;
 237                         }
 238                 }
 239                 public static decimal Round(decimal d, int decimals)
 240                 {
 241                         long p = 10;
 242                         int c;
 243                         decimal retval = d;
 244                         if (decimals < 0 || decimals > 15)
 245                                 throw new ArgumentOutOfRangeException(Locale.GetText (
 246                                         "Value is too small or too big."));
 247                         else if (decimals == 0)
 248                                 return Math.Round(d);
 249                         for (c=0; c<decimals; c++) p*=10;
 250                         retval*=p;
 251                         retval=Math.Round(retval);
 252                         retval/=p;
 253                         return retval;
 254                 }
 255                 public static double Round(double d)
 256                 {
 257                         double r = (double)((long)d);
 258                         double a = d-r;
 259                         if (a > .5) return ++r;
 260                         else if (a <.5) return r;
 261                         else
 262                         {
 263                                 if (r%2 == 0) return r;
 264                                 else return ++r;
 265                         }
 266                 }
 267                 public static double Round(double value, int digits) {
 268                         long p = 10;
 269                         int c;
 270                         double retval = value;
 271                         if (digits < 0 || digits > 15)
 272                                 throw new ArgumentOutOfRangeException(Locale.GetText (
 273                                         "Value is too small or too big."));
 274                         else if (digits == 0)
 275                                 return Math.Round(value);
 276                         for (c=0; c<digits; c++) p*=10;
 277                         retval*=p;
 278                         retval=Math.Round(retval);
 279                         retval/=p;
 280                         return retval;
 281                 }
 282                 public static int Sign(decimal value)
 283                 {
 284                         if (value > 0) return 1;
 285                         return (value == 0)? 0: -1;
 286                 }
 287                 public static int Sign(double value)
 288                 {
 289                         if (value > 0) return 1;
 290                         return (value == 0)? 0: -1;
 291                 }
 292                 public static int Sign(float value)
 293                 {
 294                         if (value > 0) return 1;
 295                         return (value == 0)? 0: -1;
 296                 }
 297                 public static int Sign(int value)
 298                 {
 299                         if (value > 0) return 1;
 300                         return (value == 0)? 0: -1;
 301                 }
 302                 public static int Sign(long value)
 303                 {
 304                         if (value > 0) return 1;
 305                         return (value == 0)? 0: -1;
 306                 }
 307                 public static int Sign(sbyte value)
 308                 {
 309                         if (value > 0) return 1;
 310                         return (value == 0)? 0: -1;
 311                 }
 312                 public static int Sign(short value)
 313                 {
 314                         if (value > 0) return 1;
 315                         return (value == 0)? 0: -1;
 316                 }
 317
 318                 public static double Sin(double a)
 319                 {
 320                         return OpSys.Sin(a);
 321                 }
 322
 323                 public static double Sinh(double value)
 324                 {
 325                         return OpSys.Sinh(value);
 326                 }
 327
 328                 public static double Sqrt(double d)
 329                 {
 330                         if (d < 0) return Double.NaN;
 331                         return OpSys.Sqrt(d);
 332                 }
 333
 334                 public static double Tan(double a)
 335                 {
 336                         return OpSys.Tan(a);
 337                 }
 338
 339                 public static double Tanh(double value)
 340                 {
 341                         return OpSys.Tanh(value);
 342                 }
 343         }
 344 }