?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2010-04-07 Jb Evain <jbevain@novell.com>
[mcs.git] / class / corlib / System / Double.cs
blob53aa6389f9974e284bbf478bb3b3f96478115d8a
1 //
2 // System.Double.cs
3 //
4 // Author:
5 // Miguel de Icaza (miguel@ximian.com)
6 // Bob Smith (bob@thestuff.net)
7 //
8 // (C) Ximian, Inc. http://www.ximian.com
9 // (C) Bob Smith. http://www.thestuff.net
10 //
11
12 //
13 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
14 //
15 // Permission is hereby granted, free of charge, to any person obtaining
16 // a copy of this software and associated documentation files (the
17 // "Software"), to deal in the Software without restriction, including
18 // without limitation the rights to use, copy, modify, merge, publish,
19 // distribute, sublicense, and/or sell copies of the Software, and to
20 // permit persons to whom the Software is furnished to do so, subject to
21 // the following conditions:
22 //
23 // The above copyright notice and this permission notice shall be
24 // included in all copies or substantial portions of the Software.
25 //
26 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
27 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
28 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
29 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
30 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
31 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
32 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
33 //
34
35 using System.Globalization;
36 using System.Runtime.CompilerServices;
37 using System.Runtime.ConstrainedExecution;
38
39 namespace System {
40
41 [Serializable]
42 [System.Runtime.InteropServices.ComVisible (true)]
43 public struct Double : IComparable, IFormattable, IConvertible, IComparable <double>, IEquatable <double>
44 {
45 public const double Epsilon = 4.9406564584124650e-324;
46 public const double MaxValue = 1.7976931348623157e308;
47 public const double MinValue = -1.7976931348623157e308;
48 public const double NaN = 0.0d / 0.0d;
49 public const double NegativeInfinity = -1.0d / 0.0d;
50 public const double PositiveInfinity = 1.0d / 0.0d;
51
52 internal double m_value;
53
54 public int CompareTo (object value)
55 {
56 if (value == null)
57 return 1;
58
59 if (!(value is System.Double))
60 throw new ArgumentException (Locale.GetText ("Value is not a System.Double"));
61
62 double dv = (double)value;
63
64 if (IsPositiveInfinity(m_value) && IsPositiveInfinity(dv))
65 return 0;
66
67 if (IsNegativeInfinity(m_value) && IsNegativeInfinity(dv))
68 return 0;
69
70 if (IsNaN(dv))
71 if (IsNaN(m_value))
72 return 0;
73 else
74 return 1;
75
76 if (IsNaN(m_value))
77 if (IsNaN(dv))
78 return 0;
79 else
80 return -1;
81
82 if (m_value > dv) return 1;
83 else if (m_value < dv) return -1;
84 else return 0;
85 }
86
87 public override bool Equals (object obj)
88 {
89 if (!(obj is System.Double))
90 return false;
91
92 double value = (double) obj;
93
94 if (IsNaN (value))
95 return IsNaN (m_value);
96
97 return (value == m_value);
98 }
99
100 public int CompareTo (double value)
101 {
102 if (IsPositiveInfinity(m_value) && IsPositiveInfinity(value))
103 return 0;
104
105 if (IsNegativeInfinity(m_value) && IsNegativeInfinity(value))
106 return 0;
107
108 if (IsNaN(value))
109 if (IsNaN(m_value))
110 return 0;
111 else
112 return 1;
113
114 if (IsNaN(m_value))
115 if (IsNaN(value))
116 return 0;
117 else
118 return -1;
119
120 if (m_value > value) return 1;
121 else if (m_value < value) return -1;
122 else return 0;
123 }
124
125 public bool Equals (double obj)
126 {
127 if (IsNaN (obj)) {
128 if (IsNaN(m_value))
129 return true;
130 else
131 return false;
132 }
133
134 return obj == m_value;
135 }
136
137 public override unsafe int GetHashCode ()
138 {
139 double d = m_value;
140 return (*((long*)&d)).GetHashCode ();
141 }
142
143 #if NET_4_0
144 public static bool operator==(double a, double b)
145 {
146 return a == b;
147 }
148
149 public static bool operator!=(double a, double b)
150 {
151 return a != b;
152 }
153
154 public static bool operator>(double a, double b)
155 {
156 return a > b;
157 }
158
159 public static bool operator>=(double a, double b)
160 {
161 return a >= b;
162 }
163
164 public static bool operator<(double a, double b)
165 {
166 return a < b;
167 }
168
169 public static bool operator<=(double a, double b)
170 {
171 return a <= b;
172 }
173 #endif
174
175 public static bool IsInfinity (double d)
176 {
177 return (d == PositiveInfinity || d == NegativeInfinity);
178 }
179
180 [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
181 public static bool IsNaN (double d)
182 {
183 #pragma warning disable 1718
184 return (d != d);
185 #pragma warning restore
186 }
187
188 public static bool IsNegativeInfinity (double d)
189 {
190 return (d < 0.0d && (d == NegativeInfinity || d == PositiveInfinity));
191 }
192
193 public static bool IsPositiveInfinity (double d)
194 {
195 return (d > 0.0d && (d == NegativeInfinity || d == PositiveInfinity));
196 }
197
198 public static double Parse (string s)
199 {
200 return Parse (s, (NumberStyles.Float | NumberStyles.AllowThousands), null);
201 }
202
203 public static double Parse (string s, IFormatProvider provider)
204 {
205 return Parse (s, (NumberStyles.Float | NumberStyles.AllowThousands), provider);
206 }
207
208 public static double Parse (string s, NumberStyles style)
209 {
210 return Parse (s, style, null);
211 }
212
213 // We're intentionally using constants here to avoid some bigger headaches in mcs.
214 // This struct must be compiled before System.Enum so we can't use enums here.
215 private const int State_AllowSign = 1;
216 private const int State_Digits = 2;
217 private const int State_Decimal = 3;
218 private const int State_ExponentSign = 4;
219 private const int State_Exponent = 5;
220 private const int State_ConsumeWhiteSpace = 6;
221 private const int State_Exit = 7;
222
223 public static double Parse (string s, NumberStyles style, IFormatProvider provider)
224 {
225 Exception exc;
226 double result;
227
228 if (!Parse (s, style, provider, false, out result, out exc))
229 throw exc;
230
231 return result;
232 }
233
234 // FIXME: check if digits are group in correct numbers between the group separators
235 internal static bool Parse (string s, NumberStyles style, IFormatProvider provider, bool tryParse, out double result, out Exception exc)
236 {
237 result = 0;
238 exc = null;
239
240 if (s == null) {
241 if (!tryParse)
242 exc = new ArgumentNullException ("s");
243 return false;
244 }
245 if (s.Length == 0) {
246 if (!tryParse)
247 exc = new FormatException ();
248 return false;
249 }
250 // yes it's counter intuitive (buggy?) but even TryParse actually throws in this case
251 if ((style & NumberStyles.AllowHexSpecifier) != 0) {
252 string msg = Locale.GetText ("Double doesn't support parsing with '{0}'.", "AllowHexSpecifier");
253 throw new ArgumentException (msg);
254 }
255 if (style > NumberStyles.Any) {
256 if (!tryParse)
257 exc = new ArgumentException();
258 return false;
259 }
260
261 NumberFormatInfo format = NumberFormatInfo.GetInstance(provider);
262 if (format == null) throw new Exception("How did this happen?");
263
264 //
265 // validate and prepare string for C
266 //
267 int len = s.Length;
268 int didx = 0;
269 int sidx = 0;
270 char c;
271 bool allow_leading_white = (style & NumberStyles.AllowLeadingWhite) != 0;
272 bool allow_trailing_white = ((style & NumberStyles.AllowTrailingWhite) != 0);
273
274 if (allow_leading_white) {
275 while (sidx < len && Char.IsWhiteSpace (s [sidx]))
276 sidx++;
277
278 if (sidx == len) {
279 if (!tryParse)
280 exc = Int32.GetFormatException ();
281 return false;
282 }
283 }
284 int sEndPos = s.Length - 1;
285 if (allow_trailing_white)
286 while (Char.IsWhiteSpace (s [sEndPos]))
287 sEndPos--;
288
289 if (TryParseStringConstant (format.NaNSymbol, s, sidx, sEndPos)) {
290 result = double.NaN;
291 return true;
292 }
293 if (TryParseStringConstant (format.PositiveInfinitySymbol, s, sidx, sEndPos)) {
294 result = double.PositiveInfinity;
295 return true;
296 }
297 if (TryParseStringConstant (format.NegativeInfinitySymbol, s, sidx, sEndPos)) {
298 result = double.NegativeInfinity;
299 return true;
300 }
301
302 byte [] b = new byte [len + 1];
303
304 //
305 // Machine state
306 //
307 int state = State_AllowSign;
308
309 //
310 // Setup
311 //
312 string decimal_separator = null;
313 string group_separator = null;
314 string currency_symbol = null;
315 int decimal_separator_len = 0;
316 int group_separator_len = 0;
317 int currency_symbol_len = 0;
318 if ((style & NumberStyles.AllowDecimalPoint) != 0){
319 decimal_separator = format.NumberDecimalSeparator;
320 decimal_separator_len = decimal_separator.Length;
321 }
322 if ((style & NumberStyles.AllowThousands) != 0){
323 group_separator = format.NumberGroupSeparator;
324 group_separator_len = group_separator.Length;
325 }
326 if ((style & NumberStyles.AllowCurrencySymbol) != 0){
327 currency_symbol = format.CurrencySymbol;
328 currency_symbol_len = currency_symbol.Length;
329 }
330 string positive = format.PositiveSign;
331 string negative = format.NegativeSign;
332
333 for (; sidx < len; sidx++){
334 c = s [sidx];
335
336 if (c == '\0') {
337 sidx = len;
338 continue;
339 }
340
341 switch (state){
342 case State_AllowSign:
343 if ((style & NumberStyles.AllowLeadingSign) != 0){
344 if (c == positive [0] &&
345 s.Substring (sidx, positive.Length) == positive){
346 state = State_Digits;
347 sidx += positive.Length-1;
348 continue;
349 }
350
351 if (c == negative [0] &&
352 s.Substring (sidx, negative.Length) == negative){
353 state = State_Digits;
354 b [didx++] = (byte) '-';
355 sidx += negative.Length-1;
356 continue;
357 }
358 }
359 state = State_Digits;
360 goto case State_Digits;
361
362 case State_Digits:
363 if (Char.IsDigit (c)){
364 b [didx++] = (byte) c;
365 break;
366 }
367 if (c == 'e' || c == 'E')
368 goto case State_Decimal;
369
370 if (decimal_separator_len > 0 &&
371 decimal_separator [0] == c) {
372 if (String.CompareOrdinal (s, sidx, decimal_separator, 0, decimal_separator_len) == 0) {
373 b [didx++] = (byte) '.';
374 sidx += decimal_separator_len-1;
375 state = State_Decimal;
376 break;
377 }
378 }
379 if (group_separator_len > 0 &&
380 group_separator [0] == c){
381 if (s.Substring (sidx, group_separator_len) ==
382 group_separator){
383 sidx += group_separator_len-1;
384 state = State_Digits;
385 break;
386 }
387 }
388 if (currency_symbol_len > 0 &&
389 currency_symbol [0] == c){
390 if (s.Substring (sidx, currency_symbol_len) ==
391 currency_symbol){
392 sidx += currency_symbol_len-1;
393 state = State_Digits;
394 break;
395 }
396 }
397
398 if (Char.IsWhiteSpace (c))
399 goto case State_ConsumeWhiteSpace;
400
401 if (!tryParse)
402 exc = new FormatException ("Unknown char: " + c);
403 return false;
404
405 case State_Decimal:
406 if (Char.IsDigit (c)){
407 b [didx++] = (byte) c;
408 break;
409 }
410
411 if (c == 'e' || c == 'E'){
412 if ((style & NumberStyles.AllowExponent) == 0) {
413 if (!tryParse)
414 exc = new FormatException ("Unknown char: " + c);
415 return false;
416 }
417 b [didx++] = (byte) c;
418 state = State_ExponentSign;
419 break;
420 }
421
422 if (Char.IsWhiteSpace (c))
423 goto case State_ConsumeWhiteSpace;
424
425 if (!tryParse)
426 exc = new FormatException ("Unknown char: " + c);
427 return false;
428
429 case State_ExponentSign:
430 if (Char.IsDigit (c)){
431 state = State_Exponent;
432 goto case State_Exponent;
433 }
434
435 if (c == positive [0] &&
436 s.Substring (sidx, positive.Length) == positive){
437 state = State_Digits;
438 sidx += positive.Length-1;
439 continue;
440 }
441
442 if (c == negative [0] &&
443 s.Substring (sidx, negative.Length) == negative){
444 state = State_Digits;
445 b [didx++] = (byte) '-';
446 sidx += negative.Length-1;
447 continue;
448 }
449
450 if (Char.IsWhiteSpace (c))
451 goto case State_ConsumeWhiteSpace;
452
453 if (!tryParse)
454 exc = new FormatException ("Unknown char: " + c);
455 return false;
456
457 case State_Exponent:
458 if (Char.IsDigit (c)){
459 b [didx++] = (byte) c;
460 break;
461 }
462
463 if (Char.IsWhiteSpace (c))
464 goto case State_ConsumeWhiteSpace;
465
466 if (!tryParse)
467 exc = new FormatException ("Unknown char: " + c);
468 return false;
469
470 case State_ConsumeWhiteSpace:
471 if (allow_trailing_white && Char.IsWhiteSpace (c)) {
472 state = State_ConsumeWhiteSpace;
473 break;
474 }
475
476 if (!tryParse)
477 exc = new FormatException ("Unknown char");
478 return false;
479 }
480
481 if (state == State_Exit)
482 break;
483 }
484
485 b [didx] = 0;
486 unsafe {
487 fixed (byte *p = &b [0]){
488 double retVal;
489 if (!ParseImpl (p, out retVal)) {
490 if (!tryParse)
491 exc = Int32.GetFormatException ();
492 return false;
493 }
494 if (IsPositiveInfinity(retVal) || IsNegativeInfinity(retVal)) {
495 if (!tryParse)
496 exc = new OverflowException ();
497 return false;
498 }
499
500 result = retVal;
501 return true;
502 }
503 }
504 }
505
506 static bool TryParseStringConstant (string format, string s, int start, int end)
507 {
508 return end - start + 1 == format.Length && String.CompareOrdinal (format, 0, s, start, format.Length) == 0;
509 }
510
511 [MethodImplAttribute(MethodImplOptions.InternalCall)]
512 unsafe private static extern bool ParseImpl (byte *byte_ptr, out double value);
513
514 public static bool TryParse (string s,
515 NumberStyles style,
516 IFormatProvider provider,
517 out double result)
518 {
519 Exception exc;
520 if (!Parse (s, style, provider, true, out result, out exc)) {
521 result = 0;
522 return false;
523 }
524
525 return true;
526 }
527
528 public static bool TryParse (string s, out double result)
529 {
530 return TryParse (s, NumberStyles.Any, null, out result);
531 }
532
533 public override string ToString ()
534 {
535 return NumberFormatter.NumberToString (m_value, null);
536 }
537
538 public string ToString (IFormatProvider provider)
539 {
540 return NumberFormatter.NumberToString (m_value, provider);
541 }
542
543 public string ToString (string format)
544 {
545 return ToString (format, null);
546 }
547
548 public string ToString (string format, IFormatProvider provider)
549 {
550 return NumberFormatter.NumberToString (format, m_value, provider);
551 }
552
553 // =========== IConvertible Methods =========== //
554
555 public TypeCode GetTypeCode ()
556 {
557 return TypeCode.Double;
558 }
559
560 object IConvertible.ToType (Type targetType, IFormatProvider provider)
561 {
562 if (targetType == null)
563 throw new ArgumentNullException ("targetType");
564 return System.Convert.ToType (m_value, targetType, provider, false);
565 }
566
567 bool IConvertible.ToBoolean (IFormatProvider provider)
568 {
569 return System.Convert.ToBoolean (m_value);
570 }
571
572 byte IConvertible.ToByte (IFormatProvider provider)
573 {
574 return System.Convert.ToByte (m_value);
575 }
576
577 char IConvertible.ToChar (IFormatProvider provider)
578 {
579 throw new InvalidCastException ();
580 }
581
582 DateTime IConvertible.ToDateTime (IFormatProvider provider)
583 {
584 throw new InvalidCastException ();
585 }
586
587 decimal IConvertible.ToDecimal (IFormatProvider provider)
588 {
589 return System.Convert.ToDecimal (m_value);
590 }
591
592 double IConvertible.ToDouble (IFormatProvider provider)
593 {
594 return System.Convert.ToDouble (m_value);
595 }
596
597 short IConvertible.ToInt16 (IFormatProvider provider)
598 {
599 return System.Convert.ToInt16 (m_value);
600 }
601
602 int IConvertible.ToInt32 (IFormatProvider provider)
603 {
604 return System.Convert.ToInt32 (m_value);
605 }
606
607 long IConvertible.ToInt64 (IFormatProvider provider)
608 {
609 return System.Convert.ToInt64 (m_value);
610 }
611
612 sbyte IConvertible.ToSByte (IFormatProvider provider)
613 {
614 return System.Convert.ToSByte (m_value);
615 }
616
617 float IConvertible.ToSingle (IFormatProvider provider)
618 {
619 return System.Convert.ToSingle (m_value);
620 }
621
622 ushort IConvertible.ToUInt16 (IFormatProvider provider)
623 {
624 return System.Convert.ToUInt16 (m_value);
625 }
626 uint IConvertible.ToUInt32 (IFormatProvider provider)
627 {
628 return System.Convert.ToUInt32 (m_value);
629 }
630 ulong IConvertible.ToUInt64 (IFormatProvider provider)
631 {
632 return System.Convert.ToUInt64 (m_value);
633 }
634 }
635 }
git-svn mirror of mcs