1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
|
//
// System.Math.cs
//
// Author:
// Bob Smith (bob@thestuff.net)
// Dan Lewis (dihlewis@yahoo.co.uk)
//
// (C) 2001 Bob Smith. http://www.thestuff.net
//
using System;
using System.Globalization;
using System.Runtime.CompilerServices;
namespace System
{
// [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 double Abs(double value)
{
return (value < 0)? -value: value;
}
public static float Abs(float value)
{
return (value < 0)? -value: value;
}
public static int Abs(int value)
{
if (value == Int32.MinValue)
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(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(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(Locale.GetText ("Value is too small"));
return (short)((value < 0)? -value: value);
}
public static double Ceiling(double a)
{
if (Double.IsNaN(a)){
return Double.NaN;
}
if (Double.IsNegativeInfinity(a)){
return Double.NegativeInfinity;
}
if (Double.IsPositiveInfinity(a)){
return Double.PositiveInfinity;
}
double b = (double)((long)a);
return (b < a)? b+1: b;
}
public static double Floor(double d) {
if (Double.IsNaN(d)){
return Double.NaN;
}
if (Double.IsNegativeInfinity(d)){
return Double.NegativeInfinity;
}
if (Double.IsPositiveInfinity(d)){
return Double.PositiveInfinity;
}
double b = (double)((long)d);
return (d < 0 && d != b) ? --b : b;
}
public static double IEEERemainder(double x, double y)
{
double r;
if (y == 0) return Double.NaN;
r = x - (y * Math.Round(x/y));
if (r != 0) return r;
return (x > 0)? 0: -0;
}
public static double Log(double a, double newBase)
{
if (a == 0) return Double.NegativeInfinity;
else if (a < 0) return Double.NaN;
return Log(a)/Log(newBase);
}
public static byte Max(byte val1, byte val2)
{
return (val1 > val2)? val1: val2;
}
public static decimal Max(decimal val1, decimal val2)
{
return (val1 > val2)? val1: val2;
}
public static double Max(double val1, double val2)
{
return (val1 > val2)? val1: val2;
}
public static float Max(float val1, float val2)
{
return (val1 > val2)? val1: val2;
}
public static int Max(int val1, int val2)
{
return (val1 > val2)? val1: val2;
}
public static long Max(long val1, long val2)
{
return (val1 > val2)? val1: val2;
}
[CLSCompliant (false)]
public static sbyte Max(sbyte val1, sbyte val2)
{
return (val1 > val2)? val1: val2;
}
public static short Max(short val1, short 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;
}
public static byte Min(byte val1, byte val2)
{
return (val1 < val2)? val1: val2;
}
public static decimal Min(decimal val1, decimal val2)
{
return (val1 < val2)? val1: val2;
}
public static double Min(double val1, double val2)
{
return (val1 < val2)? val1: val2;
}
public static float Min(float val1, float val2)
{
return (val1 < val2)? val1: val2;
}
public static int Min(int val1, int val2)
{
return (val1 < val2)? val1: val2;
}
public static long Min(long val1, long val2)
{
return (val1 < val2)? val1: val2;
}
[CLSCompliant (false)]
public static sbyte Min(sbyte val1, sbyte val2)
{
return (val1 < val2)? val1: val2;
}
public static short Min(short val1, short 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 decimal Round(decimal d)
{
decimal r = (decimal)((long)d);
decimal a = Abs (d - r);
if (a > .5M) return (r >= 0 ? ++r : --r);
else if (a <.5M) return r;
else
{
if (r%2 == 0) return r;
else return ++r;
}
}
public static decimal Round(decimal d, int decimals)
{
long p = 1;
int c;
decimal retval = d;
if (decimals < 0 || decimals > 15)
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;
retval*=p;
retval=Math.Round(retval);
retval/=p;
return retval;
}
public static double Round(double d)
{
double r = (double)((long)d);
double a = Abs (d - r);
if (a > .5) return (r >= 0 ? ++r : --r);
else if (a <.5) return r;
else
{
if (r%2 == 0) return r;
else return ++r;
}
}
public static double Round(double value, int digits) {
long p = 1;
int c;
double retval = value;
if (digits < 0 || digits > 15)
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;
retval*=p;
retval=Math.Round(retval);
retval/=p;
return retval;
}
public static int Sign(decimal value)
{
if (value > 0) return 1;
return (value == 0)? 0: -1;
}
public static int Sign(double value)
{
if (value > 0) return 1;
return (value == 0)? 0: -1;
}
public static int Sign(float value)
{
if (value > 0) return 1;
return (value == 0)? 0: -1;
}
public static int Sign(int value)
{
if (value > 0) return 1;
return (value == 0)? 0: -1;
}
public static int Sign(long value)
{
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 int Sign(short value)
{
if (value > 0) return 1;
return (value == 0)? 0: -1;
}
// internal calls
[MethodImplAttribute (MethodImplOptions.InternalCall)]
public extern static double Sin (double x);
[MethodImplAttribute (MethodImplOptions.InternalCall)]
public extern static double Cos (double x);
[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);
[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);
}
}
|
