Javascript and C++ Reed-Solomon FEC

Implementing Reed-Solomon error correction in your C++ application is extremely simple:

#include <ezpwd/rs>

// Reed Solomon w/ 255 (8-bit) symbols,
// up to 251 capacity ==> 4 parity
ezpwd::RS<255,251> rscodec;

std::vector<uint8_t> data;

// ... fill data with up to 251 bytes ...

// Add 4 Reed-Solomon parity symbols (255-251 == 4)
rscodec.encode( data );

// ... later, after data is possibly corrupted ...

// Correct errors, discard 4 parity symbols
int fixed = rscodec.decode( data );

Advanced APIs are available for dealing with erasures (missing data), corrected error positions, etc. Predefined codecs are available for symbol sizes from 2 to 16 bits (up to 64K blocks are supported). The Reed-Solomon tables are shared efficiently between all R-S codecs with compatible sizes and Galois field parameters, for excellent space efficiency.

Performance testing indicates thruput 25-75% faster than Phil Karn's excellent C implementation, and 25% faster than the renowned Schifra C++ implementation.

We have made Ivan Djelic's wonderful Linux Kernel implementation of BCH codes (or Bose–Chaudhuri–Hocquenghem codes) quickly and easily usable in C/C++ code. It is licensed under GPLv2+.

Creating a BCH codec w/ precisely the desired codeword size, payload and bit-error correction capacity (constructor throws exception if no match BCH codec is available):

#include <ezpwd/bch>
// By Codeword, Payload and Correction capacities, exactly
ezpwd::BCH<255,239,2> bch_codec;

Encoding into a container of uint8_t:

std::vector<uint8_t> codeword = {  // 8 data
    0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF
};
bch_codec.encode( codeword );  // + 2 parity added

Decoding (and correcting errors)

int corrections = bch_codec.decode( codeword );
assert( corrections >= 0 ); // fail on bad BCH
codeword.resize(            // discard parity
    codeword.size() - bch_codec.ecc_bytes() );

Generating and redeeming binary data codes on websites (Coupons, Product Keys, etc.) is a disaster.

It is inappropriate to expect a user to transcribe a complex coupon code or product key without error. In fact, it is somewhat insulting. When your user (inevitably) gets a couple of characters wrong, they are forced to manually find the error, and re-enter the code.

Instead, just enable Reed-Solomon error correction on the code. A few wrong symbols entered? No problem – they automatically get corrected.

Much happier clients == more revenue for your web store!

Generate a code with built-in Reed-Solomon error correction using the rskey.js APIs. For example, encrypt 64 bits of your Customer ID and card ID and generate an RSKEY like:

P5X1-TPW8-5NFP-2M7G

and print or email this for your client.

Later, when the client re-enters the code (with error 'W'->'v'), you might get back something like:

psx1 tpv8 snfp zm7g

No problem. The transcriptions errors are corrected (whitespace and dashes are ignored), and your encrypted card ID data is recovered. A quick request back to your server decrypts the customer and card IDs, and you can present the discount!

Since all of the RSKEY decoding occurs in your client's browser, you can easily display that the coupon code is valid in real-time – even showing the auto-correction, if you wish. All decryption occurs safely and securely on your server, so no encryption keys are ever transmitted to the browser.

Communicating important accurate geolocation information (such as where my daughter Amarissa was born) is very difficult. Making a mistake in one digit of a location such as:

53.655832,-113.625433

can result in anywhere from centimeters to thousands of kilometers of error.

Instead, use EZCOD to encode this information to within +/- 3m accuracy in just 10 symbols, anywhere on the planet – with error detection and erasure correction:

R3U 1JU QUY.0

If you require more accuracy and reliability, select an EZCOD with up to 12 symbols of position accuracy, and 3 symbols of Reed-Solomon parity. This gives you a position accurate within 20mm, and guarantees reliability with a probability of .99997, in just 15 symbols:

R3U 1JU QUY L02.XJ8

Try corrupting a symbol, or replace 1 or 2 symbols with _ to indicate an erasure, or missing symbol. The 10-symbol variant can support up to one erased symbol, and the 15-symbol version w/ 3 parity symbols can recover from one error or up to 3 erased symbols!

Get more details here about EZCOD and how it compares with all the other geo-location encoding schemes. Here is an example of how to use it in your Javascript application (see source code for C++ and Python API details):

<script src="//cdn.rawgit.com/pjkundert/ezpwd-reed-solomon/v1.8.0/js/ezpwd/ezcod.js"></script>
<script type="text/javascript">

var ezcod = ezcod_3_12_encode( 53.655832, -113.625433, 12 );
// R3U 1JU QUY L02.XJ8

// ... later ... 1 error ('Y'->'v'):

var pos = ezcod_3_12_decode( "r3u 1ju quv lo2.xj8" );
// {confidence: 34,
// latitude: 53.65583198145032,
// longitude: -113.62543302588165,
// accuracy: 0.019441640257668036}
</script>

Use EZCOD for free. Forever. For whatever application you want.

These fees are denominated in USD$ at the time of request, payable in various cryptocurrencies:

The Cryptocurrencies supported for payment (others available on request) are:

Any Crypto/USD$ exchange rate available to the public on major exchanges within 24 hours of purchase is acceptable.

For Fiat payments (Wire Transfer, Credit card, etc.), an additional fee of one year of support is payable, due to the vastly increased risk and expense of dealing in traditional currencies.