Added to Favorites

Adler-32 is a checksum algorithm which was invented by Mark Adler. Compared to a cyclic redundancy check of the same length it trades reliability for speed. Compared to its original form (Fletcher-16), Adler-32 is more reliable than Fletcher-16. However, Adler-32 is slightly less reliable than Fletcher-32
## History

It is a modification of the Fletcher checksum.## The algorithm

An Adler-32 checksum is obtained by calculating two 16-bit checksums A and B and concatenating their bits into a 32-bit integer. A is the sum of all bytes in the string plus one, and B is the sum of the individual values of A from each step.## Example

The Adler-32 sum of the ASCII string "## Comparison with the Fletcher checksum

## Example implementation

An optimized implementation in the C programming language operates as follows:

The Adler-32 checksum is part of the widely-used zlib compression library, as both were developed by Mark Adler. A "rolling checksum" version of Adler-32 is used in the rsync utility.

At the beginning of an Adler-32 run, A is initialized to 1, B to 0. The sums are done modulo 65521 (the largest prime number smaller than 2^{16}). The bytes are stored in network order (big endian), B occupying the two most significant bytes.

The function may be expressed as

A = 1 + D_{1}+ D_{2}+ ... + D_{n}(mod 65521)

B = (1 + D_{1}) + (1 + D_{1}+ D_{2}) + ... + (1 + D_{1}+ D_{2}+ ... + D_{n}) (mod 65521)

= n×D_{1}+ (n-1)×D_{2}+ (n-2)×D_{3}+ ... + D_{n}+ n (mod 65521)

Adler-32(D) = B × 65536 + A

where D is the string of bytes for which the checksum is to be calculated, and n is the length of D.

`Wikipedia`

" would be calculated as follows:
ASCII code A B

(shown as base 10)

W: 87 1 + 87 = 88 0 + 88 = 88

i: 105 88 + 105 = 193 88 + 193 = 281

k: 107 193 + 107 = 300 281 + 300 = 581

i: 105 300 + 105 = 405 581 + 405 = 986

p: 112 405 + 112 = 517 986 + 517 = 1503

e: 101 517 + 101 = 618 1503 + 618 = 2121

d: 100 618 + 100 = 718 2121 + 718 = 2839

i: 105 718 + 105 = 823 2839 + 823 = 3662

a: 97 823 + 97 = 920 3662 + 920 = 4582

A = 920 = 398 hex (base 16)

B = 4582 = 11E6 hex

Output = 300286872 = 11E60398 hex

(The modulo operation had no effect in this example, since none of the values reached 65521).

The first difference between the two algorithms is that Adler-32 sums are calculated modulo a prime number, whereas Fletcher sums are calculated modulo 2^{4}-1, 2^{8}-1, or 2^{16}-1 (depending on the number of bits used), which are all composite numbers. Using a prime number makes it possible for Adler-32 to catch differences in certain combinations of bytes that Fletcher is unable to detect.

The second difference, which has the largest effect on the speed of the algorithm, is that the Adler sums are computed over 8-bit bytes rather than 16-bit words, resulting in twice the number of loop iterations. This results in the Adler-32 checksum taking between one-and-a-half to two times as long as Fletcher's checksum for 16-bit word aligned data. For byte-aligned data, Adler-32 is faster than properly implemented (e.g., one found in the Hierarchical_Data_Format) Fletcher's checksum.

Wikipedia, the free encyclopedia © 2001-2006 Wikipedia contributors (Disclaimer)

This article is licensed under the GNU Free Documentation License.

Last updated on Monday August 25, 2008 at 11:29:56 PDT (GMT -0700)

View this article at Wikipedia.org - Edit this article at Wikipedia.org - Donate to the Wikimedia Foundation

This article is licensed under the GNU Free Documentation License.

Last updated on Monday August 25, 2008 at 11:29:56 PDT (GMT -0700)

View this article at Wikipedia.org - Edit this article at Wikipedia.org - Donate to the Wikimedia Foundation

Copyright © 2015 Dictionary.com, LLC. All rights reserved.