Adler-32 checksum calculation, initially taken from here:
            http://www.java2s.com/Code/CSharp/Security/ComputesAdler32checksumforastreamofdata.htm
            
            
            
            ----- original description ------------------------------------------------------------------
            
            Computes Adler32 checksum for a stream of data. An Adler32
            checksum is not as reliable as a CRC32 checksum, but a lot faster to
            compute.
            
            The specification for Adler32 may be found in RFC 1950.
            ZLIB Compressed Data Format Specification version 3.3)
            
            
            From that document:
            
                 "ADLER32 (Adler-32 checksum)
                  This contains a checksum value of the uncompressed data
                  (excluding any dictionary data) computed according to Adler-32
                  algorithm. This algorithm is a 32-bit extension and improvement
                  of the Fletcher algorithm, used in the ITU-T X.224 / ISO 8073
                  standard.
            
                  Adler-32 is composed of two sums accumulated per byte: s1 is
                  the sum of all bytes, s2 is the sum of all s1 values. Both sums
                  are done modulo 65521. s1 is initialized to 1, s2 to zero.  The
                  Adler-32 checksum is stored as s2*65536 + s1 in most-
                  significant-byte first (network) order."
            
             "8.2. The Adler-32 algorithm
            
               The Adler-32 algorithm is much faster than the CRC32 algorithm yet
               still provides an extremely low probability of undetected errors.
            
               The modulo on unsigned long accumulators can be delayed for 5552
               bytes, so the modulo operation time is negligible.  If the bytes
               are a, b, c, the second sum is 3a + 2b + c + 3, and so is position
               and order sensitive, unlike the first sum, which is just a
               checksum.  That 65521 is prime is important to avoid a possible
               large class of two-byte errors that leave the check unchanged.
               (The Fletcher checksum uses 255, which is not prime and which also
               makes the Fletcher check insensitive to single byte changes 0 -
               255.)
            
               The sum s1 is initialized to 1 instead of zero to make the length
               of the sequence part of s2, so that the length does not have to be
               checked separately. (Any sequence of zeroes has a Fletcher
               checksum of zero.)"
            
 Inheritance Hierarchy
Inheritance HierarchySystemObject
  Ptv.XServer.Controls.Map.Tools.ReprojectionAdler32
 
    Namespace: 
   Ptv.XServer.Controls.Map.Tools.Reprojection
    Assembly:
   Ptv.XServer.Controls.Map (in Ptv.XServer.Controls.Map.dll) Version: 1.7.10.0
 Syntax
Syntaxpublic sealed class Adler32
Public NotInheritable Class Adler32
public ref class Adler32 sealed
[<SealedAttribute>]
type Adler32 =  class end
The Adler32 type exposes the following members.
 Constructors
Constructors|  | Name | Description | 
|---|
|  | Adler32 | 
            Creates a new instance of the Adler32 class.
            The checksum starts off with a value of 1.
             | 
Top Properties
Properties|  | Name | Description | 
|---|
|  | Value | 
            Returns the Adler32 data checksum computed so far.
             | 
Top Methods
Methods Extension Methods
Extension Methods|  | Name | Description | 
|---|
|  | ToJson |  Converts an object to a JSON string representation. (Defined by JSONWriter.) | 
Top See Also
See Also