//
// Author:
// Bob Smith (bob@thestuff.net)
+// Dan Lewis (dihlewis@yahoo.co.uk)
//
// (C) 2001 Bob Smith. http://www.thestuff.net
//
using System;
-using System.Runtime.InteropServices;
-using System.PAL;
+using System.Globalization;
+using System.Runtime.CompilerServices;
namespace System
{
- [CLSCompliant(false)]
+// [CLSCompliant(false)]
public sealed class Math
{
public const double E = 2.7182818284590452354;
public const double PI = 3.14159265358979323846;
+
+ private Math () {}
+
public static decimal Abs(decimal value)
{
return (value < 0)? -value: value;
public static int Abs(int value)
{
if (value == Int32.MinValue)
- throw new OverflowException("Value is too small.");
+ throw new OverflowException (Locale.GetText (Locale.GetText ("Value is too small")));
return (value < 0)? -value: value;
}
public static long Abs(long value)
{
if (value == Int64.MinValue)
- throw new OverflowException("Value is too small.");
+ throw new OverflowException(Locale.GetText ("Value is too small"));
return (value < 0)? -value: value;
}
+ [CLSCompliant (false)]
public static sbyte Abs(sbyte value)
{
if (value == SByte.MinValue)
- throw new OverflowException("Value is too small.");
+ throw new OverflowException(Locale.GetText ("Value is too small"));
return (sbyte)((value < 0)? -value: value);
}
public static short Abs(short value)
{
if (value == Int16.MinValue)
- throw new OverflowException("Value is too small.");
+ throw new OverflowException(Locale.GetText ("Value is too small"));
return (short)((value < 0)? -value: value);
}
- public static double Acos(double d)
+ public static double Ceiling(double a)
{
- if (d < -1 || d > 1) return Double.NaN;
- return OpSys.Acos(d);
- }
+ if (Double.IsNaN(a)){
+ return Double.NaN;
+ }
- public static double Asin(double d)
- {
- if (d < -1 || d > 1) return Double.NaN;
- return OpSys.Asin(d);
- }
+ if (Double.IsNegativeInfinity(a)){
+ return Double.NegativeInfinity;
+ }
- public static double Atan(double d)
- {
- return OpSys.Atan(d);
- }
+ if (Double.IsPositiveInfinity(a)){
+ return Double.PositiveInfinity;
+ }
- public static double Atan2(double y, double x)
- {
- return OpSys.Atan2(y, x);
- }
-
- public static double Ceiling(double a)
- {
- double b = (double)((long)a);
+ double b = (double)((long)a);
return (b < a)? b+1: b;
}
+ public static double Floor(double d) {
+ if (Double.IsNaN(d)){
+ return Double.NaN;
+ }
- public static double Cos(double d)
- {
- return OpSys.Cos(d);
- }
-
- public static double Cosh(double value)
- {
- return OpSys.Cosh(value);
- }
+ if (Double.IsNegativeInfinity(d)){
+ return Double.NegativeInfinity;
+ }
- public static double Exp(double d)
- {
- return OpSys.Exp(d);
- }
+ if (Double.IsPositiveInfinity(d)){
+ return Double.PositiveInfinity;
+ }
- public static double Floor(double d) {
- return (double)((long)d) ;
+ double b = (double)((long)d);
+ return (d < 0 && d != b) ? --b : b;
}
public static double IEEERemainder(double x, double y)
{
if (r != 0) return r;
return (x > 0)? 0: -0;
}
-
- public static double Log(double d)
- {
- if (d == 0) return Double.NegativeInfinity;
- else if (d < 0) return Double.NaN;
- return OpSys.Log(d);
- }
public static double Log(double a, double newBase)
{
if (a == 0) return Double.NegativeInfinity;
else if (a < 0) return Double.NaN;
- return OpSys.Log(a)/OpSys.Log(newBase);
+ return Log(a)/Log(newBase);
}
- public static double Log10(double d)
- {
- if (d == 0) return Double.NegativeInfinity;
- else if (d < 0) return Double.NaN;
- return OpSys.Log10(d);
- }
public static byte Max(byte val1, byte val2)
{
return (val1 > val2)? val1: val2;
{
return (val1 > val2)? val1: val2;
}
+
+ [CLSCompliant (false)]
public static sbyte Max(sbyte val1, sbyte val2)
{
return (val1 > val2)? val1: val2;
{
return (val1 > val2)? val1: val2;
}
+
+ [CLSCompliant (false)]
public static uint Max(uint val1, uint val2)
{
return (val1 > val2)? val1: val2;
}
+
+ [CLSCompliant (false)]
public static ulong Max(ulong val1, ulong val2)
{
return (val1 > val2)? val1: val2;
}
+
+ [CLSCompliant (false)]
public static ushort Max(ushort val1, ushort val2)
{
return (val1 > val2)? val1: val2;
{
return (val1 < val2)? val1: val2;
}
+
+ [CLSCompliant (false)]
public static sbyte Min(sbyte val1, sbyte val2)
{
return (val1 < val2)? val1: val2;
{
return (val1 < val2)? val1: val2;
}
+
+ [CLSCompliant (false)]
public static uint Min(uint val1, uint val2)
{
return (val1 < val2)? val1: val2;
}
+
+ [CLSCompliant (false)]
public static ulong Min(ulong val1, ulong val2)
{
return (val1 < val2)? val1: val2;
}
+
+ [CLSCompliant (false)]
public static ushort Min(ushort val1, ushort val2)
{
return (val1 < val2)? val1: val2;
}
- public static double Pow(double x, double y)
- {
- return OpSys.Pow(x, y);
- }
-
public static decimal Round(decimal d)
{
decimal r = (decimal)((long)d);
- decimal a = d-r;
- if (a > .5M) return ++r;
+ decimal a = Abs (d - r);
+ if (a > .5M) return (r >= 0 ? ++r : --r);
else if (a <.5M) return r;
else
{
}
public static decimal Round(decimal d, int decimals)
{
- long p = 10;
+ long p = 1;
int c;
decimal retval = d;
if (decimals < 0 || decimals > 15)
- throw new ArgumentOutOfRangeException("Value is too small or too big.");
+ throw new ArgumentOutOfRangeException(Locale.GetText (
+ "Value is too small or too big."));
else if (decimals == 0)
return Math.Round(d);
for (c=0; c<decimals; c++) p*=10;
public static double Round(double d)
{
double r = (double)((long)d);
- double a = d-r;
- if (a > .5) return ++r;
+ double a = Abs (d - r);
+ if (a > .5) return (r >= 0 ? ++r : --r);
else if (a <.5) return r;
else
{
}
}
public static double Round(double value, int digits) {
- long p = 10;
+ long p = 1;
int c;
double retval = value;
if (digits < 0 || digits > 15)
- throw new ArgumentOutOfRangeException("Value is too small or too big.");
+ throw new ArgumentOutOfRangeException(Locale.GetText (
+ "Value is too small or too big."));
else if (digits == 0)
return Math.Round(value);
for (c=0; c<digits; c++) p*=10;
if (value > 0) return 1;
return (value == 0)? 0: -1;
}
+
+ [CLSCompliant (false)]
public static int Sign(sbyte value)
{
if (value > 0) return 1;
return (value == 0)? 0: -1;
}
- public static double Sin(double a)
- {
- return OpSys.Sin(a);
- }
+ // internal calls
- public static double Sinh(double value)
- {
- return OpSys.Sinh(value);
- }
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ public extern static double Sin (double x);
- public static double Sqrt(double d)
- {
- if (d < 0) return Double.NaN;
- return OpSys.Sqrt(d);
- }
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ public extern static double Cos (double x);
- public static double Tan(double a)
- {
- return OpSys.Tan(a);
- }
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ public extern static double Tan (double x);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ public extern static double Sinh (double x);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ public extern static double Cosh (double x);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ public extern static double Tanh (double x);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ public extern static double Acos (double x);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ public extern static double Asin (double x);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ public extern static double Atan (double x);
- public static double Tanh(double value)
- {
- return OpSys.Tanh(value);
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ public extern static double Atan2 (double y, double x);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ public extern static double Exp (double x);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ public extern static double Log (double x);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ public extern static double Log10 (double x);
+
+ public static double Pow (double x, double y) {
+ if (Double.IsNaN (x) || Double.IsNaN (y))
+ return Double.NaN;
+ if (Double.IsNegativeInfinity (x))
+ if (((int)y & 1) == 1)
+ return Double.NegativeInfinity;
+ else
+ return Double.PositiveInfinity;
+ if (Double.IsPositiveInfinity (x))
+ if (Double.IsNegativeInfinity (y))
+ return 0;
+ else
+ return Double.PositiveInfinity;
+ if (Double.IsNegativeInfinity (y) || Double.IsPositiveInfinity (y))
+ return Double.NaN;
+
+ return PowImpl (x, y);
}
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ public extern static double PowImpl (double x, double y);
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall)]
+ public extern static double Sqrt (double x);
}
}
projects / mono.git / blobdiff