Added XML standard in-code documentation, also GatsList and GatsDictionary

helpers.

1 files changed, 29 insertions, 4 deletions

diff --git a/cs-dotnet/src/gatsfloat.cs b/cs-dotnet/src/gatsfloat.cs
index 4709097..9763855 100644
--- a/cs-dotnet/src/gatsfloat.cs
+++ b/cs-dotnet/src/gatsfloat.cs
@@ -10,6 +10,31 @@ using System;
 
 namespace Com.Xagasoft.Gats
 {
+    /// <summary>
+    /// Encapsulates a single floating point value.
+    /// </summary>
+    /// <remarks>
+    /// The GATS floating point encoding is bit-exact with any standard
+    /// floating point encoding similar to the IEEE encoding.  This means that
+    /// unlike textual encoding you will always get the exact same floating
+    /// point value back that you encoded.  This format is arbitrary precision
+    /// and not dependant on platform or hardware.
+    ///
+    /// Although the format is arbitrary precision, the backend in C# uses a
+    /// double for maximum precision without resorting to a software arbitrary
+    /// precision library.
+    ///
+    /// Interestingly, unlike many other languages, C# provides a decimal type
+    /// that is also floating point, however the decimal type is encoded using
+    /// a bcd-like scheme.  This makes it an excellent choice for many human
+    /// activities, but it cannot be encoded precisely as a GatsFloat.  If you
+    /// would like to preserve the decimal nature of those types it may be
+    /// better to encode them as strings.
+    ///
+    /// In encoding, the GATS float uses two different type specifiers, an 'f'
+    /// indicates a normal floating point value.  An 'F' represents a special
+    /// value: positive or negative NaN, infinity, or zero.
+    /// </remarks>
     public class GatsFloat : GatsObject
     {
         private static readonly double Log256 = Math.Log( 256.0 );
@@ -41,10 +66,10 @@ namespace Com.Xagasoft.Gats
                 {
                     case 'N': Value = -Double.NaN;                                  break;
                     case 'n': Value = Double.NaN;                                       break;
-                    case 'I': Value = Double.NegativeInfinity;  break;
-                    case 'i': Value = Double.PositiveInfinity;  break;
-                    case 'Z': Value = -0.0;                             break;
-                    case 'z': Value = 0.0;                                      break;
+                    case 'I': Value = Double.NegativeInfinity;          break;
+                    case 'i': Value = Double.PositiveInfinity;          break;
+                    case 'Z': Value = -0.0;                                     break;
+                    case 'z': Value = 0.0;                                              break;
                 }
             }
             else if( type == 'f' )