├── .gitignore
├── .gitmodules
├── .travis.yml
├── COPYING
├── COPYRIGHT
├── GNUmakefile
├── LICENSE
├── README.org
├── README.pdf
├── VERSION
├── bch_itron.C
├── bch_itron.kelowna.txt
├── bch_itron.txt
├── bch_test.C
├── bchclassic.C
├── bchsimple.C
├── c++
    └── ezpwd
    │   ├── asserter
    │   ├── bch
    │   ├── bch_base
    │   ├── bch_errnums
    │       └── linux
    │       │   └── errno.h
    │   ├── bch_include
    │   ├── corrector
    │   ├── cut
    │   ├── definitions
    │   ├── ezcod
    │   ├── output
    │   ├── pid
    │   ├── rs
    │   ├── rs_base
    │   ├── rs_definitions
    │   ├── serialize
    │   ├── serialize_definitions
    │   ├── timeofday
    │   └── units
├── cut-test.C
├── cutone.C
├── default.nix
├── djelic_bch.c
├── djelic_bch.h
├── documentation
    ├── BCH_code.pdf
    ├── bch4836.c
    └── cyclic99.pdf
├── examples
    ├── ezcod_api
    │   ├── server.py
    │   └── static
    │   │   ├── css
    │   │       └── app.css
    │   │   ├── ezcod.png
    │   │   ├── icons
    │   │       ├── android-icon-144x144.png
    │   │       ├── android-icon-192x192.png
    │   │       ├── android-icon-36x36.png
    │   │       ├── android-icon-48x48.png
    │   │       ├── android-icon-72x72.png
    │   │       ├── android-icon-96x96.png
    │   │       ├── apple-icon-114x114.png
    │   │       ├── apple-icon-120x120.png
    │   │       ├── apple-icon-144x144.png
    │   │       ├── apple-icon-152x152.png
    │   │       ├── apple-icon-180x180.png
    │   │       ├── apple-icon-57x57.png
    │   │       ├── apple-icon-60x60.png
    │   │       ├── apple-icon-72x72.png
    │   │       ├── apple-icon-76x76.png
    │   │       ├── apple-icon-precomposed.png
    │   │       ├── apple-icon.png
    │   │       ├── browserconfig.xml
    │   │       ├── favicon-16x16.png
    │   │       ├── favicon-32x32.png
    │   │       ├── favicon-96x96.png
    │   │       ├── favicon.ico
    │   │       ├── manifest.json
    │   │       ├── ms-icon-144x144.png
    │   │       ├── ms-icon-150x150.png
    │   │       ├── ms-icon-310x310.png
    │   │       └── ms-icon-70x70.png
    │   │   ├── js
    │   │       └── app.js
    │   │   └── templates
    │   │       ├── keylist.html
    │   │       ├── layout.html
    │   │       └── map.html
    └── rskey.html
├── exercise.H
├── ezcod.C
├── ezcod.h
├── ezcod_test.C
├── ezcod_wrap.js
├── nixpkgs.nix
├── phil-karn
    ├── .gitignore
    ├── GNUmakefile
    ├── README
    ├── cpu_features.c
    ├── exercise.c
    ├── fec-3.0.1-int.patch
    ├── fec-3.0.1.tar.bz2
    ├── fec-3.0.1.tar.gz
    ├── pad_rs.c
    ├── rs.3
    ├── rs.h
    └── rstest.c
├── pid-test.C
├── qi_test_1.C
├── qi_test_1_bad.txt
├── qi_test_1_good.txt
├── qi_test_2.C
├── rscompare.C
├── rsembedded.C
├── rsencode.C
├── rsexample.C
├── rsexercise.C
├── rskey.C
├── rskey.h
├── rskey_node.js
├── rskey_test.C
├── rskey_wrap.js
├── rspwd.C
├── rspwd.h
├── rspwd_test.C
├── rspwd_wrap.js
├── rssimple.C
├── rsspeed.C
├── rsvalidate.C
├── shell.nix
├── swig
    └── python
    │   ├── .gitignore
    │   ├── BCH
    │       ├── BCH.i
    │       ├── GNUmakefile
    │       ├── __init__.py
    │       └── runme.py
    │   ├── BCH_test.py
    │   ├── GNUmakefile
    │   ├── MANIFEST.in
    │   ├── __init__.py
    │   ├── ezcod
    │       ├── GNUmakefile
    │       ├── __init__.py
    │       ├── ezcod.i
    │       └── runme.py
    │   ├── requirements.txt
    │   ├── setup.py
    │   ├── std_map
    │       ├── GNUmakefile
    │       ├── example.h
    │       ├── example.i
    │       └── runme.py
    │   └── version.py
└── units-test.C


/.gitignore:
--------------------------------------------------------------------------------
 1 | *~
 2 | *.o
 3 | /*.js.map
 4 | /*.js.mem
 5 | /README.tex
 6 | /auto
 7 | /emscripten/*
 8 | /ezcod
 9 | /ezcod_test
10 | /ezcod_test.js
11 | /phil-karn/ccsds_tab.c
12 | /phil-karn/ccsds_tal.c
13 | /phil-karn/fec
14 | /phil-karn/fec-3.0.1/
15 | /phil-karn/gen_ccsds
16 | /phil-karn/gen_ccsds_tal
17 | /phil-karn/librs.a
18 | /rscompare
19 | /rsexample
20 | /rsexample.js
21 | /rsexercise
22 | /rsexercise.js
23 | /rskey_test
24 | /rskey_test.js
25 | /rspwd_test
26 | /rspwd_test.js
27 | /rssimple
28 | /rssimple.js
29 | /rsspeed
30 | /rsvalidate
31 | rscompare_nexc
32 | rsembedded
33 | rsembedded.js
34 | rsembedded_nexc
35 | rsencode
36 | rsencode_9
37 | rsencode_16
38 | bch_test
39 | bch_itron
40 | qi_test_1
41 | qi_test_2
42 | bchsimple
43 | bchclassic
44 | swig/python/ezcod/ezcod.py
45 | swig/python/ezcod/ezcod_wrap.cpp
46 | swig/python/BCH/BCH.py
47 | swig/python/BCH/BCH_wrap.cpp
48 | c++/ezpwd/ezpwd
49 | libezpwd-*
50 | /result
51 | pid-test
52 | units-test
53 | cut-test
54 | cutone


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
 1 | [submodule "emsdk"]
 2 | 	path = emsdk
 3 | 	url = https://github.com/emscripten-core/emsdk.git
 4 | [submodule "schifra"]
 5 | 	path = schifra
 6 | 	url = https://github.com/ArashPartow/schifra.git
 7 | [submodule "djelic"]
 8 | 	path = djelic
 9 | 	url = https://github.com/pjkundert/bch.git
10 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | sudo: false
 2 | dist: trusty
 3 | language: cpp
 4 | 
 5 | perl:
 6 |   - 5.18
 7 | 
 8 | matrix:
 9 |   include:
10 |     - compiler: gcc
11 |       addons:
12 |         apt:
13 |           sources:
14 |             - ubuntu-toolchain-r-test
15 |           packages:
16 |             - g++-4.9
17 |       env:
18 |         - CXX_COMPILER=g++-4.9
19 |         - CC_COMPILER=gcc-4.9
20 |     - compiler: gcc
21 |       addons:
22 |         apt:
23 |           sources:
24 |             - ubuntu-toolchain-r-test
25 |           packages:
26 |             - g++-5
27 |       env:
28 |         CXX_COMPILER=g++-5
29 |         CC_COMPILER=gcc-5
30 |     - compiler: gcc
31 |       addons:
32 |         apt:
33 |           sources:
34 |             - ubuntu-toolchain-r-test
35 |           packages:
36 |             - g++-6
37 |       env:
38 |         CXX_COMPILER=g++-6
39 |         CC_COMPILER=gcc-6
40 |     - compiler: gcc
41 |       addons:
42 |         apt:
43 |           sources:
44 |             - ubuntu-toolchain-r-test
45 |           packages:
46 |             - g++-7
47 |       env:
48 |         CXX_COMPILER=g++-7
49 |         CC_COMPILER=gcc-7
50 |     - compiler: gcc
51 |       addons:
52 |         apt:
53 |           sources:
54 |             - ubuntu-toolchain-r-test
55 |           packages:
56 |             - g++-8
57 |       env:
58 |         CXX_COMPILER=g++-8
59 |         CC_COMPILER=gcc-8
60 |     - compiler: clang
61 |       addons:
62 |         apt:
63 |           sources:
64 |             - llvm-toolchain-trusty-3.9
65 |           packages:
66 |             - clang-3.9
67 |       env:
68 |         CXX_COMPILER=clang++-3.9
69 |         CC_COMPILER=clang-3.9
70 |     - compiler: clang
71 |       addons:
72 |         apt:
73 |           sources:
74 |             - llvm-toolchain-trusty-4.0
75 |           packages:
76 |             - clang-4.0
77 |       env:
78 |         CXX_COMPILER=clang++-4.0
79 |         CC_COMPILER=clang-4.0
80 |     - compiler: clang
81 |       addons:
82 |         apt:
83 |           sources:
84 |             - llvm-toolchain-trusty-5.0
85 |           packages:
86 |             - clang-5.0
87 |       env:
88 |         CXX_COMPILER=clang++-5.0
89 |         CC_COMPILER=clang-5.0
90 | 
91 | script: 
92 |   - $CXX_COMPILER --version
93 |   - $CC_COMPILER --version
94 |   - make CXX=$CXX_COMPILER CC=$CC_COMPILER testex
95 | 


--------------------------------------------------------------------------------
/COPYRIGHT:
--------------------------------------------------------------------------------
1 | /*! v2.0.0 | (c) 2014-2020 Dominion Research & Development Corp. | https://github.com/pjkundert/ezpwd-reed-solomon/blob/master/LICENSE */
2 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Ezpwd Reed-Solomon is distributed under the GNU General Public License version 3
 2 | and is also available under alternative Commercial licenses negotiated directly
 3 | with Hard Consulting Corporation. If you obtained Ezpwd Reed-Solomon under the
 4 | GPL, then the GPL applies to all Ezpwd Reed-Solomon modules used on your system
 5 | as well, except as defined below. The GPL (version 3) is included in this source
 6 | tree in the file COPYING.
 7 | 
 8 | The c++/ezpwd/rs file is redistributed under the terms of the LGPL, regardless
 9 | of the overall licensing terms; see the file for more details, or visit:
10 | 
11 |     https://github.com/pjkundert/ezpwd-reed-solomon/blob/master/c++/ezpwd/rs
12 | 
13 | Hard Consulting Corporation holds copyright and/or sufficient licenses to all
14 | components of the Ezpwd Reed-Solomon package, and therefore can grant, at its
15 | sole discretion, the ability for companies, individuals, or organizations to
16 | create proprietary or Open Source (even if not GPL) modules which may use at
17 | runtime the portions of Ezpwd Reed-Solomon which fall under the umbrella of our
18 | copyright/license, or are distributed under more flexible licenses than GPL.
19 | 
20 | If you wish to use our code in other GPL programs, don't worry -- there is no
21 | requirement that you provide the same exception in your GPL'd products (although
22 | if you've written a module for Ezpwd Reed-Solomon we would strongly encourage
23 | you to make the same exception that we do).
24 | 
25 | In addition, Ezpwd Reed-Solomon implements many tools and APIs using its
26 | Reed-Solomon implementation.  It is our belief that applications using these
27 | tools and APIs do not have to be licensed under the GPL or a compatible license,
28 | as we believe that the use of these tools and APIs do not create a 'derivative
29 | work' as referred to in the GPL.  However, should any court or other judiciary
30 | body find that these tools and APIs do fall under the terms of the GPL, then we
31 | hereby grant you a license to use these protocols in combination with Ezpwd
32 | Reed-Solomon in external applications licensed under any license you wish.
33 | 
34 | If you have any questions regarding our licensing policy, please contact us:
35 | 
36 | +1.780.970.8148
37 | info@hardconsulting.com
38 | 
39 | Hard Consulting Corporation
40 | 74 Greystone Crescent
41 | Spruce Grove, AB, T7X 0A7
42 | Canada
43 | 


--------------------------------------------------------------------------------
/README.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/README.pdf


--------------------------------------------------------------------------------
/VERSION:
--------------------------------------------------------------------------------
1 | 2.2.0
2 | 


--------------------------------------------------------------------------------
/bch_test.C:
--------------------------------------------------------------------------------
  1 | 
  2 | /*
  3 |  * bch_test	-- Iterate all available BCH codecs, comparing their speeds
  4 |  */
  5 | 
  6 | #include <vector>
  7 | #include <map>
  8 | #include <set>
  9 | #include <iostream>
 10 | #include <random>
 11 | 
 12 | #include <ezpwd/asserter>
 13 | 
 14 | // Djelic GPLv2+ BCH "C" API implementation from Linux kernel.  Requires "standalone" shims for
 15 | // user-space to build lib/bch.c implementation; API matches kernel.
 16 | #include <ezpwd/bch>
 17 | 
 18 | 
 19 | //
 20 | // compare< N> -- compare BCH implementations for N-bit codewords
 21 | // 
 22 | //     Allocates all BCH codecs for N-bit (eg. 31, ..., 511) codewords, supporting
 23 | // various bit-error correction capacities T.
 24 | // 
 25 | //     Computes the Galois order M, which fits the desired codeword size N, in bits.  Then, iterates
 26 | // over increasing desired bit correction capacities, until failure.  Logs the standard BCH
 27 | // specification, in bits: BCH( N, N-ECC, T ), where N == total codeword size, N-ECC == payload
 28 | // size, T == correction capacity.
 29 | // 
 30 | template <size_t N>
 31 | double 				compare(
 32 | 				    ezpwd::asserter    &assert )
 33 | {
 34 |     
 35 |     // ezpwd::log_<N,B> -- compute the log base B of N at compile-time
 36 |     // Compute the minimum M required for codeword size N (rounding up to next higher M).
 37 |     size_t			M( ezpwd::log_< N + 1 >::value );
 38 |     struct ezpwd::bch_control  *bch;
 39 |     size_t			T	= 0;
 40 |     while ( !! ( bch = ezpwd::init_bch( M, ++T, 0 ))) {
 41 | 	// We've obtained a valid BCH control structure for the target BCH M and T.  Present
 42 | 	// in standard BCH ( <SYMBOLS>, <PAYLOAD>, <CAPACITY> ) terms
 43 | 	std::cout << *bch // (see c++/ezpwd/bch_base for formatter)
 44 | 		  << "; ECC = "	<< std::setw( 3 ) << bch->ecc_bits
 45 | 		  << " / "	<< std::setw( 3 ) << bch->ecc_bytes
 46 | 		  << std::endl;
 47 | 	ezpwd::free_bch( bch );
 48 |     }
 49 |     (void)assert; // no tests, yet.
 50 |     return 0.0;
 51 | }
 52 | 
 53 | std::minstd_rand		randomizer;
 54 | std::uniform_int_distribution<uint8_t>
 55 | 				random_byte( 0, 255 );
 56 | 
 57 | int main()
 58 | {
 59 |     ezpwd::asserter		assert;
 60 |     double			avg	= 0;
 61 |     int				cnt	= 0;
 62 |     std::cout << "BCH Codecs Available (in bits)" << std::endl;
 63 |     std::cout << "  size of" << std::endl;
 64 |     std::cout << "  codeword" << std::endl;
 65 |     std::cout << "       |  data" << std::endl;
 66 |     std::cout << "       |  payload" << std::endl;
 67 |     std::cout << "       |    |    bit error" << std::endl;
 68 |     std::cout << "       |    |    capacity" << std::endl;
 69 |     std::cout << "       |    |    |           parity" << std::endl;
 70 |     std::cout << "       |    |    |           bits  bytes" << std::endl;
 71 |     std::cout << "       |    |    |            |     |" << std::endl;
 72 |     avg				       += compare<  31>( assert );	++cnt;
 73 |     avg				       += compare<  63>( assert );	++cnt;
 74 |     avg				       += compare< 127>( assert );	++cnt;
 75 |     avg				       += compare< 255>( assert );	++cnt;
 76 |     avg				       += compare< 511>( assert );	++cnt;
 77 | 
 78 |     std::cout << std::endl << "BCH(...) EZPWD vs. Djelic's: " << avg/cnt << "% faster (avg.)" << std::endl;
 79 | 
 80 | 
 81 |     // Evaluate the following BCH codec, to determine its effectiveness at detecting random bit
 82 |     // errors.
 83 |     constexpr size_t		sym	= 255;
 84 |     constexpr size_t		pay	= 239;		// max. net payload
 85 |     constexpr size_t		par	= sym - pay;
 86 |     constexpr size_t		cap	= 2;
 87 |  // constexpr size_t		paymin	= cap * 2;
 88 | 
 89 |     // Due to there being no way (presently) to specify a number of payload bits
 90 |     // that is a fraction of the (bit-packed) container supplied, there is no way to
 91 |     // use the ezpwd::bch API to supply the full 239-bit payload; the next lower
 92 |     // multiple of an 8-bit byte (232) is the maximum possible.
 93 |     std::vector<size_t>		len	{
 94 | 	8, 16, 32, 50, 64, 80, 100, 128, 200, 232, pay
 95 |     };
 96 |     size_t			run	= 1000000;
 97 |     ezpwd::BCH<sym,pay,cap>	bch;
 98 | 
 99 |     std::cout
100 | 	<< std::setw( 8 * ( bch.t() * 2 + 2 )) << std::left << "Corrections"
101 | 	<< " | " << std::right << "Description"
102 | 	<< std::endl;
103 |     
104 |     for ( int i = -1; i <= int( bch.t() ) * 2; ++i )
105 | 	std::cout
106 | 	    << std::setw( 8 ) << i;
107 |     std::cout
108 | 	<< " | "
109 | 	<< std::endl
110 | 	<< std::string( 8 * ( bch.t() * 2 + 2 ), '-' )
111 | 	<< " | "
112 | 	<< std::endl;
113 |     for ( size_t l : len ) {
114 | 	std::vector<uint8_t>	payload( ( l + 7 ) / 8 );
115 | 	for ( uint8_t &v : payload )
116 | 	    v				= random_byte( randomizer );
117 | 	std::uniform_int_distribution<size_t>
118 | 			random_msgbit( 0, par + l - 1 );	// [0,parity + payload)
119 | 	int		e_max	= std::min( l, bch.t() * 4 );
120 | 	for ( int e			= 0
121 | 		  ; e <= e_max + 1
122 | 		  ; ++e ) { // > e_max --> random date
123 | 	    std::map<int,size_t> errfix;			// bit errors fixed:  [-1,paymin] --> <count>
124 | 	    for ( size_t test = 0; test < run; ++test ) {
125 | 		// For each test, change a byte and re-generate parity.  We want to get a valid
126 | 		// distribution of error correction capacity; not the capacity of any specific
127 | 		// codeword.  Always execute on test == 0!
128 | 		payload[test % payload.size()]
129 | 		    			= random_byte( randomizer );
130 | 		std::vector<uint8_t>
131 | 		    		parity( ( par + 7 ) / 8 );
132 | 		for ( uint8_t &v : parity )
133 | 		    v			= random_byte( randomizer );
134 | 
135 | 		// Test for correction of all random data.  May change parity!
136 | 		std::vector<uint8_t>
137 | 		    		errload( payload );
138 | 
139 | 		int		fixed	= -1;
140 | 		if ( e <= e_max ) {
141 | 		    // Test for correction of 'e' bit errors; fills in parity with BCH ECC data
142 | 		    bch.encode( payload, parity );
143 | 		    std::set<int> used;
144 | 		    for ( int en = 0; en < e; ++en ) {
145 | 			while ( true ) {
146 | 			    size_t eb = random_msgbit( randomizer );
147 | 			    if ( used.find( eb ) != used.end() )
148 | 				continue;
149 | 			    used.insert( eb );
150 | 			    if ( eb < l ) {
151 | 				// Payload corruption
152 | 				errload[eb/8]  ^= uint8_t( 1 ) << ( eb % 8 );
153 | 			    } else {
154 | 				// Parity corruption
155 | 				parity[(eb-l)/8] ^= uint8_t( 1 ) << ( (eb-l) % 8 );
156 | 			    }
157 | 			    break;
158 | 			}
159 | 		    }
160 | 		}
161 | 
162 | 		try { fixed		= bch.decode( errload, parity ); } catch ( ... ) { fixed = -1; }
163 | 		++errfix[fixed >= 0 ? fixed : -1];
164 | 	    }
165 | 	    for ( int i = -1; i <= int( bch.t() * 2 ); ++i )
166 | 		std::cout
167 | 		    << std::setw( 8 ) << errfix[i];
168 | 
169 | 	    std::cout
170 | 		<< " | BCH("		<< std::setw( 3 ) << sym
171 | 		<< ","			<< std::setw( 3 ) << pay
172 | 		<< ","			<< std::setw( 3 ) << cap
173 | 		<< ") w/ "		<< std::setw( 3 ) << l
174 | 		<< " payload, ";
175 | 	    if ( e > e_max )
176 | 		std::cout
177 | 		    << "random data/parity"
178 | 		    << std::endl
179 | 		    << std::endl;
180 | 	    else
181 | 		std::cout
182 | 		    << e << " bit errors"
183 | 		    << std::endl;
184 | 	}
185 |     }
186 |     
187 |     return assert.failures ? 1 : 0;
188 | }
189 | 


--------------------------------------------------------------------------------
/bchclassic.C:
--------------------------------------------------------------------------------
1 | #define EZPWD_BCH_CLASSIC
2 | #include "bchsimple.C"
3 | 


--------------------------------------------------------------------------------
/bchsimple.C:
--------------------------------------------------------------------------------
  1 | 
  2 | #include <array>
  3 | #include <vector>
  4 | #include <iostream>
  5 | #include <random>
  6 | 
  7 | #include <ezpwd/asserter>
  8 | #include <ezpwd/output>
  9 | #include <ezpwd/bch>
 10 | 
 11 | std::minstd_rand		randomizer;
 12 | std::uniform_int_distribution<unsigned int>
 13 | 				random_80( 0, 79 );
 14 | 
 15 | #define EZPWD_BCH_FIXED
 16 | 
 17 | int main()
 18 | {
 19 |     // Allocate a BCH codec Galois order 8 (w/ 2^8-1 == 255 bit codeword size), and 2 bits of
 20 |     // correction capacity.  This results in a BCH( 255, 239, 2) codec: 255-bit codeword, 239-bit
 21 |     // data payload capacity, hence 255-239 == 16 bits of parity.  Define EZPWD_BCH_CLASSIC to use
 22 |     // classic Djelic Linux Kernel API.  Otherwise, uses <ezpwd/bch> 'bch<..>' or 'BCH<...>' classes.
 23 |     ezpwd::asserter		assert;
 24 |     try {
 25 | #if defined( EZPWD_BCH_CLASSIC )
 26 |         ezpwd::bch_control                 *bch     = ezpwd::init_bch( 8, 2, 0 );
 27 |         if ( ! bch )
 28 |     	throw std::logic_error( "Failed to allocate valid BCH codec" );
 29 |         ezpwd::bch_control                 &bch_codec( *bch );	// By Galois order, Correction capacity
 30 | #else
 31 |         //ezpwd::bch_base		bch_codec( 8, 2 );	// By Galois order, Correction capacity, flexibly
 32 |         ezpwd::BCH<255,239,2>		bch_codec;	// By Codeword, Payload and Correction capacities, exactly
 33 | #endif
 34 | 
 35 | #if defined( EZPWD_BCH_FIXED )
 36 |         typedef std::array<uint8_t,10>	codeword_t;		// Fixed (parity initialized to 0)
 37 | #else
 38 |         typedef std::vector<uint8_t>	codeword_t;		// Variable (parity added by encode)
 39 | #endif
 40 | 
 41 | 	codeword_t				codeword= {
 42 | 	    0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF	// 8 data
 43 | 	};							// 2 ECC parity
 44 | 
 45 | #if defined( EZPWD_BCH_CLASSIC )
 46 | 	// A BCH codeword's ECC must be zero-initialized for classic Djelic API, and
 47 | 	// must be added to variable containers
 48 | #  if ! defined( EZPWD_BCH_FIXED )
 49 | 	codeword.resize( 10 );
 50 | #  endif
 51 | 	codeword[8] 				= 0;
 52 | 	codeword[9] 				= 0;
 53 | 	ezpwd::encode_bch( &bch_codec, &codeword[0], 8, &codeword[8] );
 54 | #else
 55 | 	// A codeword in a fixed container will not be resized by API; assumes ECC on end. Will
 56 | 	// initialize to 0.  A variable container will have parity appended by the API.
 57 | 	bch_codec.encode( codeword );
 58 | #endif
 59 | 
 60 | 	// Place random errors in the codeword and correct, up to the capacity of the BCH codec.
 61 | 	for ( size_t t = 0; t < 5; ++t ) {
 62 | 	    for ( size_t e = 0
 63 | #if defined( EZPWD_BCH_CLASSIC )
 64 | 		      ; e < bch_codec.t
 65 | #else
 66 | 		      ; e < bch_codec.t()
 67 | #endif
 68 | 		      ; ++e ) {
 69 | 		codeword_t		corrupted( codeword );
 70 | 		// Randomly corrupt from 0 to bch->t bits
 71 | 		for ( size_t be = 0; be < e; ++be ) {
 72 | 		    unsigned int	bl	= random_80( randomizer );
 73 | 		    corrupted[bl/8]	       ^= uint8_t( 1 ) << ( bl % 8 );
 74 | 		}
 75 | 		codeword_t		corrected( corrupted );
 76 | #if defined( EZPWD_BCH_CLASSIC )
 77 | 		int corrections			= ezpwd::correct_bch( &bch_codec, &corrected[0], 8, &corrected[8] );
 78 | #else
 79 | 		int corrections			= bch_codec.decode( corrected );
 80 | #endif
 81 | 
 82 | 		if ( assert.ISEQUAL( corrections, int( e ),
 83 | 				     std::string( "Failed decode of " ) << bch_codec
 84 | 				     << " codeword w/ " << e << " bit errrors"
 85 | 				     )) {
 86 | 		    std::cout << assert << std::endl;
 87 | 		    continue;
 88 | 		}
 89 | 
 90 | 		// Success; If differences were found, they better be in the parity data!
 91 | 		for ( size_t i = 0; i < 8; ++i )
 92 | 		    if ( assert.ISEQUAL( corrected[i], codeword[i], 
 93 | 					 std::string( "Failed recovery of " ) << bch_codec
 94 | 					 << " codeword w/ " << e << " bit errors" ))
 95 | 			std::cout << assert << std::endl;
 96 | 	    }
 97 | #if ! defined( EZPWD_BCH_CLASSIC )
 98 | 	    // Try the inline versions (only available in C++ API)
 99 | 	    std::string			raw( "abc" );
100 | 	    std::string			enc	= bch_codec.encoded( raw );
101 | 	    std::string			err	= enc;
102 | 	    err[0]			       ^= 0x40;
103 | 	    err[2]			       ^= 0x08;
104 | 	    std::string			dec	= bch_codec.decoded( err );
105 | 	    if ( assert.ISEQUAL( dec.substr( 0, 3 ), raw,
106 | 				 std::string( "decoded/encoded of " )	<< bch_codec
107 | 				 << " codeword failed, encoded '0x"	<< ezpwd::hexstr( raw )
108 | 				 << "' to '0x"				<< ezpwd::hexstr( enc )
109 | 				 << "', decoded '0x"			<< ezpwd::hexstr( err )
110 | 				 << "' to '0x"				<< ezpwd::hexstr( dec )
111 | 				 << "'" ))
112 | 		std::cout << assert << std::endl;
113 | #endif
114 | 	}
115 | 	std::cout
116 | 	    << bch_codec << ": ";
117 |     } catch( std::exception &exc ) {
118 | 	assert.FAILURE( "Exception", exc.what() );
119 | 	std::cout << assert << std::endl;
120 |     }
121 | 
122 |     if ( assert.failures )
123 | 	std::cout
124 | 	    << assert.failures << " tests failed." << std::endl;
125 |     else
126 | 	std::cout
127 | 	    << "All tests passed." << std::endl;
128 |     return assert.failures ? 1 : 0;
129 | }
130 | 


--------------------------------------------------------------------------------
/c++/ezpwd/asserter:
--------------------------------------------------------------------------------
  1 | #ifndef _EZPWD_ASSERTER
  2 | #define _EZPWD_ASSERTER
  3 | 
  4 | #include <algorithm>
  5 | #include <cstring>
  6 | #include <iostream>
  7 | #include <iomanip>
  8 | #include <sstream>
  9 | 
 10 | namespace ezpwd {
 11 | 
 12 | #define ISEQUAL( ... )	isequal(__FILE__, __LINE__, __VA_ARGS__ )
 13 | #define ISTRUE( ... )	istrue(	__FILE__, __LINE__, __VA_ARGS__ )
 14 | #define ISFALSE( ... )	isfalse(__FILE__, __LINE__, __VA_ARGS__ )
 15 | #define ISNEAR( ... )	isnear(	__FILE__, __LINE__, __VA_ARGS__ )
 16 | #define FAILURE( ... )	failure(__FILE__, __LINE__, __VA_ARGS__ )
 17 | 
 18 |     struct asserter {
 19 | 	bool			failed;		// The last test failed
 20 | 	int			failures;	// Total number of failures
 21 | 	std::string		out;		// Last failure
 22 | 
 23 | 				asserter()
 24 | 				    : failed( false )
 25 | 				    , failures( 0 )
 26 | 				    , out()
 27 | 	{
 28 | 	    ;
 29 | 	}
 30 | 
 31 | 	// 
 32 | 	// output( <std::ostream> )		-- Output description of last failed test (or nothing if successful)
 33 | 	// <std::ostream> << <asserter>
 34 | 	// 
 35 | 	std::ostream  	       &output(
 36 | 				    std::ostream       &lhs )
 37 | 	    const
 38 | 	{
 39 | 	    return lhs << out;
 40 | 	}
 41 | 
 42 | 	// 
 43 | 	// (bool) <asserter> -- Return status of last test
 44 | 	//
 45 |     				operator bool()
 46 | 	{
 47 | 	    return failed;
 48 | 	}
 49 | 	
 50 | 	template < typename T >
 51 | 	asserter	       &istrue(  const char *file, int line, const T &a, const std::string &comment = std::string() )
 52 | 	{
 53 | 	    return isequal( file, line, !!a, true, comment );
 54 | 	}
 55 | 
 56 | 	template < typename T >
 57 | 	asserter	       &isfalse(  const char *file, int line, const T &a, const std::string &comment = std::string() )
 58 | 	{
 59 | 	    return isequal( file, line, !!a, false, comment );
 60 | 	}
 61 | 
 62 | 	template < typename T >
 63 | 	asserter	       &isequal( const char *file, int line, const T &a, const T &b, const std::string &comment = std::string() )
 64 | 	{
 65 | 	    if ( ! ( a == b )) {
 66 | 		std::ostringstream oss;
 67 | 		oss << a << " != " << b;
 68 | 		return failure( file, line, oss.str(), comment );
 69 | 	    }
 70 | 	    return success();
 71 | 	}
 72 | 
 73 | 	template < typename T >
 74 | 	asserter	       &isnear( const char *file, int line, const T &a, const T &b, const T &delta, const std::string &comment = std::string() )
 75 | 	{
 76 | 	    T			difference;
 77 | 	    difference			= ( a < b
 78 | 					    ? T( b - a )
 79 | 					    : T( a - b ));
 80 | 	    if ( ! ( difference < ( delta < T( 0 ) ? T( -delta ) : T( delta )))) {
 81 | 		std::ostringstream oss;
 82 | 		oss << std::setprecision( 13 ) << a << " != " << b << " +/- " << delta;
 83 | 		return failure( file, line, oss.str(), comment );
 84 | 	    }
 85 | 	    return success();
 86 | 	}
 87 | 	
 88 | 	asserter	       &failure( const char *file, int line, const std::string &comparison,
 89 | 					 const std::string &comment = std::string() )
 90 | 	{
 91 | 	    ++failures;
 92 | 	    const char	       *needle	= "/";
 93 | 	    const char	       *slash	= std::find_end( file, file + strlen( file ),
 94 | 							 needle, needle + strlen( needle ));
 95 | 	    if ( slash == file + strlen( file ))
 96 | 		slash		= file;
 97 | 	    else
 98 | 		slash	       += 1;
 99 | 
100 | 	    std::ostringstream oss;
101 | 	    oss
102 | 		<< std::setw( 24 ) << slash << ", "
103 | 		<< std::setw( -5 ) << line
104 | 		<< "; FAILURE: " << comparison
105 | 		<< ( comment.size() ? ": " : "" ) << comment
106 | 		<< std::endl;
107 | 	    out			= oss.str();
108 | 	    failed			= true;
109 | 	    return *this;
110 | 	}
111 | 
112 | 	asserter	       &success()
113 | 	{
114 | 	    out.clear();
115 | 	    failed			= false;
116 | 	    return *this;
117 | 	}
118 |     }; // class asserter
119 | } // namespace ezpwd
120 | 
121 | std::ostream	       	       &operator<<(
122 | 				    std::ostream       &lhs,
123 | 				    ezpwd::asserter    &rhs )
124 | {
125 |     return rhs.output( lhs );
126 | }
127 | 
128 | #endif // _EZPWD_ARRAY
129 | 


--------------------------------------------------------------------------------
/c++/ezpwd/bch_errnums/linux/errno.h:
--------------------------------------------------------------------------------
 1 | #include <errno.h>
 2 | 
 3 | #if ! defined( EBADMSG )
 4 | #  define EBADMSG	9905
 5 | #endif
 6 | 
 7 | #if ! defined( EINVAL )
 8 | #  define EINVAL	9943
 9 | #endif
10 | 


--------------------------------------------------------------------------------
/c++/ezpwd/bch_include:
--------------------------------------------------------------------------------
1 | ../../djelic/Documentation/bch/standalone


--------------------------------------------------------------------------------
/c++/ezpwd/definitions:
--------------------------------------------------------------------------------
 1 | // 
 2 | // C++ Definitions -- include once in a single C++ compilation unit
 3 | // 
 4 | #ifndef _EZPWD_DEFINITIONS
 5 | #define _EZPWD_DEFINITIONS
 6 | 
 7 | #include "serialize_definitions"
 8 | #include "rs_definitions"
 9 | 
10 | #endif // _EZPWD_DEFINITIONS
11 | 


--------------------------------------------------------------------------------
/c++/ezpwd/rs_definitions:
--------------------------------------------------------------------------------
 1 | 
 2 | // 
 3 | // The encoder/decoder tables for all ezpwd::rs codecs
 4 | // 
 5 | //     Must be included in exactly one C++ compilation unit.
 6 | // 
 7 | 
 8 | #ifndef _EZPWD_RS_DEFINITIONS
 9 | #define _EZPWD_RS_DEFINITIONS
10 | 
11 | #include "rs_base"
12 | 
13 | const constexpr std::array<uint8_t,256>
14 | 			ezpwd::reed_solomon_base::into_dual;
15 | const constexpr std::array<uint8_t,256>
16 | 			ezpwd::reed_solomon_base::from_dual;
17 | 
18 | #endif // _EZPWD_RS_DEFINITIONS
19 | 


--------------------------------------------------------------------------------
/c++/ezpwd/serialize_definitions:
--------------------------------------------------------------------------------
 1 | 
 2 | // 
 3 | // The encoder/decoder tables for all ezpwd::serialize::... base<N> codecs
 4 | // 
 5 | //     Must be included in exactly one C++ compilation unit.
 6 | // 
 7 | 
 8 | #ifndef _EZPWD_SERIALIZE_DEFINITIONS
 9 | #define _EZPWD_SERIALIZE_DEFINITIONS
10 | 
11 | #include "serialize"
12 | 
13 | // 
14 | // base<16> tables for RFC4864 standard
15 | // 
16 | const constexpr std::array<char,16>
17 | 			ezpwd::serialize::hex<16>::encoder;
18 | const constexpr std::array<char,127>
19 | 			ezpwd::serialize::hex<16>::decoder;
20 | 
21 | // 
22 | // base<32> tables for RFC4864 standard, and the Hex32, EZPWD and Crockford codecs
23 | // 
24 | const constexpr std::array<char,32>
25 | 			ezpwd::serialize::hex<32>::encoder;
26 | const constexpr std::array<char,127>
27 | 			ezpwd::serialize::hex<32>::decoder;
28 | const constexpr std::array<char,32>
29 | 			ezpwd::serialize::standard<32>::encoder;
30 | const constexpr std::array<char,127>
31 | 			ezpwd::serialize::standard<32>::decoder;
32 | const constexpr std::array<char,32>
33 | 			ezpwd::serialize::ezpwd<32>::encoder;
34 | const constexpr std::array<char,127>
35 | 			ezpwd::serialize::ezpwd<32>::decoder;
36 | const constexpr std::array<char,32>
37 | 			ezpwd::serialize::crockford<32>::encoder;
38 | const constexpr std::array<char,127>
39 | 			ezpwd::serialize::crockford<32>::decoder;
40 | 
41 | // 
42 | // base<64> tables for RFC4864 standard (regular and url), and the EZPWD codecs
43 | // 
44 | const constexpr std::array<char,64>
45 | 			ezpwd::serialize::standard<64>::encoder;
46 | const constexpr std::array<char,127>
47 | 			ezpwd::serialize::standard<64>::decoder;
48 | const constexpr std::array<char,64>
49 | 			ezpwd::serialize::standard_url<64>::encoder;
50 | const constexpr std::array<char,127>
51 | 			ezpwd::serialize::standard_url<64>::decoder;
52 | const constexpr std::array<char,64>
53 | 			ezpwd::serialize::ezpwd<64>::encoder;
54 | const constexpr std::array<char,127>
55 | 			ezpwd::serialize::ezpwd<64>::decoder;
56 | 
57 | #endif // _EZPWD_SERIALIZE_DEFINITIONS
58 | 


--------------------------------------------------------------------------------
/c++/ezpwd/timeofday:
--------------------------------------------------------------------------------
 1 | #ifndef _EZPWD_TIMEOFDAY
 2 | #define _EZPWD_TIMEOFDAY
 3 | 
 4 | #include <sys/time.h>
 5 | 
 6 | // 
 7 | // ezpwd::timeofday 	-- Return current time.
 8 | // ezpwd::epoch    	-- The UNIX epoch.
 9 | // ezpwd::seconds	-- convert timeval to a real-valued seconds
10 | // <timeval> < <timeval>-- less-than comparison on timevals
11 | // <timeval> - <timeval>-- difference on timevals
12 | //
13 | namespace ezpwd {
14 |     inline
15 |     timeval			timeofday()
16 |     {
17 | 	timeval			tv;
18 | 	::gettimeofday( &tv, NULL );
19 | 	return tv;
20 |     }
21 | 
22 |     timeval				epoch()
23 |     {
24 | 	timeval			tv;
25 | 	tv.tv_sec			= 0;
26 | 	tv.tv_usec			= 0;
27 | 	return tv;
28 |     }
29 | 
30 |     inline
31 |     double				seconds( const timeval &rhs )
32 |     {
33 | 	return rhs.tv_usec / 1000000.0 + rhs.tv_sec;
34 |     }
35 | } // namespace ezpwd
36 | 
37 | inline
38 | bool				operator<(
39 | 				    const timeval      &lhs,
40 | 				    const timeval      &rhs )
41 | {
42 |     return ( lhs.tv_sec 		<  rhs.tv_sec
43 | 	     || (( lhs.tv_sec		== rhs.tv_sec )
44 | 		 && ( lhs.tv_usec 	<  rhs.tv_usec )));
45 | }
46 | 
47 | inline
48 | timeval				operator-(
49 | 				    const timeval      &lhs,
50 | 				    timeval             rhs ) // copy; adjusted...
51 | {
52 |     timeval			result;
53 |     if ( lhs < rhs ) {
54 | 	result				= ezpwd::epoch();
55 |     } else {
56 | 	// See http://www.gnu.org/software/libc/manual/html_node/Elapsed-Time.html
57 | 	if ( lhs.tv_usec < rhs.tv_usec ) {
58 | 	    int 		sec	= ( rhs.tv_usec - lhs.tv_usec ) / 1000000 + 1;
59 | 	    rhs.tv_usec		       -= sec * 1000000;
60 | 	    rhs.tv_sec		       += sec;
61 | 	}
62 | 	if ( lhs.tv_usec - rhs.tv_usec > 1000000 ) {
63 | 	    int 		sec	= ( lhs.tv_usec - rhs.tv_usec ) / 1000000;
64 | 	    rhs.tv_usec 	       += sec * 1000000;
65 | 	    rhs.tv_sec		       -= sec;
66 | 	}
67 | 	result.tv_sec			= lhs.tv_sec  - rhs.tv_sec;
68 | 	result.tv_usec			= lhs.tv_usec - rhs.tv_usec;
69 |     }
70 |     return result;
71 | }
72 | 
73 | #endif // _EZPWD_TIMEOFDAY
74 | 


--------------------------------------------------------------------------------
/cut-test.C:
--------------------------------------------------------------------------------
  1 | 
  2 | // 
  3 | // cut-test.C		-- CUT unit tests
  4 | // 
  5 | 
  6 | #include <ezpwd/cut>
  7 | 
  8 | #if defined( __GNUC__ )
  9 | #  define UNUSED		__attribute__((unused))
 10 | #else
 11 | #  define UNUSED
 12 | #endif
 13 | 
 14 | 
 15 | #if defined( TEST )
 16 | 
 17 | namespace cut {
 18 | 
 19 | #if defined( TESTSTANDALONE )
 20 |     test			root( "C++ Unit Test Example" );
 21 | #endif
 22 | 
 23 |     CUT( root, cut_tests, "CUT" ) {
 24 | 	assert.out() << name() << std::endl;
 25 |     }
 26 | 
 27 |     CUT( cut_tests, FirstSuite, "The First Suite" ) {
 28 | 	assert.out() << "This is the first suite" << std::endl;
 29 | 	assert.ISTRUE( 1 );
 30 |     }
 31 | 
 32 |     CUT( FirstSuite, FirstSuiteInternalOne, "The First Suite's Internal Test One" ) {
 33 | 	assert.out() << "This is the first suite's internal test #1" << std::endl;
 34 | 	assert.ISEQUAL( 1 + 1, 2 );
 35 | 	assert.ISNOTEQUAL( 1 + 1, 3 );
 36 |     }
 37 | 
 38 |     CUT( cut_tests, animaltests, "Animal Tests" ) {
 39 | 	assert.out() << "Animal tests" << std::endl;
 40 |     }
 41 | 
 42 |     CUT( animaltests, ducktest, "Duck Test" ) {
 43 | 	assert.out() << "Monty Python's excellent witch testing protocol..." << std::endl;
 44 | 	assert.ISEQUAL( 1 - 1 + 1, 1 );
 45 | 	// assert.ISUNKNOWN( 1 );		// Unknown (must weigh same as wood)
 46 |     }
 47 | 
 48 |     CUT( animaltests, cowtest, "Cow Test" ) {
 49 | 	assert.out() << "Cow test" << std::endl;
 50 | 	assert.ISTRUE( true );			// Succeeds
 51 |     }
 52 | 
 53 |     CUT( cowtest, dogtest, "Dog Test" ) {
 54 | 	assert.out() << "Dog test" << std::endl;
 55 | 	assert.ISEQUAL( 1 + 1, 2 );
 56 | 	assert.ISFALSE( 1 + 1 == 4 );
 57 |     }
 58 | 
 59 |     CUT( cut_tests, Cstringtest, "C String Tests" ) {
 60 | 	assert.out() << "Now testing C string matching..." << std::endl;
 61 | 	assert.ISEQUAL( "Hello, World!", "Hello, World!" );
 62 | 	assert.ISFALSE( 0 == strcmp( "Hello, World!", "Hello,  World!" ));
 63 |     }
 64 | 
 65 |     CUT( cut_tests, stringtest, "String Tests" ) {
 66 | 	assert.out() << "Now testing std::string matching..." << std::endl;
 67 | 	assert.ISEQUAL( std::string( "Hello, World!" ), std::string( "Hello, World!" ) );
 68 | 	std::string	bye( "Goodbye" );
 69 | 	assert.ISEQUAL( bye, bye );
 70 |     }
 71 | 
 72 |     // 
 73 |     // Example of repeatedly running a chain of test suites.  You can
 74 |     // create a new cut::test, and use CUT to define some test(s)
 75 |     // chained to it.  Then, you can run the tree of tests repeatedly
 76 |     // with different initial conditions (either in a suite with a
 77 |     // loop, or just by calling the tree from within different
 78 |     // CUT-generated suites, which set up (and tear down) the initial
 79 |     // conditions.  Here, we illustrate one (sort of simple and silly)
 80 |     // use of this facility.
 81 |     // 
 82 |     struct mathfuns { 
 83 | 	const char	       *description;
 84 | 	double 	      	      (*fun )( double );
 85 | 	double			arg;
 86 | 	double			result;
 87 | 	double			delta;
 88 |     };
 89 | #   define			MATH( f, a, v ) { # f "( " #a " )", f, a, v, 1e-4 }
 90 |     static mathfuns	       *math;
 91 |     static mathfuns		mathtests[] = {
 92 | 	MATH( sqrt,	2.0,	1.4142 ),
 93 | 	MATH( sqrt,	4.0,	2.0000 ),
 94 | 	MATH( cos,	1.0,	0.5403 ),
 95 | 	MATH( sin,	1.0,	0.8414 ),
 96 | 	MATH( tan,	1.0,	1.5574 ),
 97 | 	{ 0, 0, 0, 0, 0 }
 98 |     };
 99 | 
100 |     // Root of "isolated" tree of tests
101 |     static test			mathsuite( "Repeated Math Test Suite" );
102 | 
103 |     // Define test(s) rooted in the "isolated" tree
104 |     CUT( mathsuite, mathvalue, "Test Function Value" ) {
105 | 	assert.ISEQUALDELTAS( math->fun( math->arg ), math->result, math->delta, math->description );
106 |     }
107 | 
108 |     // Run the "isolated" tree of tests, with different initial
109 |     // conditions.  This suite is rooted in the "main" cut::root tree
110 |     // of tests, and explicitly runs the "isolated" tree of tests,
111 |     // checking that it succeeds.
112 |     CUT( cut_tests, repeater, "Run All Math Tests" ) {
113 | 	for ( math = mathtests; math->description != 0; ++math ) {
114 | 	    // Set up your initial conditions here
115 | 	    assert.ISTRUE( assert.run( mathsuite ));
116 | 	    // Tear down your conditions here
117 | 	}
118 |     }
119 | 
120 |     // Test Exceptions.  Test succeeds if the correct exception is
121 |     // thrown, fails otherwise.
122 |     CUTEXCEPTION( cut_tests, TemplateExceptionTests, const char *, "Template Exception Tests" ) {
123 | 	assert.out() << "Throwing \"Hello, World!\"" << std::endl;
124 | 	throw "Hello, World!";
125 |     }
126 | 
127 |     // Test a selection of types.  Templates generate test code in for
128 |     // each type.
129 |     CUT( cut_tests, TypesTest, "Built-in Types Test" ) {
130 | 	assert.ISEQUAL(	   true, true );
131 | 	assert.ISNOTEQUAL( true, false );
132 | 	assert.ISEQUAL( char( 1 ), char( 1 ) );
133 | 	assert.ISNOTEQUAL( char( 1 ), char( 2 ) );
134 | 	assert.ISEQUALDELTA( char( 1 ), char( 2 ), char( 1 ));
135 | 	assert.ISEQUALPERCENT( char( 1 ), char( 2 ), char( 50 ));
136 | 	assert.ISEQUAL( (unsigned char)( 1 ), (unsigned char)( 1 ) );
137 | 	assert.ISNOTEQUAL( (unsigned char)( 1 ), (unsigned char)( 2 ) );
138 | 	assert.ISEQUALDELTA( (unsigned char)( 1 ), (unsigned char)( 2 ), (unsigned char)( 1 ));
139 | 	assert.ISNOTEQUALDELTA( (unsigned char)( 4 ), (unsigned char)( 2 ), (unsigned char)( 1 ));
140 | 	assert.ISEQUALPERCENT( (unsigned char)( 1 ), (unsigned char)( 2 ), (unsigned char)( 50 ));
141 | 	assert.ISEQUALPERCENT( (unsigned char)( 7 ), (unsigned char)( 5 ), (unsigned char)( 50 ));
142 | 	assert.ISEQUALPERCENT( (unsigned char)( 250 ), (unsigned char)( 200 ), (unsigned char)( 25 ));
143 | 	assert.ISNOTEQUALPERCENT( (unsigned char)( 255 ), (unsigned char)( 200 ), (unsigned char)( 25 ));
144 | 	assert.ISEQUAL( short( 1 ), short( 1 ) );
145 | 	assert.ISNOTEQUAL( short( 1 ), short( 2 ) );
146 | 	assert.ISEQUALDELTA( short( 1 ), short( 2 ), short( 1 ));
147 | 	assert.ISEQUALPERCENT( short( 1 ), short( 2 ), short( 50 ));
148 | 	assert.ISEQUALDELTA( short( -1 ), short( -2 ), short( 1 ));
149 | 	assert.ISEQUALPERCENT( short( -1 ), short( -2 ), short( 50 ));
150 | 	assert.ISEQUAL( int( 1 ), int( 1 ) );
151 | 	assert.ISNOTEQUAL( int( 1 ), int( 2 ) );
152 | 	assert.ISEQUALDELTA( int( 1 ), int( 2 ), 1 );
153 | 	assert.ISEQUALPERCENT( int( 1 ), int( 2 ), int( 50 ));
154 | 	assert.ISEQUALDELTA( int( -1 ), int( -2 ), 1 );
155 | 	assert.ISEQUALPERCENT( int( -1 ), int( -2 ), int( 50 ));
156 | 	assert.ISEQUAL( long( 1 ), long( 1 ) );
157 | 	assert.ISNOTEQUAL( long( 1 ), long( 2 ) );
158 | 	assert.ISEQUALDELTA( long( 1 ), long( 2 ), long( 1 ));
159 | 	assert.ISEQUALPERCENT( long( 1 ), long( 2 ), long( 50 ));
160 | 	assert.ISEQUALDELTA( long( -1 ), long( -2 ), long( 1 ));
161 | 	assert.ISEQUALPERCENT( long( -1 ), long( -2 ), long( 50 ));
162 | 	assert.ISEQUAL( float( 1.1 ), float( 1.1 ) );
163 | 	assert.ISNOTEQUAL( float( 1.1 ), float( 2.2 ) );
164 | 	assert.ISEQUALDELTA( float( 1.1 ), float( 2.2 ), float( 1.11 ));
165 | 	assert.ISEQUALPERCENT( float( 1.1 ), float( 2.2 ), float( 51 ));
166 | 	assert.ISEQUALDELTA( float( -1.1 ), float( -2.2 ), float( 1.11 ));
167 | 	assert.ISEQUALPERCENT( float( -1.1 ), float( -2.2 ), float( 51 ));
168 | 	assert.ISEQUAL( double( 1.1 ), double( 1.1 ) );
169 | 	assert.ISNOTEQUAL( double( 1.1 ), double( 2.2 ) );
170 | 	assert.ISEQUALDELTA( double( 1.1 ), double( 2.2 ), double( 1.11 ));
171 | 	assert.ISEQUALPERCENT( double( 1.1 ), double( 2.2 ), double( 51 ));
172 | 	assert.ISEQUALDELTA( double( -1.1 ), double( -2.2 ), double( 1.11 ));
173 | 	assert.ISEQUALPERCENT( double( -1.1 ), double( -2.2 ), double( 51 ));
174 | 	assert.ISEQUALDELTA( (long long)1234567890LL, (long long)1234567891LL, (long long)1LL );
175 |     }
176 | }
177 | 
178 | 
179 | #endif // TEST
180 | 
181 | #if defined( TESTSTANDALONE )
182 | 
183 | int
184 | main( int, char ** ) {
185 | 
186 |     // 
187 |     // Run the root test suite, using various runners
188 |     // 
189 |     cut::htmlrunner	html0( std::cout,
190 | 			       true,	// sparse
191 | 			       true,	// flat
192 | 			       true,	// cgi
193 | 			       true,   // do not redirect std::cout
194 | 			       0 );	// indent
195 |     html0.run();
196 | 
197 |     std::cout << "<PRE>\nRunning test suite in HTML mode; sparse, flat, redirecting std::cout.\n</PRE>" << std::endl;
198 |     cut::htmlrunner	html1( std::cout,
199 | 			       true,	// sparse
200 | 			       true,	// flat
201 | 			       false,	// not cgi
202 | 			       true,    // do redirect std::cout
203 | 			       8 );	// indent
204 |     html1.run();
205 | 
206 |     std::cout << "<PRE>\nRunning test suite in HTML mode; NOT sparse, flat, redirecting std::cout.\n</PRE>" << std::endl;
207 | 
208 |     cut::htmlrunner	html2( std::cout,
209 | 			       false,	// sparse
210 | 			       true,	// flat
211 | 			       false,	// not cgi
212 | 			       true,    // do redirect std::cout
213 | 			       0 );	// indent
214 |     html2.run();
215 | 
216 |     std::cout << "<PRE>\nRunning  ONE suite in HTML mode; NOT sparse, flat, redirecting std::cout.\n</PRE>" << std::endl;
217 |     html2.run( "Cow Test" );
218 | 
219 |     std::cout << "<PRE>\nRunning   NO suite in HTML mode; NOT sparse, flat, redirecting std::cout.\n</PRE>" << std::endl;
220 |     html2.run( "Invalid Test Suite Name" );
221 | 
222 |     std::cout << "<PRE>\nRunning test suite in HTML mode; NOT sparse, NOT flat, NOT redirecting std::cout.\n</PRE>" << std::endl;
223 | 
224 |     cut::htmlrunner	html3( std::cout,
225 | 			       false,	// sparse
226 | 			       false,	// heirarchical flat
227 | 			       false,	// not cgi
228 | 			       false,   // do redirect std::cout
229 | 			       8 );	// indent
230 |     html3.run();
231 | 
232 | 
233 |     std::cout << "<PRE>\nRunning test suite in text mode; sparse\n</PRE>" << std::endl;
234 |     std::cout << "<PRE>" << std::endl;
235 |     cut::runner		text1( std::cout,
236 | 			       true ); 	// sparse
237 |     text1.run();
238 |     std::cout << "</PRE>" << std::endl;
239 | 
240 |     std::cout << "<PRE>\nRunning test suite in text mode; NOT sparse\n</PRE>" << std::endl;
241 |     std::cout << "<PRE>" << std::endl;
242 |     cut::runner		text2( std::cout,
243 | 			       false );	// not sparse
244 |     text2.run();
245 |     std::cout << "</PRE>" << std::endl;
246 | 
247 |     return 0;
248 | }
249 | 
250 | #endif // TESTSTANDALONE
251 | 


--------------------------------------------------------------------------------
/cutone.C:
--------------------------------------------------------------------------------
 1 | 
 2 | // 
 3 | // cutone.C		-- CUT unit tests
 4 | // 
 5 | 
 6 | #include <ezpwd/cut>
 7 | 
 8 | #include <math.h>
 9 | 
10 | namespace cut {
11 |     //
12 |     // Create a test suite, which chains itself automatically
13 |     // beneath cut::root.  Don't clutter up your own namespace!
14 |     // 
15 |     test			root( "Simple C++ Unit Test" );
16 | 
17 |     //
18 |     // Create class derived from cut::test, and defines its run() method. The
19 |     // instance chains itself automatically beneath the given cut::test.
20 |     // 
21 |     CUT( cut::root, SqrtTest, "Simple sqrt() Test" ) {
22 | 	assert.out() << "tests sqrt(2) == 1.4 +/- 0.1" << std::endl;
23 | 	assert.ISEQUALDELTA( sqrt( 2.0 ), 1.4, 0.1 );
24 |     }
25 | }
26 | 
27 | int
28 | main(
29 |     int,
30 |     char 	       	      ** )
31 | {
32 |     // 
33 |     // Create cut::runner instances, and run all tests, with HTML output.
34 |     // Return 0 on success, ! 0 on failure. 
35 |     // 
36 |     cut::htmlrunner 		html( std::cout );	// use cut::runner for textual output
37 |     return ! html.run();
38 | }
39 |  
40 | 


--------------------------------------------------------------------------------
/default.nix:
--------------------------------------------------------------------------------
 1 | { pkgs ? import ./nixpkgs.nix {}, shell ? false }:
 2 | 
 3 | with pkgs;
 4 | 
 5 | let
 6 |   inherit (rust.packages.stable) rustPlatform;
 7 |   inherit (darwin.apple_sdk.frameworks) Security;
 8 | 
 9 |   stdenv = pkgs.gcc11Stdenv;
10 | in
11 | 
12 | {
13 |   ezpwd-reed-solomon = stdenv.mkDerivation rec {
14 |     name = "ezpwd-reed-solomon";
15 |     src = gitignoreSource ./.;
16 | 
17 |     cargoSha256 = "0xz29dxvg306kfc6fmysccdlw8fldwdpv9i40dwxnmd0wzcwhxxx";
18 | 
19 |     nativeBuildInputs = [ pkg-config ] ++ lib.optionals stdenv.isDarwin [
20 |       xcbuild
21 |     ];
22 | 
23 |     buildInputs = [
24 |       git
25 |       perl
26 |       bash
27 |       boost
28 |       ncurses
29 |     ];
30 | 
31 |     buildPhase = ''
32 |       make
33 |     '';
34 | 
35 |     installPhase = ''
36 |       mkdir -p          $out/include
37 |       cp -RL c++/*      $out/include
38 |       mkdir -p          $out/lib
39 |       mv libezpwd-*     $out/lib
40 |     '';
41 |   };
42 | }
43 | 


--------------------------------------------------------------------------------
/djelic_bch.c:
--------------------------------------------------------------------------------
1 | djelic/lib/bch.c


--------------------------------------------------------------------------------
/djelic_bch.h:
--------------------------------------------------------------------------------
1 | djelic/Documentation/bch/standalone/linux/bch.h


--------------------------------------------------------------------------------
/documentation/BCH_code.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/documentation/BCH_code.pdf


--------------------------------------------------------------------------------
/documentation/cyclic99.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/documentation/cyclic99.pdf


--------------------------------------------------------------------------------
/examples/ezcod_api/static/css/app.css:
--------------------------------------------------------------------------------
 1 | /* Small devices (tablets, 768px and up) */
 2 | @media (min-width: 768px) 
 3 | { 
 4 |     div[class^="col"]{padding-left:5px; padding-right:5px;}
 5 | }
 6 | 
 7 | /* Medium devices (desktops, 992px and up) */
 8 | @media (min-width: 992px) 
 9 | {   
10 |     div[class^="col"]{padding-left:10px; padding-right:10px;}
11 | }
12 | 
13 | /* Large devices (large desktops, 1200px and up) */
14 | @media (min-width: 1200px) 
15 | {   
16 |     /*default so you don't need this*/
17 |     div[class^="col"]{padding-left:15px; padding-right:15px;}
18 | }
19 | 
20 | /* Change the responsive breakpoint */
21 | @media (max-width: 860px) {
22 |     .navbar-header {
23 |         float: none;
24 |     }
25 |     .navbar-left,.navbar-right {
26 |         float: none !important;
27 |     }
28 |     .navbar-toggle {
29 |         display: block;
30 |     }
31 |     .navbar-collapse {
32 |         border-top: 1px solid transparent;
33 |         box-shadow: inset 0 1px 0 rgba(255,255,255,0.1);
34 |     }
35 |     .navbar-fixed-top {
36 |     top: 0;
37 |     border-width: 0 0 1px;
38 |     }
39 |     .navbar-collapse.collapse {
40 |         display: none!important;
41 |     }
42 |     .navbar-nav {
43 |         float: none!important;
44 |     margin-top: 7.5px;
45 |     }
46 |     .navbar-nav>li {
47 |         float: none;
48 |     }
49 |     .navbar-nav>li>a {
50 |         padding-top: 10px;
51 |         padding-bottom: 10px;
52 |     }
53 |     .collapse.in{
54 |     display:block !important;
55 |     }
56 | }
57 | 
58 | /*
59 | .form-control {
60 |   padding-left:  3px;
61 |   padding-right: 3px;
62 | }
63 | 
64 | .form-horizontal .control-group {
65 |   margin-left:  0;
66 |   margin-right: 0;
67 | }
68 | */
69 | 
70 | /* Forms in navbar header are not vertically padded to align properly */
71 | .header-form {
72 |   padding: 0px 15px;
73 | }
74 | 
75 | /* Lat/Lon inputs are joined on right */
76 | .latlon-input-addon { width: 4em; }
77 | .latlon-input   { width: 7em !important; }
78 | 
79 | /* Google Maps full-screen on modern browsers */
80 | body {
81 |   height: 100%;
82 |   padding-top: 50px; /* required with navbar-fixed-top */
83 | }
84 | html, #map-canvas {
85 |   height: 100%;
86 | }
87 | 


--------------------------------------------------------------------------------
/examples/ezcod_api/static/ezcod.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/examples/ezcod_api/static/ezcod.png


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/android-icon-144x144.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/examples/ezcod_api/static/icons/android-icon-144x144.png


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/android-icon-192x192.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/examples/ezcod_api/static/icons/android-icon-192x192.png


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/android-icon-36x36.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/examples/ezcod_api/static/icons/android-icon-36x36.png


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/android-icon-48x48.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/examples/ezcod_api/static/icons/android-icon-48x48.png


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/android-icon-72x72.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/examples/ezcod_api/static/icons/android-icon-72x72.png


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/android-icon-96x96.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/examples/ezcod_api/static/icons/android-icon-96x96.png


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/apple-icon-114x114.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/examples/ezcod_api/static/icons/apple-icon-114x114.png


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/apple-icon-120x120.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/examples/ezcod_api/static/icons/apple-icon-120x120.png


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/apple-icon-144x144.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/examples/ezcod_api/static/icons/apple-icon-144x144.png


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/apple-icon-152x152.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/examples/ezcod_api/static/icons/apple-icon-152x152.png


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/apple-icon-180x180.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/examples/ezcod_api/static/icons/apple-icon-180x180.png


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/apple-icon-57x57.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/examples/ezcod_api/static/icons/apple-icon-57x57.png


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/apple-icon-60x60.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/examples/ezcod_api/static/icons/apple-icon-60x60.png


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/apple-icon-72x72.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/examples/ezcod_api/static/icons/apple-icon-72x72.png


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/apple-icon-76x76.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/examples/ezcod_api/static/icons/apple-icon-76x76.png


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/apple-icon-precomposed.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/examples/ezcod_api/static/icons/apple-icon-precomposed.png


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/apple-icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/examples/ezcod_api/static/icons/apple-icon.png


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/browserconfig.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <browserconfig><msapplication><tile><square70x70logo src="/ms-icon-70x70.png"/><square150x150logo src="/ms-icon-150x150.png"/><square310x310logo src="/ms-icon-310x310.png"/><TileColor>#ffffff</TileColor></tile></msapplication></browserconfig>


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/favicon-16x16.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/examples/ezcod_api/static/icons/favicon-16x16.png


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/favicon-32x32.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/examples/ezcod_api/static/icons/favicon-32x32.png


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/favicon-96x96.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/examples/ezcod_api/static/icons/favicon-96x96.png


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/examples/ezcod_api/static/icons/favicon.ico


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/manifest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |  "name": "App",
 3 |  "icons": [
 4 |   {
 5 |    "src": "\/static\/icons\/android-icon-36x36.png",
 6 |    "sizes": "36x36",
 7 |    "type": "image\/png",
 8 |    "density": "0.75"
 9 |   },
10 |   {
11 |    "src": "\/static\/icons\/android-icon-48x48.png",
12 |    "sizes": "48x48",
13 |    "type": "image\/png",
14 |    "density": "1.0"
15 |   },
16 |   {
17 |    "src": "\/static\/icons\/android-icon-72x72.png",
18 |    "sizes": "72x72",
19 |    "type": "image\/png",
20 |    "density": "1.5"
21 |   },
22 |   {
23 |    "src": "\/static\/icons\/android-icon-96x96.png",
24 |    "sizes": "96x96",
25 |    "type": "image\/png",
26 |    "density": "2.0"
27 |   },
28 |   {
29 |    "src": "\/static\/icons\/android-icon-144x144.png",
30 |    "sizes": "144x144",
31 |    "type": "image\/png",
32 |    "density": "3.0"
33 |   },
34 |   {
35 |    "src": "\/static\/icons\/android-icon-192x192.png",
36 |    "sizes": "192x192",
37 |    "type": "image\/png",
38 |    "density": "4.0"
39 |   }
40 |  ]
41 | }
42 | 


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/ms-icon-144x144.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/examples/ezcod_api/static/icons/ms-icon-144x144.png


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/ms-icon-150x150.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/examples/ezcod_api/static/icons/ms-icon-150x150.png


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/ms-icon-310x310.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/examples/ezcod_api/static/icons/ms-icon-310x310.png


--------------------------------------------------------------------------------
/examples/ezcod_api/static/icons/ms-icon-70x70.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/examples/ezcod_api/static/icons/ms-icon-70x70.png


--------------------------------------------------------------------------------
/examples/ezcod_api/static/templates/keylist.html:
--------------------------------------------------------------------------------
 1 | $def with ( content )
 2 | <div class="container theme-showcase" role="main">
 3 |     <h1 class="page-header">
 4 |         $content["title"]
 5 |     </h1>
 6 |     <div class="row-fluid">
 7 |         <table class="table table-striped table-condensed table-bordered">
 8 |             <thead>
 9 |                $for key in content["keys"]:
10 |                   <th>$key</th>
11 |             </thead>
12 |             <tbody>
13 |               $for item in content["list"]:
14 |                 <tr>
15 |                   $for key in content["keys"]:
16 |                       <td>$item[key]</td>
17 |                 </tr>
18 |             </tbody>
19 |         </table>
20 |     </div>
21 | </div>
22 | 


--------------------------------------------------------------------------------
/examples/ezcod_api/static/templates/layout.html:
--------------------------------------------------------------------------------
 1 | $def with ( content )
 2 | <!DOCTYPE html>
 3 | <html>
 4 | <head>
 5 |     <title>EZCOD - Easy Geolocation Code</title>
 6 |     <meta charset="utf-8" />
 7 |     <meta http-equiv="X-UA-Compatible" content="IE=edge;" />
 8 |     <meta name="viewport" content="initial-scale=1, width=device-width, user-scalable=no" />
 9 |     <link rel="stylesheet" href="//maxcdn.bootstrapcdn.com/bootstrap/3.3.4/css/bootstrap.min.css">
10 |     <link rel="stylesheet" href="/static/css/app.css">
11 | 
12 |     <!--
13 |      == Icons
14 |      -->
15 |     <link rel="apple-touch-icon" sizes="57x57" href="/static/icons/apple-icon-57x57.png">
16 |     <link rel="apple-touch-icon" sizes="60x60" href="/static/icons/apple-icon-60x60.png">
17 |     <link rel="apple-touch-icon" sizes="72x72" href="/static/icons/apple-icon-72x72.png">
18 |     <link rel="apple-touch-icon" sizes="76x76" href="/static/icons/apple-icon-76x76.png">
19 |     <link rel="apple-touch-icon" sizes="114x114" href="/static/icons/apple-icon-114x114.png">
20 |     <link rel="apple-touch-icon" sizes="120x120" href="/static/icons/apple-icon-120x120.png">
21 |     <link rel="apple-touch-icon" sizes="144x144" href="/static/icons/apple-icon-144x144.png">
22 |     <link rel="apple-touch-icon" sizes="152x152" href="/static/icons/apple-icon-152x152.png">
23 |     <link rel="apple-touch-icon" sizes="180x180" href="/static/icons/apple-icon-180x180.png">
24 |     <link rel="icon" type="image/png" sizes="192x192" href="/static/icons/android-icon-192x192.png">
25 |     <link rel="icon" type="image/png" sizes="32x32" href="/static/icons/favicon-32x32.png">
26 |     <link rel="icon" type="image/png" sizes="96x96" href="/static/icons/favicon-96x96.png">
27 |     <link rel="icon" type="image/png" sizes="16x16" href="/static/icons/favicon-16x16.png">
28 |     <link rel="manifest" href="/static/icons/manifest.json">
29 |     <meta name="msapplication-TileColor" content="#ffffff">
30 |     <meta name="msapplication-TileImage" content="/static/icons/ms-icon-144x144.png">
31 |     <meta name="theme-color" content="#ffffff">
32 | 
33 |     <!--
34 |       == Begin loading of all Javascript resources early, and execute as asynchronously as possible.
35 |       -->
36 |     <script type="text/javascript">
37 |         // Bindings for Emscripten initialization detection.
38 |         var jquery_release = function() {
39 |             console.log( "Emscripten run-time initialization completed before jQuery loaded" );
40 |             jquery_loaded = function() {}; // nothing left to do after jquery loads.
41 |         };
42 |         var jquery_loaded = function() {
43 |             console.log( "Emscripten run-time initialization blocking jQuery..." );
44 |             $$.holdReady(true);		// force delay of triggering jQuery.on( 'ready', ...
45 |             jquery_release = function() {
46 |                 console.log( "Emscripten run-time initialization completed; jQuery released" );
47 |                 $$.holdReady(false);	// ... 'til Emscripten code runtime is initialized
48 |             };
49 |         };
50 |         var Module = {
51 |             onRuntimeInitialized: function() {
52 |                 jquery_release(); // Emscripten run-time has been initialized
53 |             }
54 |         };
55 |     </script>
56 |     <script type="text/javascript" async
57 | 	    src="//cdn.rawgit.com/pjkundert/ezpwd-reed-solomon/v1.8.0/js/ezpwd/ezcod.js"
58 | 	    srctest="static/js/ezcod.js"> <!-- access a sym-link to locally built version if desired -->
59 |     </script>
60 |     <script type="text/javascript" defer onload="jquery_loaded()"
61 |             src="//ajax.googleapis.com/ajax/libs/jquery/2.1.3/jquery.min.js">
62 |     </script>
63 |     <script type="text/javascript" defer
64 |             src="//maxcdn.bootstrapcdn.com/bootstrap/3.3.4/js/bootstrap.min.js">
65 |     </script>
66 | 
67 |     $if analytics:
68 |         <script type="text/javascript">
69 |             (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
70 |             (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
71 |             m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
72 |             })(window,document,'script','//www.google-analytics.com/analytics.js','ga');
73 | 
74 |             ga('create', '$analytics["id"]', 'auto');
75 |             ga('send', 'pageview');
76 |         </script>
77 | </head>
78 | <body>
79 |     $:content
80 | </body>
81 | </html>
82 | 
83 | 


--------------------------------------------------------------------------------
/examples/ezcod_api/static/templates/map.html:
--------------------------------------------------------------------------------
 1 | $def with ( content )
 2 |     <script type="text/javascript" defer
 3 |             src="/static/js/app.js"></script>
 4 |     <nav class="navbar navbar-default navbar-fixed-top">
 5 |         <div class="container-fluid">
 6 |             <div class="navbar-header">
 7 |                 <button type="button" class="navbar-toggle" data-toggle="collapse" data-target="#ezcod-navbar-collapse">
 8 |                     <span class="sr-only">Toggle navigation</span>
 9 |                     <span class="icon-bar"></span>
10 |                     <span class="icon-bar"></span>
11 |                     <span class="icon-bar"></span>
12 |                 </button>
13 | 
14 |                 <form class="navbar-form navbar-left form-inline header-form">
15 |                     <div class="input-group">
16 |                         <span class="input-group-btn">
17 |                             <button id="home" type="button" class="btn btn-default">
18 |                                 <span class="glyphicon glyphicon-home"></span>
19 |                             </button>
20 |                         </span>
21 |                         <input class="form-control ezcod-input-10"        type="text" id="EZCOD_3:10" placeholder="EZCOD 3:10">
22 |                         <input class="form-control ezcod-input-11 hidden" type="text" id="EZCOD_3:11" placeholder="EZCOD 3:11">
23 |                         <input class="form-control ezcod-input-12 hidden" type="text" id="EZCOD_3:12" placeholder="EZCOD 3:12">
24 |                     </div>
25 |                 </form>
26 |             </div>
27 | 
28 |             <div class="collapse navbar-collapse" id="ezcod-navbar-collapse">
29 |                 <form class="navbar-form form-inline">
30 |                     <ul class="nav navbar-nav">
31 |                         <li>
32 |                             <button type="button" class="btn btn-default dropdown-toggle"
33 |                                     data-toggle="dropdown"><span id="parity-button-text">EZCOD 3:10</span> <span class="caret"></span></button>
34 |                             <ul class="dropdown-menu" role="menu" id="parity">
35 |                                 <li>3:10</li>
36 |                                 <li>3:11</li>
37 |                                 <li>3:12</li>
38 |                             </ul>
39 |                         </li>
40 |                         <li>
41 |                             <div class="input-group">
42 |                                 <span class="input-group-addon latlon-input-addon">Lat:</span>
43 |                                 <input class="form-control latlon-input" type="text" id="pos_lat" placeholder="Latitude">
44 |                             </div>
45 |                         </li>
46 |                         <li>
47 |                             <div class="input-group">
48 |                                 <span class="input-group-addon latlon-input-addon">Lon:</span>
49 |                                 <input class="form-control latlon-input" type="text" id="pos_lon" placeholder="Longitude">
50 |                             </div>
51 |                         </li>
52 |                         <li>
53 |                             <div class="input-group">
54 |                                 <span class="input-group-addon latlon-input-addon">Acc:</span>
55 |                                 <input class="form-control latlon-input" type="text" id="pos_acc" placeholder="Accuracy" disabled>
56 |                             </div>
57 |                         </li>
58 |                     </ul>
59 |                 </form>
60 |             </div><!--/.nav-collapse -->
61 |         </div>
62 |     </nav>
63 |     <div id="error-bar"></div>
64 |     <div id="map-canvas"></div>
65 | 


--------------------------------------------------------------------------------
/examples/rskey.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en">
  3 | <head>
  4 |     <meta charset="utf-8" />
  5 |     <meta http-equiv="X-UA-Compatible" content="IE=edge;" />
  6 |     <title>RSKEY Example</title>
  7 |     <style>
  8 | 	html,body {
  9 | 	    height:100%;
 10 | 	    background:lightgray;
 11 | 	    font-family:arial,sans-serif;
 12 | 	}
 13 | 	table {
 14 | 	    width: 100%;
 15 | 	}
 16 | 	td:last-child {
 17 | 	    width: 100%;
 18 | 	}
 19 | 	table input {
 20 | 	    width: 100%;
 21 | 	}
 22 |     </style>
 23 |     <script type="text/javascript">
 24 |         // Bindings for Emscripten initialization detection.
 25 |         var jquery_release = function() {
 26 |             console.log( "Emscripten run-time initialization completed before jQuery loaded" );
 27 |             jquery_loaded = function() {}; // nothing left to do after jquery loads.
 28 |         };
 29 |         var jquery_loaded = function() {
 30 |             console.log( "Emscripten run-time initialization blocking jQuery..." );
 31 |             $.holdReady(true);		// force delay of triggering jQuery.on( 'ready', ...
 32 |             jquery_release = function() {
 33 |                 console.log( "Emscripten run-time initialization completed; jQuery released" );
 34 |                 $.holdReady(false);	// ... 'til Emscripten code run-time is initialized
 35 |             };
 36 |         };
 37 | 	var Module = {
 38 |             onRuntimeInitialized: function() {
 39 |                 jquery_release(); // Emscripten run-time has been initialized
 40 |             }
 41 | 	};
 42 |     </script>
 43 |     <script type="text/javascript" async
 44 |             src="//cdn.rawgit.com/pjkundert/ezpwd-reed-solomon/v1.8.0/js/ezpwd/rskey.js"
 45 | 	    srctest="rskey.js"> <!-- access a sym-link to locally built version if desired -->
 46 |     </script>
 47 | </head>
 48 | <body>
 49 |     <h3>RSKEY Encoding and Correction.</h3>
 50 |     <ul>
 51 |       <li>
 52 |         Change Parity to increase or decrease the error detection and correction capacity of
 53 |         the RSKEY.  It takes 1 parity symbol to correct any missing symbol (eg. one not
 54 |         yet entered on the end of the RSKEY, or one replaced by an '_' or other invalid
 55 |         character).  2 parity symbols are consumed to correct any erroneous symbol.
 56 |       </li>
 57 |       <li>
 58 |         Change Data to regenerate the RSKEY.  Provide either 0x... (hex), or Unicode text.
 59 |       </li>
 60 |     </ul>
 61 |     <table>
 62 |         <tr>
 63 |             <td>
 64 |                 Parity:
 65 |             </td>
 66 |             <td>
 67 |                 <input type='number' id='parity' value='3' min='2' max='5' />
 68 |             </td>
 69 |         </tr>
 70 |         <tr>
 71 |             <td>
 72 |                 Data Size:
 73 |             </td>
 74 |             <td>
 75 |                 <input type='number' id='rawsiz' value='8' min='0' />
 76 |             </td>
 77 |         </tr>
 78 |         <tr>
 79 |             <td>
 80 |                 Data:
 81 |             </td>
 82 |             <td>
 83 |                 <input type='text'   id='data' />
 84 |             </td>
 85 |         </tr>
 86 |         <tr>
 87 |             <td>
 88 |                 Separators:
 89 |             </td>
 90 |             <td>
 91 |                 <input type='number' id='sepers' value='4' min='0' />
 92 |             </td>
 93 |         </tr>
 94 |         <tr>
 95 |             <td>
 96 |                 Key:
 97 |             </td>
 98 |             <td>
 99 |                 <input type='text'   id='key' value='89JP-4VKR-437Q-0GAF' />
100 |             </td>
101 |         </tr>
102 |         <tr>
103 |             <td>
104 |                 Confidence:
105 |             </td>
106 |             <td>
107 |                 <div id='confidence' />
108 |             </td>
109 |         </tr>
110 |     </table>
111 |     <script type="text/javascript" onload="jquery_loaded()"
112 |             src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.3/jquery.min.js"></script>
113 |     <script type="text/javascript" defer>
114 |     $( document ).on( 'ready', function(){
115 | 	// Deferred 'til Emscripten run-time initialization is complete
116 | 	$('#data').on( 'blur change paste input', function() {
117 | 	    var data		= $('#data').val();
118 | 	    var rawsiz		= $('#rawsiz').val();
119 | 	    var sepers		= $('#sepers').val();
120 | 	    console.log( "encoding rawsiz == ", rawsiz, ", data == ", data );
121 | 	    var rskey_encode	= 'rskey_' + $('#parity').val() + "_encode"
122 | 	    $('#key').val( window[rskey_encode]( rawsiz|0, data, sepers|0 ));
123 | 	});
124 | 
125 | 	$('#key').on( 'blur', function() {
126 | 	    var key		= $('#key').val();
127 | 	    var rawsiz		= $('#rawsiz').val();
128 | 	    console.log( "decoding rawsiz == ", rawsiz, ",  key == ", key );
129 | 	    try {
130 | 		var rskey_decode= 'rskey_' + $('#parity').val() + "_decode"
131 | 		var dec		= window[rskey_decode]( rawsiz|0, key );
132 | 		console.log( "decoded: ", dec );
133 | 		$('#confidence').text( dec.confidence );
134 | 		var str		= dec.hex;
135 | 		if ( dec.utf8 )
136 | 		    str	       += ": " + dec.utf8;
137 | 		$('#data').val( str ).blur(); // and regenerate the key (fixing errors/erasures)
138 | 	    } catch ( exc ) {
139 | 		$('#data').val( "Exception: " + exc );
140 | 	    }		     
141 | 	});
142 | 
143 | 	// regenerate the key from data on parity, rawsiz change
144 | 	$('#parity').on( 'change', function(){ $('#data').blur(); } );
145 | 	$('#rawsiz').on( 'change', function(){ $('#data').blur(); } );
146 | 	$('#sepers').on( 'change', function(){ $('#data').blur(); } );
147 | 
148 | 	// And finally, decode the provided key to start things off
149 | 	$('#key').blur();
150 |     });
151 |     </script>
152 | </body>
153 | </html>
154 | 


--------------------------------------------------------------------------------
/exercise.H:
--------------------------------------------------------------------------------
  1 | /* Exercise an RS codec a specified number of times using random
  2 |  * data and error patterns
  3 |  *
  4 |  * Copyright 2002 Phil Karn, KA9Q
  5 |  * May be used under the terms of the GNU General Public License (GPL)
  6 |  */
  7 | #define FLAG_ERASURE 1 /* Randomly flag 50% of errors as erasures */
  8 | 
  9 | #include <iostream>
 10 | #include <iomanip>
 11 | #include <random>
 12 | 
 13 | #include <stdio.h>
 14 | #include <stdlib.h>
 15 | #include <memory.h>
 16 | 
 17 | #include <ezpwd/rs>
 18 | #include <ezpwd/timeofday>
 19 | 
 20 | /* Exercise the RS codec passed as an argument */
 21 | template < typename data_t, unsigned SYM, unsigned NROOTS, unsigned FCS, unsigned PRIM, unsigned POLY, bool DUAL >
 22 | int exercise( const ezpwd::reed_solomon<data_t, SYM, NROOTS, FCS, PRIM, ezpwd::gfpoly<SYM,POLY>, DUAL> &rs, int trials=1 )
 23 | {
 24 |     const unsigned NN = ( 1 << SYM ) - 1;
 25 |     data_t block[NN],tblock[NN];
 26 |     unsigned i;
 27 |     int errors;
 28 | 
 29 |     std::array<unsigned,NN> 	errlocs;
 30 |     std::array<unsigned,NROOTS>	derrlocs;
 31 |     data_t corrvals[NROOTS];
 32 |     int derrors;
 33 |     unsigned errval,errloc;
 34 |     unsigned erasures;
 35 |     unsigned tee;
 36 |     int decoder_errors = 0;
 37 | 
 38 |     struct timeval start;
 39 |     struct timeval end;
 40 | 
 41 |     //std::default_random_engine	rnd_gen( (unsigned int)time( 0 ));
 42 |     std::minstd_rand		rnd_gen( (unsigned int)time( 0 ));
 43 | #define random_between( first, last ) std::uniform_int_distribution<unsigned>(( first ), ( last ))
 44 |     auto			random_bool	= random_between( 0, 1 );
 45 |     auto			random_NROOTS_1	= random_between( 0, NROOTS - 1 );
 46 |     auto			random_NN	= random_between( 0, NN - 1 );
 47 |     auto			random_25	= random_between( 0, 25 );
 48 | 
 49 |     /*
 50 |      * Collect stats on 3 types of decodes; no errors, < 1/2 correction capacity, > 1/2 correction
 51 |      * capacity.  Also, on 4 percentages of padding symbols vs. capacity <25%, <50%, <75% and <100%.
 52 |      * We must perform each type 'kind' of encode/decode in a block, because it is not possible to
 53 |      * collect CPU time in resolutions smaller than clock ticks; typically on the order of 1/1000th
 54 |      * of a second...
 55 |      */
 56 |     int decusecs[4][3] = { { 0, 0, 0 },
 57 | 			   { 0, 0, 0 },
 58 | 			   { 0, 0, 0 },
 59 | 			   { 0, 0, 0 } };
 60 |     int decblcks[4][3] = { { 0, 0, 0 },
 61 | 			   { 0, 0, 0 },
 62 | 			   { 0, 0, 0 },
 63 | 			   { 0, 0, 0 } };
 64 |     double avgerror[4][3]  = { { 0, 0, 0 },
 65 | 			       { 0, 0, 0 },
 66 | 			       { 0, 0, 0 },
 67 | 			       { 0, 0, 0 } };
 68 |     double avgerasu[4][3]  = { { 0, 0, 0 },
 69 | 			       { 0, 0, 0 },
 70 | 			       { 0, 0, 0 },
 71 | 			       { 0, 0, 0 } };
 72 |     int errknd;
 73 |     const char * errstr[3] = {
 74 | 	"no errors",
 75 | 	"< 1/2 err",
 76 | 	">=1/2 err"
 77 |     };
 78 | 
 79 |     int pad;
 80 |     int padpct;
 81 |     int padknd;
 82 |     const char *padstr[4] = {
 83 | 	"<25%  pad",
 84 | 	"<50%  pad",
 85 | 	"<75%  pad",
 86 | 	"<100% pad"
 87 |     };
 88 | 
 89 |     int tri;
 90 | 
 91 |     for ( padknd = 0; padknd < 4; ++padknd ) for ( errknd = 0; errknd < 3; ++errknd ) {
 92 | 
 93 | 	    start		= ezpwd::timeofday();
 94 | 
 95 | #if defined( DEBUG ) && DEBUG >= 1
 96 | 	    trials	= 10;
 97 | #endif
 98 | 
 99 | 	    for ( tri = 0; tri < trials; ++tri ) {
100 | 
101 | 		/* Test up to the error correction capacity of the code */
102 | 		switch ( errknd ) {
103 | 		case 0: default:	/* no errors */
104 | 		    tee		= 0;
105 | 		    break;
106 | 		case 1:			/* <= 1/2 correction capacity */	
107 | 		    tee		= random_NROOTS_1( rnd_gen ) / 2 + 1;
108 | 		    break;
109 | 		case 2:			/* > 1/2 correction capacity */	
110 | 		    tee		= random_NROOTS_1( rnd_gen ) / 2 + NROOTS - ( NROOTS / 2 );
111 | 		    break;
112 | 		}
113 | 
114 | 		/*
115 | 		 * Allow up to the maximum amount of padding.  If NN == 255 and NROOTS == 32, then the
116 | 		 * number of non-parity symbols in the codeword is 255 - 32 == 223.  We can allow up to 222
117 | 		 * symbols of padding.  padknd specifies the allowable percentage range for this test...
118 | 		 */
119 | 		padpct	= padknd * 25 + random_25( rnd_gen );/* 0 - 100% */
120 | 		pad	= padpct * ( NN - NROOTS - 1) / 100;	/* as little as 1 data symbol */
121 | 		auto		random_NN_pad_1	= random_between( 0, NN - pad - 1 );
122 | 
123 | 		/* Load block with random data and encode */
124 | 		memset( block, 0, sizeof block );
125 | 		for(i=pad;i<NN-NROOTS;i++)
126 | 		    block[i] = random_NN( rnd_gen );
127 | 
128 | 		// Encode the block; pad+data+parity
129 | 		rs.encode( block+pad, NN-NROOTS-pad, block+NN-NROOTS);
130 | 
131 | #if defined( DEBUG ) && DEBUG >= 2
132 | 		std::cout
133 | 		    << "Original: " << std::endl
134 | 		    << std::vector<uint8_t>( block+pad, block+NN ) << std::endl;
135 | #endif
136 | 
137 | 		/* Make temp copy, seed with errors */
138 | 		memcpy(tblock,block,sizeof(tblock));
139 | 		errlocs.fill( 0 );	// memset(errlocs,0,sizeof(errlocs));
140 | 		derrlocs.fill( 0 );	// memset(derrlocs,0,sizeof(derrlocs));
141 | 
142 | 		/*
143 | 		 * RS codes can correct t errors or 2t erasures.  In other words, "errors * 2 + erasures <
144 | 		 * 2t".  So, we loop while we have room for at least 1 more erasure, and still come in at "<
145 | 		 * 2t".  Stop adding errors/erasures if we reach the number of non-pad symbols; this will be
146 | 		 * automatic, because the capacity will always be less than the number of non-padding
147 | 		 * symbols!
148 | 		 */
149 | 		erasures = 0;
150 | 		errors   = 0;
151 | 		std::vector<uint8_t>	errident( NN-pad, ' ' );
152 | 		for( i = 0; ( 2 * errors + erasures + 1 ) <= tee; i++ ) {
153 | 		    do {
154 | 			errval = random_NN( rnd_gen );
155 | 		    } while(errval == 0); /* Error value must contain at least one non-zero bit */
156 | 
157 | 		    do {
158 | 			errloc = random_NN_pad_1( rnd_gen ); /* errloc must be beyond end of pad */
159 | 		    } while(errlocs[errloc] != 0); /* Must not choose the same location twice */
160 | 
161 | 		    errlocs[errloc] = 1;
162 | 
163 | #if FLAG_ERASURE
164 | 		    if ( random_bool( rnd_gen ) /* 50-50 chance, or only room for 1 more erasure */
165 | 			 || (( 2 * errors + erasures + 1 ) >= tee )) {
166 | 			derrlocs[erasures++] = errloc;
167 | 			errident[errloc] = '_';
168 | 		    } else
169 | #endif
170 | 			{
171 | 			    ++ errors;
172 | 			    errident[errloc] = '?';
173 | 			}
174 | 		    // If a symbol marked as an erasure is not actually different from the computed
175 | 		    // value, it won't be returned in the count (nor included in the
176 | 		    // derrlocs/corrvals arrays.  So corrupt erasures to keep derrors consistent.
177 | 		    tblock[pad+errloc] ^= errval;	/* erasure or error; corrupt the symbol...*/
178 | 		}
179 | #if defined( DEBUG ) && DEBUG >= 2
180 | 		std::cout
181 | 		    << "Errors:   " << errors << ", erasures: " << erasures << std::endl
182 | 		    << errident << std::endl;
183 | #endif
184 | 
185 | #if defined( DEBUG ) && DEBUG >= 1
186 | 		std::cout
187 | 		    << rs << " decoding (mode: tee == " << std::setw( 3 ) << tee
188 | 		    << ", pad == " << padknd
189 | 		    << ", err == " << errknd
190 | 		    << ") with " << std::setw( 4 ) << errors 
191 | 		    << " errors, " << std::setw( 4 ) << erasures
192 | 		    << " erasures; " << std::setw( 4 ) << pad << " pad (" << padpct << "%)" 
193 | 		    << std::endl;
194 | #endif
195 | 
196 | 		/* Decode the errored block */
197 | 		derrors = rs.decode( tblock+pad, NN-NROOTS-pad, tblock+NN-NROOTS,
198 | 				     &derrlocs[0], erasures, corrvals );
199 | #if defined( DEBUG ) && DEBUG >= 2
200 | 		for ( int e = 0; e < derrors; ++e )
201 | 		    if ( derrlocs[e] >= 0 && derrlocs[e] < NN-pad )
202 | 			errident[derrlocs[e]] = corrvals[e];
203 | 		std::cout
204 | 		    << "Corrects: " << derrors << std::endl
205 | 		    << errident << std::endl;
206 | #endif
207 | 		
208 | 		decblcks[padknd][errknd] ++;
209 | 		avgerror[padknd][errknd] += errors;
210 | 		avgerasu[padknd][errknd] += erasures;
211 | 
212 | 		if(derrors != int( errors + erasures )){
213 | 		    std::cout 
214 | 			<< rs << " decoder says " << derrors 
215 | 			<< " errors, true number is " << errors + erasures
216 | 			<< " (" << errors << " errors, " << erasures << " erasures)"
217 | 			<< std::endl;
218 | 		    decoder_errors++;
219 | 		}
220 | 		for(int e=0; e < derrors; e++){
221 | 		    if(errlocs[derrlocs[e]] == 0){
222 | 			std::cout 
223 | 			    << rs << " decoder indicates error in location "
224 | 			    << derrlocs[e] << " without error"
225 | 			    << std::endl;
226 | 			decoder_errors++;
227 | 		    }
228 | 		}
229 | 		if(memcmp(tblock,block,sizeof tblock) != 0){
230 | 		    decoder_errors++;
231 | 		    std::cout
232 | 			<< rs << " uncorrected errors! output ^ input:"
233 | 			<< std::setfill( '0' ) << std::hex;
234 | 		    for(i=pad;i<NN;i++)
235 | 			std::cout
236 | 			    << std::setw( 2 ) << (unsigned int)(tblock[i] ^ block[i]);
237 | 		    std::cout
238 | 			<< std::setfill( ' ' ) << std::dec
239 | 			<< std::endl;
240 | 		}
241 | 	    }
242 | 
243 | 	    end				= ezpwd::timeofday();
244 | 	    timeval		duration= end - start;
245 | 	    decusecs[padknd][errknd] += duration.tv_sec * 1000000 + duration.tv_usec;
246 | 	}
247 | 
248 |     for ( padknd = 0; padknd < 4; ++padknd ) {
249 | 	for ( errknd = 0; errknd < 3; ++errknd ) {
250 | 	    if ( decblcks[padknd][errknd] )
251 | 		std::cout 
252 | 		    << rs
253 | 		    << " Enc/Decoding (" << errstr[errknd] << ", " << padstr[padknd]
254 | 		    << "). Bytes: " << std::setw( 4 ) << NN
255 | 		    << ", Blocks: " << std::setw( 5 ) << decblcks[padknd][errknd]
256 | 		    << " (avg. " << std::setprecision( 2 ) << std::setw( 6 )
257 | 		    << avgerror[padknd][errknd] / decblcks[padknd][errknd]
258 | 		    << " errors, " << std::setprecision( 2 ) << std::setw( 6 )
259 | 		    << avgerasu[padknd][errknd] / decblcks[padknd][errknd]
260 | 		    << " erasures), Usecs: " << std::setw( 9 ) << decusecs[padknd][errknd]
261 | 		    << " == " << std::setprecision( 0 ) << std::setw( 13 )
262 | 		    << (int)((( NN * decblcks[padknd][errknd] ) * 1000.0 )
263 | 			     / ( decusecs[padknd][errknd] ? decusecs[padknd][errknd] : -1 ))
264 | 		    << " kB/s"
265 | 		    << std::endl;
266 | 	}
267 |     }
268 | 
269 |     return decoder_errors;
270 | }
271 | 


--------------------------------------------------------------------------------
/ezcod.C:
--------------------------------------------------------------------------------
  1 | 
  2 | #include <iostream>
  3 | #include <utility>
  4 | 
  5 | #include <ezpwd/ezcod>		// C++ implementation
  6 | #if defined( DEBUG )
  7 | #  include <ezpwd/output>
  8 | #endif // DEBUG
  9 | 
 10 | #include <ezpwd/definitions>	// must be included in one C++ compilation unit
 11 | 
 12 | #include "ezcod.h"		// C API declarations
 13 | 
 14 | // 
 15 | // Encode lat/lon with default worst-case 3m. accuracy: 1 part in 2^22 Latitude, 2^23 Longitude.
 16 | // 
 17 | template < size_t P=1 >
 18 | int				ezcod_3_encode(
 19 | 				    double		lat,
 20 | 				    double		lon,
 21 | 				    char	       *enc,
 22 | 				    size_t		siz,
 23 | 				    size_t		pre	= 0 ) // precision (0 --> default 9)
 24 | {
 25 | #if defined( DEBUG ) && DEBUG > 1
 26 |     std::cout
 27 | 	<< "ezcod_3_encode<"	<< P << ">("
 28 | 	<< " lat == "		<< lat
 29 | 	<< ", lon == "		<< lon
 30 | 	<< ", w/ "		<< pre << " symbols precision"
 31 | #if DEBUG > 2
 32 | 	<< ", buf[" << siz << "] == " << std::vector<uint8_t>( (uint8_t*)enc, (uint8_t*)enc + siz )
 33 | #endif
 34 | 	<< std::endl;
 35 | #endif
 36 |     int				res;
 37 |     try {
 38 | 	const std::string      &str( ezpwd::ezcod<P>( lat, lon ).encode( pre ));
 39 | 	if ( str.size() + 1 > siz )
 40 | 	    throw std::runtime_error( "insufficient buffer provided" );
 41 | 	std::copy( str.begin(), str.end(), enc );
 42 | 	enc[str.size()]			= 0;
 43 | 	res				= str.size();
 44 |     } catch ( std::exception &exc ) {
 45 | 	ezpwd::streambuf_to_buffer sbf( enc, siz );
 46 | 	std::ostream( &sbf )
 47 | 	    << "ezcod_3_encode<" << P << ">(" << lat << ", " << lon << ") failed: "
 48 | 	    << exc.what();
 49 | 	res				= -1;
 50 |     }
 51 |     return res;
 52 | }
 53 | 
 54 | // 
 55 | // Decode lat/lon position in degrees and (optionally) accuracy in m, returning confidence in %.
 56 | // 
 57 | template < size_t P=1 >
 58 | int				ezcod_3_decode(
 59 | 				    char	       *dec,
 60 | 				    size_t		siz,
 61 | 				    double	       *lat	= 0,
 62 | 				    double	       *lon	= 0,
 63 | 				    double	       *acc	= 0 )
 64 | {
 65 |     int				confidence;
 66 |     try {
 67 | 	ezpwd::ezcod<P>		decoder( dec );
 68 | 	confidence			= decoder.confidence;
 69 | #if defined( DEBUG ) && DEBUG > 1
 70 | 	std::cout
 71 | 	    << "ezcod_3_decode<" << P << ">(\"" << dec
 72 | 	    << "\") == " << confidence << "% confidence: "
 73 | 	    << " lat (" << (void *)lat << ") == " << decoder.latitude
 74 | 	    << ", lon (" << (void *)lon << ") == " << decoder.longitude
 75 | 	    << ", acc (" << (void *)acc << ") == " << decoder.accuracy
 76 | 	    << std::endl;
 77 | #endif
 78 | 	if ( lat )
 79 | 	    *lat			= decoder.latitude;
 80 | 	if ( lon )
 81 | 	    *lon			= decoder.longitude;
 82 | 	if ( acc )
 83 | 	    *acc			= decoder.accuracy;
 84 |     } catch ( std::exception &exc ) {
 85 | 	std::string		location( dec );
 86 | 	ezpwd::streambuf_to_buffer sbf( dec, siz );
 87 | 	std::ostream( &sbf )
 88 | 	    << "ezcod_3_decode<" << P << ">(\"" << location << "\") failed: "
 89 | 	    << exc.what();
 90 | 	confidence			= -1;
 91 |     }
 92 |     return confidence;
 93 | }
 94 | 
 95 | extern "C" {
 96 | 
 97 |     /* ezcod 3:10 -- 9+1 Reed-Solomon parity symbol */
 98 |     int ezcod_3_10_encode( double lat, double lon, char *enc, size_t siz, size_t pre )
 99 |     {
100 | 	return ezcod_3_encode<1>( lat, lon, enc, siz, pre );
101 |     }
102 |     int ezcod_3_10_decode( char *dec, size_t siz, double *lat, double *lon, double *acc )
103 |     {
104 | 	return ezcod_3_decode<1>( dec, siz, lat, lon, acc );
105 |     }
106 | 
107 |     /* ezcod 3:11 -- 9+2 Reed-Solomon parity symbols */
108 |     int ezcod_3_11_encode( double lat, double lon, char *enc, size_t siz, size_t pre )
109 |     {
110 | 	return ezcod_3_encode<2>( lat, lon, enc, siz, pre );
111 |     }
112 |     int ezcod_3_11_decode( char *dec, size_t siz, double *lat, double *lon, double *acc )
113 |     {
114 | 	return ezcod_3_decode<2>( dec, siz, lat, lon, acc );
115 |     }
116 | 
117 |     /* ezcod 3:12 -- 9+3 Reed-Solomon parity symbols */
118 |     int ezcod_3_12_encode( double lat, double lon, char *enc, size_t siz, size_t pre )
119 |     {
120 | 	return ezcod_3_encode<3>( lat, lon, enc, siz, pre );
121 |     }
122 |     int ezcod_3_12_decode( char *dec, size_t siz, double *lat, double *lon, double *acc )
123 |     {
124 | 	return ezcod_3_decode<3>( dec, siz, lat, lon, acc );
125 |     }
126 | 
127 | } // extern "C"
128 | 
129 | #if defined( __cheerp )
130 | int webMain()
131 | {
132 |     return 0;
133 | }
134 | #endif
135 | 


--------------------------------------------------------------------------------
/ezcod.h:
--------------------------------------------------------------------------------
  1 | #ifndef _EZPWD_EZCOD_H
  2 | #define _EZPWD_EZCOD_H
  3 | 
  4 | /*
  5 |  * "C" API for ezcod w/3m accuracy in 9 symbols, with 1, 2 or 3 parity symbols.
  6 |  * 
  7 |  * ..._encode -- Encode the lat/lon into an ezcod 3:10 string in buffer supplied, returning length
  8 |  * ..._decode -- Decode the ezcode 3:10 string into lat, lon, returning confidence percentage
  9 |  * 
 10 |  *     All return -'ve value on failure, and as much of an error message as allowed by the 'siz' of
 11 |  * the supplied char* buffer.
 12 |  */
 13 | #  if defined( __cplusplus )
 14 | // Standard C Javascript binding implementation
 15 | extern "C" {
 16 | #  endif
 17 |     /* ezcod 3:10 -- 9+1 Reed-Solomon parity symbol */
 18 |     int				ezcod_3_10_encode(
 19 | 				    double		lat,
 20 | 				    double		lon,
 21 | 				    char	       *enc,
 22 | 				    size_t		siz,
 23 | 				    size_t		pre );
 24 |     int				ezcod_3_10_decode(
 25 | 				    char	       *dec,
 26 | 				    size_t		siz,
 27 | 				    double	       *lat,
 28 | 				    double	       *lon,
 29 | 				    double	       *acc );
 30 |     /* ezcod 3:11 -- 9+2 Reed-Solomon parity symbols */
 31 |     int				ezcod_3_11_encode(
 32 | 				    double		lat,
 33 | 				    double		lon,
 34 | 				    char	       *enc,
 35 | 				    size_t		siz,
 36 | 				    size_t		pre );
 37 |     int				ezcod_3_11_decode(
 38 | 				    char	       *dec,
 39 | 				    size_t		siz,
 40 | 				    double	       *lat,
 41 | 				    double	       *lon,
 42 | 				    double	       *acc );
 43 |     /* ezcod 3:12 -- 9+3 Reed-Solomon parity symbols */
 44 |     int				ezcod_3_12_encode(
 45 | 				    double		lat,
 46 | 				    double		lon,
 47 | 				    char	       *enc,
 48 | 				    size_t		siz,
 49 | 				    size_t		pre );
 50 |     int				ezcod_3_12_decode(
 51 | 				    char	       *dec,
 52 | 				    size_t		siz,
 53 | 				    double	       *lat,
 54 | 				    double	       *lon,
 55 | 				    double	       *acc );
 56 | #  if defined( __cplusplus )
 57 | } // extern "C"
 58 | 
 59 | #    if defined( __cheerp )
 60 | // Cheerp C++ Javascript binding implementation
 61 | class [[jsexport]] ezcod_cheerp
 62 | {
 63 |   public:
 64 | 				ezcod_cheerp()
 65 | 				{
 66 | 				    ;
 67 | 				}
 68 | 
 69 |     /* ezcod 3:10 -- 9+1 Reed-Solomon parity symbol */
 70 |     int				ezcod_3_10_encode(
 71 | 				    double		lat,
 72 | 				    double		lon,
 73 | 				    char	       *enc,
 74 | 				    size_t		siz,
 75 | 				    size_t		pre )
 76 |     {
 77 | 	return ::ezcod_3_10_encode( lat, lon, enc, siz, pre );
 78 |     }
 79 |     int				ezcod_3_10_decode(
 80 | 				    char	       *dec,
 81 | 				    size_t		siz,
 82 | 				    double	       *lat,
 83 | 				    double	       *lon,
 84 | 				    double	       *acc )
 85 |     {
 86 | 	return ::ezcod_3_10_decode( dec, siz, lat, lon, acc );
 87 |     }
 88 |     /* ezcod 3:11 -- 9+2 Reed-Solomon parity symbols */
 89 |     int				ezcod_3_11_encode(
 90 | 				    double		lat,
 91 | 				    double		lon,
 92 | 				    char	       *enc,
 93 | 				    size_t		siz,
 94 | 				    size_t		pre )
 95 |     {
 96 | 	return ::ezcod_3_11_encode( lat, lon, enc, siz, pre );
 97 |     }
 98 |     int				ezcod_3_11_decode(
 99 | 				    char	       *dec,
100 | 				    size_t		siz,
101 | 				    double	       *lat,
102 | 				    double	       *lon,
103 | 				    double	       *acc )
104 |     {
105 | 	return ::ezcod_3_11_decode( dec, siz, lat, lon, acc );
106 |     }
107 |     /* ezcod 3:12 -- 9+3 Reed-Solomon parity symbols */
108 |     int				ezcod_3_12_encode(
109 | 				    double		lat,
110 | 				    double		lon,
111 | 				    char	       *enc,
112 | 				    size_t		siz,
113 | 				    size_t		pre )
114 |     {
115 | 	return ::ezcod_3_12_encode( lat, lon, enc, siz, pre );
116 |     }
117 |     int				ezcod_3_12_decode(
118 | 				    char	       *dec,
119 | 				    size_t		siz,
120 | 				    double	       *lat,
121 | 				    double	       *lon,
122 | 				    double	       *acc )
123 |     {
124 | 	return ::ezcod_3_12_decode( dec, siz, lat, lon, acc );
125 |     }
126 | };
127 | #    endif // __cheerp
128 | #  endif // __cplusplus
129 | #endif // _EZPWD_EZCOD_H
130 | 


--------------------------------------------------------------------------------
/ezcod_wrap.js:
--------------------------------------------------------------------------------
  1 | //
  2 | // Ezpwd Reed-Solomon -- Reed-Solomon encoder / decoder library
  3 | // 
  4 | // Copyright (c) 2014, Hard Consulting Corporation.
  5 | //
  6 | // Ezpwd Reed-Solomon is free software: you can redistribute it and/or modify it under the terms of
  7 | // the GNU General Public License as published by the Free Software Foundation, either version 3 of
  8 | // the License, or (at your option) any later version.  See the LICENSE file at the top of the
  9 | // source tree.  Ezpwd Reed-Solomon is also available under Commercial license.  c++/ezpwd/rs_base
 10 | // is redistributed under the terms of the LGPL, regardless of the overall licensing terms.
 11 | // 
 12 | // Ezpwd Reed-Solomon is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 13 | // without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
 14 | // the GNU General Public License for more details.
 15 | //
 16 | 
 17 | // 
 18 | // string_to_heapi8	-- allocate buffer of (at least) len of type (eg. i8), initializing from str
 19 | // heapi8_to_string	-- decode a JS string from the buffer, til NUL
 20 | // array_to_heap	-- allocate an array of max( arr.length, len ) elements of type typ
 21 | // index_in_heap	-- return pointer to index ptr[idx] in an array of type typ
 22 | // 
 23 | //     The returned buffer may be longer than the C representation of UTF-8 str, but won't be
 24 | // shorter, and will be NUL terminated.  Account for size of native type in all heap allocations and
 25 | // indexing.
 26 | // 
 27 | function string_to_heapi8( str, len ) {
 28 |     var			arr	= intArrayFromString( str ); // will NUL terminate
 29 |     if ( len && arr.length < len )
 30 |         arr.length		= len;
 31 |     return allocate( arr, 'i8', ALLOC_NORMAL );
 32 | }
 33 | 
 34 | function heapi8_to_string( ptr, len ) {
 35 |     return Pointer_stringify( ptr );
 36 | };
 37 | 
 38 | function array_to_heap( typ, arr, len ) {
 39 |     if ( len && arr.length / Runtime.getNativeTypeSize( typ ) < len )
 40 |         arr.length		= len * Runtime.getNativeTypeSize( typ );
 41 |     return allocate( arr, typ, ALLOC_NORMAL );
 42 | }
 43 | 
 44 | function index_in_heap( typ, ptr, idx ) {
 45 |     return ptr + idx * Runtime.getNativeTypeSize( typ );
 46 | }
 47 | 
 48 | // 
 49 | // ezcod_3_<N>_encode -- encodes the lat/lon as an ezcod 3:<N> code, returning the encoded string
 50 | // ezcod_3_<N>_decode -- decodes the 3:<N> encoded string to confidence, lat/lon and accuracy
 51 | // 
 52 | //     Since arrays are used to communicate, they must be allocated locally and release after the
 53 | // wrapped call.  The underlying "C" decode returns a -'ve confidence and a (NUL terminated) string
 54 | // describing the error on failure, or a zero or +'ve confidence and the decoded lat/lon and
 55 | // accuracy on success.
 56 | // 
 57 | //     Encoding a Latitude/Longitude yields a 3:10/11/12 code with (default) 9 symbols of position
 58 | // information and 1, 2 or 3 symbols of parity.  You can specify an alternative number of symbols of
 59 | // position information, between 1 symbol (global quadrant) and 12 symbols (millimeters) of
 60 | // precision.
 61 | // 
 62 | //     Decoding an EZCOD 3:10/11/12 encoded string returns a Javascript Object:
 63 | // 
 64 | //         { confidence: <int>, latitude: <double>, longitude: <double>, accuracy: <double]
 65 | // 
 66 | // <confidence>	-- The percentage [0,100] of parity symbols in excess, after error/erasure correction
 67 | // <latitude>	-- Latitude in degress [-90,90]
 68 | // <longitude>	-- Longitude in degrees [-180,180]
 69 | // <accuracy>	-- Estimated accuracty in meters
 70 | // 
 71 | ezcod_3_N_encode_wrap = function( func_name ) {
 72 |     var func			= Module.cwrap( func_name, 'number',
 73 |                                                 ['number'	// lat
 74 |                                                  ,'number'	// lon
 75 |                                                  ,'number'	// array (buf allocated here)
 76 |                                                  ,'number'	// array size
 77 |                                                  ,'number'] );	// precision (0 --> default 9)
 78 |     return function( lat, lon, pre ) {
 79 |         if ( typeof pre == 'undefined' )
 80 |             pre			= 0;	// the default precision (9 symbols)
 81 |         var 		len	= 1024; // room for error message, spaces, etc.
 82 |         var		res	= -1;
 83 |         var		str	= func_name + " invocation failed.";
 84 |         var		buf	= string_to_heapi8( "", len );
 85 |         try { // must de-allocate buf after this point
 86 |             res			= func( lat, lon, buf, len, pre );
 87 |             str			= heapi8_to_string( buf );
 88 |         } finally {
 89 |             if ( buf ) _free( buf );
 90 |         }
 91 |         if ( res < 0 ) { // call failed, or call attempt failed w/o exception
 92 |             throw new Error( str );
 93 |         }
 94 |         return str;
 95 |     }
 96 | }
 97 | 
 98 | ezcod_3_10_encode		= ezcod_3_N_encode_wrap( 'ezcod_3_10_encode' );
 99 | ezcod_3_11_encode		= ezcod_3_N_encode_wrap( 'ezcod_3_11_encode' );
100 | ezcod_3_12_encode		= ezcod_3_N_encode_wrap( 'ezcod_3_12_encode' );
101 | 
102 | ezcod_3_N_decode_wrap = function( func_name ) {
103 |     var func			= Module.cwrap( func_name, 'number',
104 |                                                 ['number'	// array (buf allocated here)
105 |                                                  ,'number'	// array size
106 |                                                  ,'number'	// lat * (pos allocated here)
107 |                                                  ,'number'	// lon *  ''
108 |                                                  ,'number'] );	// acc *  ''
109 |     return function( cod ) {
110 |         var		cnf	= -1;
111 |         var		str	= func_name + " invocation failed.";
112 |         var		ret;
113 |         var		pos;
114 |         var 		len	= 1024; // room for error message, spaces, etc.
115 |         var		buf	= string_to_heapi8( cod, len );
116 |         try { // must de-allocate buf and lat/lon/acc after this point
117 |             pos			= array_to_heap( 'double', [], 3 );
118 |             var		lat	= index_in_heap( 'double', pos, 0 );
119 |             var		lon	= index_in_heap( 'double', pos, 1 );
120 |             var		acc	= index_in_heap( 'double', pos, 2 );
121 |             cnf			= func( buf, len, lat, lon, acc );
122 |             if ( cnf < 0 ) {
123 |                 str		= heapi8_to_string( buf );
124 |             } else {
125 |                 ret		= {
126 |                     confidence: cnf,
127 |                     latitude:	getValue( lat, 'double', 1 ),
128 |                     longitude:	getValue( lon, 'double', 1 ),
129 |                     accuracy:	getValue( acc, 'double', 1 ),
130 |                 };
131 |             }
132 |         } finally {
133 |             if ( buf ) _free( buf );
134 |             if ( pos ) _free( pos );
135 |         }
136 |         if ( cnf < 0 ) { // call failed, or call attempt failed w/o exception
137 |             throw new Error( str );
138 |         }
139 |  
140 |         return ret;
141 |     }
142 | }
143 | 
144 | ezcod_3_10_decode		= ezcod_3_N_decode_wrap( 'ezcod_3_10_decode' );
145 | ezcod_3_11_decode		= ezcod_3_N_decode_wrap( 'ezcod_3_11_decode' );
146 | ezcod_3_12_decode		= ezcod_3_N_decode_wrap( 'ezcod_3_12_decode' );
147 | 


--------------------------------------------------------------------------------
/nixpkgs.nix:
--------------------------------------------------------------------------------
1 | import (fetchGit {
2 |   url = "ssh://git@github.com/pjkundert/cleargrid-nixpkgs.git";
3 |   rev = "b9efff2afaae4bca4306bae463872b7c7047baf5";
4 |   ref = "master";
5 | })
6 | 


--------------------------------------------------------------------------------
/phil-karn/.gitignore:
--------------------------------------------------------------------------------
1 | rstest
2 | 


--------------------------------------------------------------------------------
/phil-karn/GNUmakefile:
--------------------------------------------------------------------------------
  1 | 
  2 | # 
  3 | # Build ezpwd/phil-karn
  4 | # 
  5 | #     Uses Phil Karn's LGPL Reed-Solomon implementation unchanged (except for
  6 | # the build procedure).  See README.
  7 | # 
  8 | SHELL		= bash
  9 | 
 10 | FEC		= fec-3.0.1
 11 | CFLAGS	       += -I. -I$(FEC)
 12 | 
 13 | # 
 14 | # Main targets
 15 | # 
 16 | all test: 			fec librs.a
 17 | 
 18 | test-all:			rstest
 19 | 	./rstest
 20 | 
 21 | clean:
 22 | 	-rm -rf fec $(FEC)
 23 | 	-rm -f *.a
 24 | 	-rm -f ccsds_tab.c ccsds_tal.c gen_ccsds gen_ccsds_tal rstest
 25 | 	-rm -f *.o
 26 | 	-rm -f *~
 27 | 	-rm -f core core.*
 28 | 
 29 | distclean:		clean
 30 | 
 31 | install:		all
 32 | 
 33 | # 
 34 | # Build targets
 35 | # 
 36 | 
 37 | # 
 38 | # ezpwd/phil-karn/fec must by a symbolic link pointing to Phil Karn's
 39 | # unpacked FEC implementation; this is required so that the header
 40 | # file ezpwd/phil-karn/rs.h can locate Phil's underlying <fec/fec.h>
 41 | # headers.  We have had to re-package Phil's ...tar.bz2 package as ...tar.gz,
 42 | # due to deficiencies in some of the build architectures (no bunzip2 or 
 43 | # "tar ..z.." on HP-UX)
 44 | # 
 45 | fec:			$(FEC)
 46 | 	ln -fs $^ $@
 47 | 
 48 | # 
 49 | # Apply any patches after unpacking the archive
 50 | # 
 51 | $(FEC):			$(FEC).tar.gz
 52 | 	gunzip < $^ | tar xf -
 53 | 	for p in $(FEC)*.patch; do ( cd $(FEC); patch -p1 ) < $$p; done
 54 | 	touch $@
 55 | 
 56 | # 
 57 | # The majority of the contents of librs.a comes directly from Phil's 
 58 | # implementation; the exceptions are:
 59 | # 
 60 | #     cpu_features.o	-- always selects cross-platform non-SIMD implementation
 61 | #     pad_rs.o		-- check that padding is consistent with specified encoding
 62 | # 
 63 | librs.a:		fec.o				\
 64 | 			encode_rs_char.o		\
 65 | 			encode_rs_int.o			\
 66 | 			encode_rs_8.o			\
 67 | 			decode_rs_char.o		\
 68 | 			decode_rs_int.o			\
 69 | 			decode_rs_8.o			\
 70 | 			init_rs_char.o			\
 71 | 			init_rs_int.o			\
 72 | 			pad_rs.o			\
 73 | 			ccsds_tab.o			\
 74 | 			encode_rs_ccsds.o		\
 75 | 			decode_rs_ccsds.o		\
 76 | 			ccsds_tal.o			\
 77 | 			cpu_features.o
 78 | 	rm -f $@
 79 | 	ar rsv $@ $^
 80 | 
 81 | # 
 82 | # I have used my own enhanced rstest.c and exercise.c to implement.
 83 | # 
 84 | rstest: 		rstest.o			\
 85 | 			exercise_char.o			\
 86 | 			exercise_int.o			\
 87 | 			exercise_8.o			\
 88 | 			exercise_ccsds.o		\
 89 | 			librs.a
 90 | 	$(CC) -o $@ $^
 91 | 
 92 | 
 93 | # 
 94 | # Build Phil's stock code
 95 | # 
 96 | sources 		= $(FEC)/fec.c			\
 97 | 			  $(FEC)/encode_rs_char.c	\
 98 | 			  $(FEC)/encode_rs_int.c	\
 99 | 			  $(FEC)/encode_rs_8.c		\
100 | 			  $(FEC)/encode_rs_ccsds.c	\
101 | 			  $(FEC)/decode_rs_char.c	\
102 | 			  $(FEC)/decode_rs_int.c	\
103 | 			  $(FEC)/decode_rs_8.c		\
104 | 			  $(FEC)/decode_rs_ccsds.c	\
105 | 			  $(FEC)/init_rs_char.c		\
106 | 			  $(FEC)/init_rs_int.c		\
107 | 			  $(FEC)/gen_ccsds.c		\
108 | 			  $(FEC)/gen_ccsds_tal.c	\
109 | 			  pad_rs.c			\
110 | 			  cpu_features.c		\
111 | 			  rstest.c			\
112 | 			  exercise.c
113 | 
114 | $(sources):		fec $(FEC)
115 | 
116 | fec.o:			$(FEC)/fec.c
117 | 	$(CC) $(CFLAGS) -c -o $@ $^
118 | 
119 | encode_rs_char.o:	$(FEC)/encode_rs_char.c
120 | 	$(CC) $(CFLAGS) -c -o $@ $^
121 | 
122 | encode_rs_int.o:	$(FEC)/encode_rs_int.c
123 | 	$(CC) $(CFLAGS) -c -o $@ $^
124 | 
125 | encode_rs_8.o:		$(FEC)/encode_rs_8.c
126 | 	$(CC) $(CFLAGS) -c -o $@ $^
127 | 
128 | encode_rs_ccsds.o:	$(FEC)/encode_rs_ccsds.c
129 | 	$(CC) $(CFLAGS) -c -o $@ $^
130 | 
131 | decode_rs_char.o:	$(FEC)/decode_rs_char.c
132 | 	$(CC) $(CFLAGS) -c -o $@ $^
133 | 
134 | decode_rs_int.o:	$(FEC)/decode_rs_int.c
135 | 	$(CC) $(CFLAGS) -c -o $@ $^
136 | 
137 | decode_rs_8.o:		$(FEC)/decode_rs_8.c
138 | 	$(CC) $(CFLAGS) -c -o $@ $^
139 | 
140 | decode_rs_ccsds.o:	$(FEC)/decode_rs_ccsds.c
141 | 	$(CC) $(CFLAGS) -c -o $@ $^
142 | 
143 | init_rs_char.o:		$(FEC)/init_rs_char.c
144 | 	$(CC) $(CFLAGS) -c -o $@ $^
145 | 
146 | init_rs_int.o:		$(FEC)/init_rs_int.c
147 | 	$(CC) $(CFLAGS) -c -o $@ $^
148 | 
149 | ccsds_tab.o: 		ccsds_tab.c
150 | 
151 | ccsds_tab.c:		gen_ccsds
152 | 	./gen_ccsds > ccsds_tab.c
153 | 
154 | gen_ccsds: 		gen_ccsds.o 		\
155 | 			init_rs_char.o		\
156 | 			fec.o
157 | 	$(CC) -o $@ $^
158 | 
159 | gen_ccsds.o:		$(FEC)/gen_ccsds.c
160 | 	$(CC)  $(CFLAGS) -c -o $@ $^
161 | 
162 | gen_ccsds_tal: 		gen_ccsds_tal.o		\
163 | 			init_rs_char.o
164 | 	$(CC) -o $@ $^
165 | 
166 | gen_ccsds_tal.o:	$(FEC)/gen_ccsds_tal.c
167 | 	$(CC)  $(CFLAGS) -c -o $@ $^
168 | 
169 | ccsds_tal.o:		ccsds_tal.c
170 | 
171 | ccsds_tal.c:		gen_ccsds_tal
172 | 	./gen_ccsds_tal > ccsds_tal.c
173 | 
174 | 
175 | # 
176 | # Build Perry's customized code
177 | # 
178 | pad_rs.o: 		pad_rs.c
179 | 	$(CC) $(CFLAGS) -c -o $@ $^
180 | 
181 | cpu_features.o: 	cpu_features.c
182 | 	$(CC) $(CFLAGS) -c -o $@ $^
183 | 
184 | 
185 | 
186 | rstest.o: 		rstest.c
187 | 	$(CC) $(CFLAGS) -c -o $@ $^
188 | 
189 | exercise_char.o:	exercise.c
190 | 	$(CC) $(CFLAGS) -c -o $@ $^
191 | 
192 | exercise_int.o:		exercise.c
193 | 	$(CC) -DBIGSYM=1 $(CFLAGS) -c -o $@ $^
194 | 
195 | exercise_8.o:		exercise.c
196 | 	$(CC) -DFIXED=1 $(CFLAGS) -c -o $@ $^
197 | 
198 | exercise_ccsds.o:	exercise.c
199 | 	$(CC) -DCCSDS=1 $(CFLAGS) -c -o $@ $^
200 | 
201 | 
202 | 


--------------------------------------------------------------------------------
/phil-karn/README:
--------------------------------------------------------------------------------
 1 | COPYRIGHT
 2 | 
 3 | This package is copyright 2006 by Phil Karn, KA9Q. It may be used
 4 | under the terms of the GNU Lesser General Public License (LGPL). See
 5 | the file "lesser.txt" in this package for license details.
 6 | 
 7 | Copyright 2006, Phil Karn, KA9Q
 8 | karn@ka9q.net
 9 | http://www.ka9q.net/
10 | 
11 | 
12 | DESCRIPTION
13 | 
14 |     This package implements a general purpose Reed-Solomon encoding and
15 | decoding facility. See the fec/rs.3 man page for details.
16 | 
17 |     The command "make test" runs a battery of encode/decode tests using a
18 | variety of RS codes using random data and random errors. Each test
19 | should pass with an "OK"; if any fail, please let me know so I can
20 | track down the problem.
21 | 
22 | 
23 |     This directory contains a modified version of:
24 | 
25 |         http://www.ka9q.net/code/fec/fec-3.0.1.tar.bz2 
26 | 
27 | by Perry Kundert (perry@hardconsulting.com).
28 | 
29 |     o Added some additional test cases
30 |     o Build only a selected subset of functionality (Reed-Solomon only)
31 |     o Handle some other architectures.
32 |     o Allow changing the padding specified in a prior call to init_rs_*().
33 | 
34 |     None of Phil's actual code has been changed; a simplified cross-platform
35 | build procedure has been implemented, and a couple of deprecated functions have
36 | been re-introduced.  The results are packaged into librs.a, and are available
37 | by including <rs.h>, as required.
38 | 


--------------------------------------------------------------------------------
/phil-karn/cpu_features.c:
--------------------------------------------------------------------------------
 1 | 
 2 | /*
 3 |  * cpu_features -- returns bitmask indicating SIMD features of CPU
 4 |  * 
 5 |  *     Force "portable" behavior.
 6 |  */
 7 | int cpu_features( void )
 8 | {
 9 | 	return 0;
10 | }
11 | 


--------------------------------------------------------------------------------
/phil-karn/exercise.c:
--------------------------------------------------------------------------------
  1 | /* Exercise an RS codec a specified number of times using random
  2 |  * data and error patterns
  3 |  *
  4 |  * Copyright 2002 Phil Karn, KA9Q
  5 |  * May be used under the terms of the GNU General Public License (GPL)
  6 |  */
  7 | #define FLAG_ERASURE 1 /* Randomly flag 50% of errors as erasures */
  8 | 
  9 | #include <stdio.h>
 10 | #include <stdlib.h>
 11 | #include <memory.h>
 12 | 
 13 | #define      CLOCK
 14 | #if defined( CLOCK )
 15 | #  include <time.h>
 16 | #else
 17 | #  include <sys/time.h>
 18 | #endif
 19 | 
 20 | #ifdef FIXED
 21 | #include "fixed.h"
 22 | #define EXERCISE exercise_8
 23 | #define ENCODE_RS encode_rs_8
 24 | #define DECODE_RS decode_rs_8
 25 | #elif defined(CCSDS)
 26 | #include "ccsds.h"
 27 | #define EXERCISE exercise_ccsds
 28 | #define ENCODE_RS encode_rs_ccsds
 29 | #define DECODE_RS decode_rs_ccsds
 30 | #elif defined(BIGSYM)
 31 | #include "int.h"
 32 | #define EXERCISE exercise_int
 33 | #define ENCODE_RS encode_rs_int
 34 | #define DECODE_RS decode_rs_int
 35 | #define PAD_RS pad_rs_int
 36 | #else
 37 | #include "char.h"
 38 | #define EXERCISE exercise_char
 39 | #define ENCODE_RS encode_rs_char
 40 | #define DECODE_RS decode_rs_char
 41 | #define PAD_RS pad_rs_char
 42 | #endif
 43 | 
 44 | #ifdef FIXED
 45 | #define PRINTPARM printf("(255,223):");
 46 | #elif defined(CCSDS)
 47 | #define PRINTPARM printf("CCSDS (255,223):");
 48 | #else
 49 | #define PRINTPARM printf("(%d,%d):",rs->nn,rs->nn-rs->nroots);
 50 | #endif
 51 | 
 52 | #include "rs-common.h"
 53 | #include "fec.h"
 54 | // Provided by previous version of Phil's Reed-Solomon library.
 55 | void *pad_rs_char( void *p, int pad );
 56 | void *pad_rs_int( void *p, int pad );
 57 | 
 58 | /* Exercise the RS codec passed as an argument */
 59 | int EXERCISE(
 60 | #if !defined(CCSDS) && !defined(FIXED)
 61 | void *p,
 62 | #endif
 63 | int trials){
 64 | #if !defined(CCSDS) && !defined(FIXED)
 65 |   struct rs *rs = (struct rs *)p;
 66 | #endif
 67 |   data_t block[NN],tblock[NN];
 68 |   int i;
 69 |   int errors;
 70 |   int errlocs[NN];
 71 |   int derrlocs[NROOTS];
 72 |   int derrors;
 73 |   int errval,errloc;
 74 |   int erasures;
 75 |   int tee;
 76 |   int decoder_errors = 0;
 77 | 
 78 | #if defined( CLOCK )
 79 |   clock_t	 start;
 80 |   clock_t	 end;
 81 | #else
 82 |   struct timeval start;
 83 |   struct timeval end;
 84 | #endif
 85 | 
 86 |   /*
 87 |    * Collect stats on 3 types of decodes; no errors, < 1/2 correction capacity, > 1/2 correction
 88 |    * capacity.  Also, on 4 percentages of padding symbols vs. capacity <25%, <50%, <75% and <100%.
 89 |    * We must perform each type 'kind' of encode/decode in a block, because it is not possible to
 90 |    * collect CPU time in resolutions smaller than clock ticks; typically on the order of 1/1000th
 91 |    * of a second...
 92 |    */
 93 |   int decusecs[4][3] = { { 0, 0, 0 },
 94 | 			 { 0, 0, 0 },
 95 | 			 { 0, 0, 0 },
 96 | 			 { 0, 0, 0 } };
 97 |   int decblcks[4][3] = { { 0, 0, 0 },
 98 | 			 { 0, 0, 0 },
 99 | 			 { 0, 0, 0 },
100 | 			 { 0, 0, 0 } };
101 |   double avgerror[4][3]  = { { 0, 0, 0 },
102 | 			     { 0, 0, 0 },
103 | 			     { 0, 0, 0 },
104 | 			     { 0, 0, 0 } };
105 |   double avgerasu[4][3]  = { { 0, 0, 0 },
106 | 			     { 0, 0, 0 },
107 | 			     { 0, 0, 0 },
108 | 			     { 0, 0, 0 } };
109 |   int errknd;
110 |   const char * errstr[3] = {
111 |     "no errors",
112 |     "< 1/2 err",
113 |     ">=1/2 err"
114 |   };
115 | 
116 |   int pad;
117 |   int padpct;
118 |   int padknd;
119 |   const char *padstr[4] = {
120 |     "<25%  pad",
121 |     "<50%  pad",
122 |     "<75%  pad",
123 |     "<100% pad"
124 |   };
125 | 
126 |   int tri;
127 | 
128 |   for ( padknd = 0; padknd < 4; ++padknd ) for ( errknd = 0; errknd < 3; ++errknd ) {
129 | 
130 | #if defined( CLOCK )
131 |     start	= clock();
132 | #else
133 |     (void)gettimeofday( &start, NULL );
134 | #endif
135 | 
136 | #if defined( DEBUG ) && DEBUG >= 1
137 |     trials	= 10;
138 | #endif
139 | 
140 |     for ( tri = 0; tri < trials; ++tri ) {
141 | 
142 |       /* Test up to the error correction capacity of the code */
143 |       switch ( errknd ) {
144 |       case 0:			/* no errors */
145 | 	tee		= 0;
146 | 	break;
147 |       case 1:			/* <= 1/2 correction capacity */	
148 | 	tee		= ( random() % NROOTS ) / 2 + 1;
149 | 	break;
150 |       case 2:			/* > 1/2 correction capacity */	
151 | 	tee		= ( random() % NROOTS ) / 2 + NROOTS - ( NROOTS / 2 );
152 | 	break;
153 |       }
154 | 
155 |       /*
156 |        * Allow up to the maximum amount of padding.  If NN == 255 and NROOTS == 32, then the
157 |        * number of non-parity symbols in the codeword is 255 - 32 == 223.  We can allow up to 222
158 |        * symbols of padding.  padknd specifies the allowable percentage range for this test...
159 |        */
160 |       padpct	= padknd * 25 + random() % 26;	/* 0 - 100% */
161 |       pad	= padpct * ( NN - NROOTS - 1) / 100;
162 | 
163 |       /* Load block with random data and encode */
164 |       memset( block, 0, sizeof block );
165 |       for(i=0;i<NN-NROOTS-pad;i++)
166 | 	block[i] = random() & NN;
167 | 
168 | #if defined(CCSDS) || defined(FIXED)
169 |       ENCODE_RS(&block[0],&block[NN-NROOTS-pad], pad);
170 | #else
171 |       PAD_RS( rs, pad );
172 |       ENCODE_RS(rs,&block[0],&block[NN-NROOTS-pad]);
173 | #endif
174 | 
175 |       /* Make temp copy, seed with errors */
176 |       memcpy(tblock,block,sizeof(tblock));
177 |       memset(errlocs,0,sizeof(errlocs));
178 |       memset(derrlocs,0,sizeof(derrlocs));
179 | 
180 |       /*
181 |        * RS codes can correct t errors or 2t erasures.  In other words, "errors * 2 + erasures <
182 |        * 2t".  So, we loop while we have room for at least 1 more erasure, and still come in at "<
183 |        * 2t".  Stop adding errors/erasures if we reach the number of non-pad symbols; this will be
184 |        * automatic, because the capacity will always be less than the number of non-padding
185 |        * symbols!
186 |        */
187 |       erasures = 0;
188 |       errors   = 0;
189 |       for( i = 0; ( 2 * errors + erasures + 1 ) <= tee; i++ ) {
190 | 	do {
191 | 	  errval = random() & NN;
192 | 	} while(errval == 0); /* Error value must contain at least one non-zero bit */
193 | 
194 | 	do {
195 | 	  errloc = ( random() % ( NN - pad )) + pad; /* errloc must be beyond end of pad */
196 | 	} while(errlocs[errloc] != 0); /* Must not choose the same location twice */
197 | 
198 | 	errlocs[errloc] = 1;
199 | 
200 | #if FLAG_ERASURE
201 | 	if ( ( random() & 1)	/* 50-50 chance, or only room for 1 more erasure */
202 | 	     || (( 2 * errors + erasures + 1 ) >= tee )) {
203 | 	  derrlocs[erasures++] = errloc;
204 | 	} else
205 | #endif
206 | 	{
207 | 	    ++ errors;
208 | 	}
209 | 	tblock[errloc-pad] ^= errval;	/* erasure or error; corrupt the symbol...*/
210 |       }
211 | 
212 | #if DEBUG >= 1
213 |       PRINTPARM
214 |       printf(" decoding (mode: tee == %3d, pad == %1d, err == %1d) with %4d errors, %4d erasures; %4d pad (%2d%)\n",
215 | 	     tee, padknd, errknd,
216 | 	     errors, erasures,
217 | 	     pad, padpct );
218 | #endif
219 | 
220 |       /* Decode the errored block */
221 | #if defined(CCSDS) || defined(FIXED)
222 |       derrors = DECODE_RS(tblock,derrlocs,erasures,pad);
223 | #else
224 |       derrors = DECODE_RS(rs,tblock,derrlocs,erasures);
225 | #endif
226 | 
227 |       decblcks[padknd][errknd] ++;
228 |       avgerror[padknd][errknd] += errors;
229 |       avgerasu[padknd][errknd] += erasures;
230 | 
231 |       if(derrors != errors + erasures){
232 | 	PRINTPARM
233 | 	printf(" decoder says %d errors, true number is %d (%d errors, %d erasures)\n",
234 | 	       derrors, errors + erasures, errors, erasures );
235 | 	decoder_errors++;
236 |       }
237 |       for(i=0;i<derrors;i++){
238 | 	if(errlocs[derrlocs[i]] == 0){
239 | 	  PRINTPARM
240 | 	  printf(" decoder indicates error in location %d without error\n",derrlocs[i]);
241 | 	  decoder_errors++;
242 | 	}
243 |       }
244 |       if(memcmp(tblock,block,sizeof(tblock)) != 0){
245 | 	PRINTPARM
246 | 	printf(" uncorrected errors! output ^ input:");
247 | 	decoder_errors++;
248 | 	for(i=0;i<NN;i++)
249 | 	  printf(" %02x",tblock[i] ^ block[i]);
250 | 	printf("\n");
251 |       }
252 |     }
253 | 
254 | #if defined( CLOCK )
255 |     end		= clock();
256 |     decusecs[padknd][errknd] += end - start;
257 | #else
258 |     (void)gettimeofday( &end, NULL );
259 |     decusecs[padknd][errknd] += ( end.tv_sec - start.tv_sec ) * 1000000;
260 |     decusecs[padknd][errknd] += ( end.tv_usec - start.tv_usec );
261 | #endif
262 | 
263 |   }
264 | 
265 |   for ( padknd = 0; padknd < 4; ++padknd ) {
266 |     for ( errknd = 0; errknd < 3; ++errknd ) {
267 |       if ( decblcks[padknd][errknd] )
268 | 	  printf( "Enc/Decoding (%s, %s). Bytes: %4d, Blocks: %5d (avg. %4.2g errors, %4.2g erasures), Usecs: %9d == %13.0f B/s\n",
269 | 		  errstr[errknd],
270 | 		  padstr[padknd],
271 | 		  NN, decblcks[padknd][errknd],
272 | 		  avgerror[padknd][errknd] / decblcks[padknd][errknd],
273 | 		  avgerasu[padknd][errknd] / decblcks[padknd][errknd],
274 | 		  decusecs[padknd][errknd],
275 | 		  ((( NN * decblcks[padknd][errknd] ) * 1000000.0 )
276 | 		   / ( decusecs[padknd][errknd] ? decusecs[padknd][errknd] : -1 )));
277 | 
278 |     }
279 |   }
280 | 
281 |   return decoder_errors;
282 | }
283 | 


--------------------------------------------------------------------------------
/phil-karn/fec-3.0.1-int.patch:
--------------------------------------------------------------------------------
 1 | Only in fec-3.0.1: fec-3.0.1
 2 | diff -u fec-3.0.1/fec.h fec-3.0.2/fec.h
 3 | --- fec-3.0.1/fec.h	2006-10-12 19:10:53.000000000 -0600
 4 | +++ fec-3.0.2/fec.h	2022-03-29 11:39:54.000000000 -0600
 5 | @@ -235,8 +235,8 @@
 6 |  void free_rs_char(void *rs);
 7 |  
 8 |  /* General purpose RS codec, integer symbols */
 9 | -void encode_rs_int(void *rs,int *data,int *parity);
10 | -int decode_rs_int(void *rs,int *data,int *eras_pos,int no_eras);
11 | +void encode_rs_int(void *rs,unsigned int *data,unsigned int *parity);
12 | +int decode_rs_int(void *rs,unsigned int *data,int *eras_pos,int no_eras);
13 |  void *init_rs_int(int symsize,int gfpoly,int fcr,
14 |  		  int prim,int nroots,int pad);
15 |  void free_rs_int(void *rs);
16 | Only in fec-3.0.2: fec.h~
17 | 


--------------------------------------------------------------------------------
/phil-karn/fec-3.0.1.tar.bz2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/phil-karn/fec-3.0.1.tar.bz2


--------------------------------------------------------------------------------
/phil-karn/fec-3.0.1.tar.gz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/phil-karn/fec-3.0.1.tar.gz


--------------------------------------------------------------------------------
/phil-karn/pad_rs.c:
--------------------------------------------------------------------------------
 1 | #include <rs.h>
 2 | 
 3 | /* 
 4 |  * pad_rs_int
 5 |  * pad_rs_char
 6 |  * 
 7 |  *     Ensure that the specified amount of padding is compatible with the
 8 |  * encoding.  These functions used to be part of the older version of Phil's
 9 |  * Reed-Solomon library, so Iv'e replicated them here.
10 |  */
11 | 
12 | void *pad_rs(void *p, int pad){
13 |   struct rs *rs = (struct rs *)p;
14 |   if(pad < 0 || pad >= ( rs->nn - rs->nroots ))
15 |     return 0; /* Too much padding */
16 |   rs->pad = pad;
17 |   return p;
18 | }
19 | 
20 | void *pad_rs_char( void *p, int pad )
21 | {
22 |     return pad_rs( p, pad );
23 | }
24 | 
25 | void *pad_rs_int( void *p, int pad )
26 | {
27 |     return pad_rs( p, pad );
28 | }
29 | 
30 | 


--------------------------------------------------------------------------------
/phil-karn/rs.3:
--------------------------------------------------------------------------------
  1 | .TH REED-SOLOMON 3
  2 | .SH NAME
  3 | init_rs_int, encode_rs_int, decode_rs_int, free_rs_int,
  4 | init_rs_char, encode_rs_char, decode_rs_char, free_rs_char,
  5 | encode_rs_8, decode_rs_8, encode_rs_ccsds, decode_rs_ccsds
  6 | \- Reed-Solomon encoding/decoding
  7 | .SH SYNOPSIS
  8 | .nf
  9 | .ft B
 10 | #include "rs.h"
 11 | 
 12 | void *init_rs_int(int symsize,int gfpoly,int fcr,int prim,
 13 |      int nroots,int pad);
 14 | 
 15 | void *pad_rs_int(void *rs, int pad);
 16 | 
 17 | void encode_rs_int(void *rs,int *data,int *parity);
 18 | 
 19 | int decode_rs_int(void *rs,int *data,int *eras_pos,int no_eras);
 20 | 
 21 | void free_rs_int(void *rs);
 22 | 
 23 | 
 24 | void *init_rs_char(int symsize,int gfpoly,int fcr,int prim,
 25 |      int nroots,int pad);
 26 | 
 27 | void *pad_rs_char(void *rs, int pad);
 28 | 
 29 | void encode_rs_char(void *rs,unsigned char *data,
 30 |      unsigned char *parity);
 31 | 
 32 | int decode_rs_char(void *rs,unsigned char *data,int *eras_pos,
 33 |      int no_eras);
 34 | 
 35 | void free_rs_char(void *rs);
 36 | 
 37 | 
 38 | void encode_rs_8(unsigned char *data,unsigned char *parity,
 39 |      int pad);
 40 | 
 41 | int decode_rs_8(unsigned char *data,int *eras_pos,int no_eras,
 42 |      int pad);
 43 | 
 44 | 
 45 | void encode_rs_ccsds(unsigned char *data,unsigned char *parity,
 46 |      int pad);
 47 | 
 48 | int decode_rs_ccsds(unsigned char *data,int *eras_pos,int no_eras,
 49 |      int pad);
 50 | 
 51 | unsigned char Taltab[256];
 52 | unsigned char Tal1tab[256];
 53 | 
 54 | .fi
 55 | 
 56 | .SH DESCRIPTION
 57 | These functions implement Reed-Solomon error control encoding and
 58 | decoding. For optimal performance in a variety of applications, three
 59 | sets of functions are supplied. To access these functions, add "-lrs"
 60 | to your linker command line.
 61 | 
 62 | The functions with names ending in \fB_int\fR handle data in integer arrays,
 63 | permitting arbitrarily large codewords limited only by machine
 64 | resources.
 65 | 
 66 | The functions with names ending in \fB_char\fR take unsigned char arrays and can
 67 | handle codes with symbols of 8 bits or less (i.e., with codewords of
 68 | 255 symbols or less).
 69 | 
 70 | \fBencode_rs_8\fR and \fBdecode_rs_8\fR implement a specific
 71 | (255,223) code with 8-bit symbols specified by the CCSDS:
 72 | a field generator of 1 + X + X^2 + X^7 + X^8 and a code
 73 | generator with first consecutive root = 112 and a primitive element of
 74 | 11. These functions use the conventional
 75 | polynomial form, \fInot\fR the dual-basis specified in
 76 | the CCSDS standard, to represent symbols. This code may be
 77 | shortened by giving a non-zero \fBpad\fR value to produce a
 78 | (255-\fBpad\fR,223-\fBpad\fR) code. The padding will consist of the
 79 | specified number of zeroes at the front of the full codeword.
 80 | 
 81 | For full CCSDS compatibility, \fBencode_rs_ccsds\fR and
 82 | \fBdecode_rs_ccsds\fR are provided. These functions use two lookup
 83 | tables, \fBTaltab\fR to convert from conventional to dual-basis, and
 84 | \fBTal1tab\fR to perform the inverse mapping from dual-basis to
 85 | conventional form, before and after calls to \fBencode_rs_8\fR
 86 | and \fBdecode_rs_8\fR.
 87 | 
 88 | The \fB_8\fR and \fB_ccsds\fR functions do not require initialization.
 89 | 
 90 | To use the general purpose RS encoder or decoder (i.e.,
 91 | the \fB_char\fR or \fB_int\fR versions), the user must first
 92 | call \fBinit_rs_int\fR or \fBinit_rs_char\fR as appropriate. The
 93 | arguments are as follows:
 94 | 
 95 | \fBsymsize\fR gives the symbol size in bits, up to 8 for \fBinit_rs_char\fR
 96 | or 32 for \fBinit_rs_int\fR on a machine with 32-bit ints (though such a
 97 | huge code would exhaust memory limits on a 32-bit machine). The resulting
 98 | Reed-Solomon code word will have 2^\fBsymsize\fR - 1 symbols,
 99 | each containing \fBsymsize\fR bits. The codeword may be shortened with the
100 | \fBpad\fR parameter described below.
101 | 
102 | \fBgfpoly\fR gives the extended Galois field generator polynomial coefficients,
103 | with the 0th coefficient in the low order bit. The polynomial
104 | \fImust\fR be primitive; if not, the call will fail and NULL will be
105 | returned.
106 | 
107 | \fBfcr\fR gives, in index form, the first consecutive root of the
108 | Reed Solomon code generator polynomial.
109 | 
110 | \fBprim\fR gives, in index form, the primitive element in the Galois field
111 | used to generate the Reed Solomon code generator polynomial.
112 | 
113 | \fBnroots\fR gives the number of roots in the Reed Solomon code
114 | generator polynomial. This equals the number of parity symbols
115 | per code block.
116 | 
117 | \fBpad\fR gives the number of leading symbols in the codeword
118 | that are implicitly padded to zero in a shortened code block. 
119 | 
120 | The resulting Reed-Solomon code has parameters (N,K), where
121 | N = 2^\fBsymsize\fR - \fBpad\fR - 1 and K = N-\fBnroots\fR.
122 | 
123 | The \fBpad_rs_char\fR and \fBpad_rs_int\fR functions can modify the
124 | \fBpad\fR specified in the structure returned by a previous call to
125 | \fBinit_rs_char\fR or \fBinit_rs_int\fR, respectively.  Pass the
126 | pointer to the structure, and the new \fBpad\fR.  The modified
127 | structure will be returned (if \fBpad\fR is valid), or NULL will be
128 | returned.
129 | 
130 | The \fBencode_rs_char\fR and \fBencode_rs_int\fR functions accept
131 | the pointer returned by \fBinit_rs_char\fR or
132 | \fBinit_rs_int\fR, respectively, to
133 | encode a block of data using the specified code.
134 | The input data array is expected to
135 | contain K symbols (of \fBsymsize\fR bits each, right justified
136 | in each char or int) and \fBnroots\fR parity symbols will be placed
137 | into the \fBparity\fR array, right justified.
138 | 
139 | The \fBdecode_\fR functions correct
140 | the errors in a Reed-Solomon codeword of N symbols up to the capability of the code.
141 | An optional list of "erased" symbol indices may be given in the \fBeras_pos\fR
142 | array to assist the decoder; this parameter may be NULL if no erasures
143 | are given. The number of erased symbols must be given in the \fBno_eras\fR
144 | parameter.
145 | 
146 | To maximize performance, the encode and decode functions perform no
147 | "sanity checking" of their inputs. Decoder failure may result if
148 | \fBeras_pos\fR contains duplicate entries, and both encoder and
149 | decoder will fail if an input symbol exceeds its allowable range.
150 | (Symbol range overflow cannot occur with the \fB_8\fR or
151 | \fB_ccsds\fR functions,
152 | or with the \fB_char\fR functions when 8-bit symbols are specified.)
153 | 
154 | The decoder corrects the symbols "in place", returning the number
155 | of symbols in error. If the codeword is uncorrectable, -1 is returned
156 | and the data block is unchanged. If \fBeras_pos\fR is non-null, it is
157 | used to return a list of corrected symbol positions, in no particular
158 | order.  This means that the
159 | array passed through this parameter \fImust\fR have at least \fBnroots\fR
160 | elements to prevent a possible buffer overflow.
161 | 
162 | The \fBfree_rs_int\fR and \fBfree_rs_char\fR functions free the internal
163 | space allocated by the \fBinit_rs_int\fR and \fBinit_rs_char\fR functions,
164 | respecitively.
165 | 
166 | The functions \fBencode_rs_8\fR and \fBdecode_rs_8\fR do not have
167 | corresponding \fBinit\fR and \fBfree\fR, nor do they take the
168 | \fBrs\fR argument accepted by the other functions as their parameters
169 | are statically compiled. These functions implement a code
170 | equivalent to calling
171 | 
172 | \fBinit_rs_char\fR(8,0x187,112,11,32,pad);
173 | 
174 | and using the resulting pointer with \fBencode_rs_char\fR and
175 | \fBdecode_rs_char\fR.
176 | 
177 | .SH RETURN VALUES
178 | \fBinit_rs_int\fR and \fBinit_rs_char\fR return a pointer to an internal
179 | control structure that must be passed to the corresponding encode, decode
180 | and free functions. These functions return NULL on error.
181 | 
182 | The \fBdecode_\fR functions return a count of corrected
183 | symbols, or -1 if the block was uncorrectible.
184 | 
185 | .SH AUTHOR
186 | Phil Karn, KA9Q (karn@ka9q.net), based heavily on earlier work by Robert
187 | Morelos-Zaragoza (robert@spectra.eng.hawaii.edu) and Hari Thirumoorthy
188 | (harit@spectra.eng.hawaii.edu). Extra improvements suggested by Detmar
189 | Welz (dwelz@web.de).  Extra test cases by Perry Kundert (perry@hardconsulting.com).
190 | 
191 | .SH COPYRIGHT
192 | Copyright 2002, Phil Karn, KA9Q. May be used under the terms of the
193 | GNU General Public License (GPL).
194 | 
195 | .SH SEE ALSO
196 | CCSDS 101.0-B-5: Telemetry Channel Coding.
197 | http://www.ccsds.org/documents/pdf/CCSDS-101.0-B-5.pdf
198 | 
199 | .SH NOTE
200 | CCSDS chose the "dual basis" symbol representation because it
201 | simplified the implementation of a Reed-Solomon encoder in dedicated
202 | hardware. However, this approach holds no advantages for a software
203 | implementation on a general purpose computer, so use of the dual basis
204 | is recommended only if compatibility with the CCSDS standard is needed,
205 | e.g., to decode data from an existing spacecraft using the CCSDS
206 | standard. If you just want a fast (255,223) RS codec without needing
207 | to interoperate with a CCSDS standard code, use \fBencode_rs_8\fR
208 | and \fBdecode_rs_8\fR.
209 | 
210 | 


--------------------------------------------------------------------------------
/phil-karn/rs.h:
--------------------------------------------------------------------------------
 1 | #ifndef _RS_H
 2 | #define _RS_H
 3 | 
 4 | 
 5 | /* 
 6 |  * When using the 'rs' data structure from "outside" the library, we make all
 7 |  * the "internal" data table pointers generic (and hence inaccessible).
 8 |  * However, we require access to the remainder of the structure.
 9 |  */ 
10 | typedef void data_t;
11 | 
12 | #include <fec/rs-common.h>
13 | #include <fec/fec.h>
14 | 
15 | /* 
16 |  * pad_rs_int
17 |  * pad_rs_char
18 |  * 
19 |  *      Provided by previous versions of Phil's Reed-Solomon library.
20 |  * 
21 |  */
22 | void *pad_rs_char( void *p, int pad );
23 | void *pad_rs_int( void *p, int pad );
24 | 
25 | #endif /* _RS_H */
26 | 
27 | 


--------------------------------------------------------------------------------
/phil-karn/rstest.c:
--------------------------------------------------------------------------------
  1 | /* Test the Reed-Solomon codecs
  2 |  * for various block sizes and with random data and random error patterns
  3 |  *
  4 |  * Copyright 2002 Phil Karn, KA9Q
  5 |  * May be used under the terms of the GNU General Public License (GPL)
  6 |  */
  7 | 
  8 | #include <stdio.h>
  9 | #include <stdlib.h>
 10 | #include <time.h>
 11 | #include <sys/time.h>
 12 | #include "rs.h"
 13 | 
 14 | int exercise_char(void *,int);
 15 | int exercise_int(void *,int);
 16 | int exercise_8(int);
 17 | int exercise_ccsds(int);
 18 | 
 19 | struct {
 20 |   int symsize;
 21 |   int genpoly;
 22 |   int fcs;
 23 |   int prim;
 24 |   int nroots;
 25 |   int ntrials;
 26 | } Tab[] = {
 27 |   {2, 0x7,     1,   1,  1,  100000 },
 28 |   {3, 0xb,     1,   1,  2,  100000 },
 29 |   {4, 0x13,    1,   1,  4,  100000 },
 30 |   {5, 0x25,    1,   1,  6,  100000 },
 31 |   {6, 0x43,    1,   1,  8,  100000 },
 32 |   {7, 0x89,    1,   1, 10,  100000 },
 33 |   {8, 0x11d,   1,   1,  4,   50000 },
 34 |   {8, 0x11d,   1,   1,  8,   50000 },
 35 |   {8, 0x11d,   1,   1, 16,   50000 },
 36 |   {8, 0x11d,   1,   1, 32,   50000 },
 37 |   {8, 0x187,   112,11,  2,   50000 }, /* Duplicates CCSDS codec */
 38 |   {8, 0x187,   112,11,  4,   50000 }, /* Duplicates CCSDS codec */
 39 |   {8, 0x187,   112,11,  8,   25000 }, /* Duplicates CCSDS codec */
 40 |   {8, 0x187,   112,11, 16,   12000 }, /* Duplicates CCSDS codec */
 41 |   {8, 0x187,   112,11, 32,    6000 }, /* Duplicates CCSDS codec */
 42 |   {8, 0x187,   112,11, 64,    3000 }, /* Duplicates CCSDS codec */
 43 |   {9, 0x211,   1,   1, 32,    2000 },
 44 |   {10,0x409,   1,   1, 32,    1500 },
 45 |   {11,0x805,   1,   1, 32,    1000 },
 46 |   {12,0x1053,  1,   1, 32,     500 },
 47 |   {13,0x201b,  1,   1, 32,     250 },
 48 |   {14,0x4443,  1,   1, 32,     125 },
 49 |   {15,0x8003,  1,   1, 32,      60 },
 50 |   {16,0x1100b, 1,   1, 32,      30 },
 51 |   {0, 0, 0, 0, 0},
 52 | };
 53 | 
 54 | inline int millidiff( 
 55 |     struct timeval     	       *tvend,
 56 |     struct timeval     	       *tvbeg )
 57 | {
 58 |     return ( (int)( tvend->tv_sec - tvbeg->tv_sec ) * 1000
 59 | 	     + (int)( tvend->tv_usec )
 60 | 	     - (int)( tvbeg->tv_usec ));
 61 | }
 62 | 
 63 | int main(){
 64 |   void *handle;
 65 |   int errs,terrs;
 66 |   int i;
 67 | 
 68 |   terrs = 0;
 69 |   srandom(time(NULL));
 70 | 
 71 | 
 72 | 
 73 |   printf("Testing fixed (255,223) RS codec...");
 74 |   fflush(stdout);
 75 |   errs = exercise_8(10000);
 76 |   terrs += errs;
 77 |   if(errs == 0){
 78 |     printf("OK\n");
 79 |   }
 80 |   printf("Testing CCSDS standard (255,223) RS codec...");
 81 |   fflush(stdout);
 82 |   errs = exercise_ccsds(10000);
 83 |   terrs += errs;
 84 |   if(errs == 0){
 85 |     printf("OK\n");
 86 |   }
 87 | 
 88 |   for(i=0;Tab[i].symsize != 0;i++){
 89 |     int nn,kk;
 90 | 
 91 |     nn = (1<<Tab[i].symsize) - 1;
 92 |     kk = nn - Tab[i].nroots;
 93 |     printf("Testing (%3d,%3d) RS codec, %2d bits/symbol, genpoly: 0x%08x, fcs: %3d, prim: %3d, nroots: %3d...\n",
 94 | 	   nn,kk,
 95 | 	   Tab[i].symsize, Tab[i].genpoly, Tab[i].fcs, Tab[i].prim, Tab[i].nroots );
 96 |     fflush(stdout);
 97 |     if(Tab[i].symsize <= 8){
 98 |       if((handle = init_rs_char(Tab[i].symsize,Tab[i].genpoly,Tab[i].fcs,Tab[i].prim,Tab[i].nroots,0)) == NULL){
 99 | 	printf("init_rs_char failed!\n");
100 | 	continue;
101 |       }
102 |       errs = exercise_char(handle,Tab[i].ntrials);
103 |     } else {
104 |       if((handle = init_rs_int(Tab[i].symsize,Tab[i].genpoly,Tab[i].fcs,Tab[i].prim,Tab[i].nroots,0)) == NULL){
105 | 	printf("init_rs_int failed!\n");
106 | 	continue;
107 |       }
108 |       errs = exercise_int(handle,Tab[i].ntrials);
109 |     }
110 |     terrs += errs;
111 |     if(errs == 0){
112 |       printf("OK\n");
113 |     }
114 |     free_rs_char(handle);
115 |   }
116 |   if(terrs == 0)
117 |     printf("All codec tests passed!\n");
118 | 
119 |   exit(0);
120 | }
121 | 


--------------------------------------------------------------------------------
/qi_test_1.C:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2010 Peter Schueller
 2 | //
 3 | //  Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | #include <vector>
 7 | #include <istream>
 8 | #include <sstream>
 9 | #include <iostream>
10 | #include <iomanip>
11 | #include <boost/spirit/include/qi.hpp>
12 | #include <boost/spirit/include/support_multi_pass.hpp>
13 | #include <boost/spirit/include/classic_position_iterator.hpp>
14 | 
15 | namespace qi = boost::spirit::qi;
16 | namespace ascii = boost::spirit::ascii;
17 | namespace classic = boost::spirit::classic;
18 | 
19 | // parse list of doubles from input stream
20 | // throw exception (perhaps including filename) on errors
21 | std::vector<double> parse(std::istream& input, const std::string& filename);
22 | 
23 | // main function
24 | int main(int, char**)
25 | {
26 |       try
27 |       {
28 | 	  for ( auto &&r : parse(std::cin, "STDIN"))
29 | 	      std::cout << r << std::endl;
30 |       }
31 |       catch(const std::exception& e)
32 |       {
33 | 	  std::cerr << "Exception: " << e.what() << std::endl;
34 | 	  return -1;
35 |       }
36 |       return 0;
37 | }
38 | 
39 | // implementation
40 | std::vector<double> parse(std::istream& input, const std::string& filename)
41 | {
42 |     // iterate over stream input
43 |     typedef std::istreambuf_iterator<char> base_iterator_type;
44 |     base_iterator_type in_begin(input);
45 | 
46 |     // convert input iterator to forward iterator, usable by spirit parser
47 |     typedef boost::spirit::multi_pass<base_iterator_type> forward_iterator_type;
48 |     forward_iterator_type fwd_begin = boost::spirit::make_default_multi_pass(in_begin);
49 |     forward_iterator_type fwd_end;
50 | 
51 |     // wrap forward iterator with position iterator, to record the position
52 |     typedef classic::position_iterator2<forward_iterator_type> pos_iterator_type;
53 |     pos_iterator_type position_begin(fwd_begin, fwd_end, filename);
54 |     pos_iterator_type position_end;
55 | 
56 |     // prepare output
57 |     std::vector<double> output;
58 | 
59 |     // parse
60 |       try
61 |       {
62 | 	  qi::phrase_parse(
63 | 			   position_begin, position_end,                               // iterators over input
64 | 			   qi::double_ > *(',' > qi::double_) >> qi::eoi,              // recognize list of doubles
65 | 			   ascii::space | '#' >> *(ascii::char_ - qi::eol) >> qi::eol, // comment skipper
66 | 			   output);                                                    // doubles are stored into this object
67 |       }
68 |       catch(const qi::expectation_failure<pos_iterator_type>& e)
69 |       {
70 | 	  const classic::file_position_base<std::string>& pos = e.first.get_position();
71 | 	  std::stringstream msg;
72 | 	  msg <<
73 | 	      "parse error at file " << pos.file <<
74 | 	      " line " << pos.line << " column " << pos.column << std::endl <<
75 | 	      "'" << e.first.get_currentline() << "'" << std::endl <<
76 | 	      std::setw(pos.column) << " " << "^- here";
77 | 	  throw std::runtime_error(msg.str());
78 |       }
79 | 
80 |       // return result
81 |       return output;
82 | }
83 | 


--------------------------------------------------------------------------------
/qi_test_1_bad.txt:
--------------------------------------------------------------------------------
1 | #  Copyright (c) 2010 Peter Schueller
2 | #
3 | #  Distributed under the Boost Software License, Version 1.0. (See accompanying
4 | #  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
5 | 
6 | # bad input
7 | 
8 | 123,42.0,a,1.4
9 | 


--------------------------------------------------------------------------------
/qi_test_1_good.txt:
--------------------------------------------------------------------------------
1 | #  Copyright (c) 2010 Peter Schueller
2 | #
3 | #  Distributed under the Boost Software License, Version 1.0. (See accompanying
4 | #  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
5 | 
6 | # good input
7 | 
8 | 1.3,2.3, 5
9 | 


--------------------------------------------------------------------------------
/qi_test_2.C:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2001-2010 Hartmut Kaiser
 2 | //
 3 | //  Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | // The purpose of this example is to show how to parse arbitrary key/value
 7 | // pairs delimited by some separator into a std::map. Parsing the URL query
 8 | // format is the example we use to demonstrate how this can be done
 9 | // (i.e. things like: key1=value1;key2=value2;...;keyN=valueN).
10 | //
11 | // For a more elaborate explanation see here: http://spirit.sourceforge.net/home/?p=371
12 | 
13 | #include <boost/spirit/include/qi.hpp>
14 | #include <boost/fusion/include/std_pair.hpp>
15 | 
16 | #include <iostream>
17 | #include <map>
18 | 
19 | namespace client
20 | {
21 |     namespace qi = boost::spirit::qi;
22 | 
23 |     typedef std::map<std::string, std::string> pairs_type;
24 | 
25 |     template <typename Iterator>
26 |         struct key_value_sequence
27 | 	: qi::grammar<Iterator, pairs_type()>
28 |     {
29 | 	key_value_sequence()
30 | 	    : key_value_sequence::base_type(query)
31 | 	{
32 | 	    query =  pair >> *((qi::lit(';') | '&') >> pair);
33 | 	    pair  =  key >> -('=' >> value);
34 | 	    key   =  qi::char_("a-zA-Z_") >> *qi::char_("a-zA-Z_0-9");
35 | 	    value = +qi::char_("a-zA-Z_0-9");
36 | 	}
37 | 
38 | 	qi::rule<Iterator, pairs_type()> query;
39 | 	qi::rule<Iterator, std::pair<std::string, std::string>()> pair;
40 | 	qi::rule<Iterator, std::string()> key, value;
41 |     };
42 | }
43 | 
44 | ///////////////////////////////////////////////////////////////////////////////
45 | int main()
46 | {
47 |     namespace qi = boost::spirit::qi;
48 | 
49 |     std::string input("key1=value1;key2;key3=value3");
50 |     std::string::iterator begin = input.begin();
51 |     std::string::iterator end = input.end();
52 | 
53 |     client::key_value_sequence<std::string::iterator> p;
54 |     client::pairs_type m;
55 | 
56 |     if (!qi::parse(begin, end, p, m))
57 |     {
58 | 	std::cout << "-------------------------------- \n";
59 | 	std::cout << "Parsing failed\n";
60 | 	std::cout << "-------------------------------- \n";
61 |     }
62 |     else
63 |     {
64 | 	std::cout << "-------------------------------- \n";
65 | 	std::cout << "Parsing succeeded, found entries:\n";
66 | 	client::pairs_type::iterator end = m.end();
67 | 	for (client::pairs_type::iterator it = m.begin(); it != end; ++it)
68 | 	{
69 | 	    std::cout << (*it).first;
70 | 	    if (!(*it).second.empty())
71 | 		std::cout << "=" << (*it).second;
72 | 	    std::cout << std::endl;
73 | 	}
74 | 	std::cout << "---------------------------------\n";
75 |     }
76 |     return 0;
77 | }
78 | 


--------------------------------------------------------------------------------
/rsembedded.C:
--------------------------------------------------------------------------------
 1 | // 
 2 | // rsembedded.C
 3 | // 
 4 | //     Example of using ezpwd/rs in an embedded environment.  Such environments often have certain
 5 | // constraints:
 6 | // 
 7 | //   o No exception support
 8 | //   o Limited memory
 9 | // 
10 | //     Therefore, no STL containers with dynamic allocation may be used, and -fno-exceptions may be
11 | // specified if EZPWD_NO_EXCEPTS is defined.
12 | //
13 | #include <cstdio>
14 | #include <cctype>
15 | #include <array>
16 | 
17 | #include <ezpwd/rs>
18 | #include <ezpwd/output>
19 | 
20 | int main()
21 | {
22 |     int				failures= 0;
23 |     ezpwd::RS<255,253>		rs;
24 | 
25 |     // Use of fixed-size container
26 |     std::fputs( "\n\nFixed-size container:\n", stdout );
27 |     std::array<uint8_t,15>	raw = { 'H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!', 'x', 'x' }; // working data, w/ space for parity
28 |     std::fputs( "Original:  ", stdout ); ezpwd::hexout( raw.begin(), raw.end(), stdout ); fputc( '\n', stdout );
29 |     rs.encode( raw );				// 13 symbols data + 2 symbols R-S parity added
30 |     std::fputs( "Encoded:   ", stdout ); ezpwd::hexout( raw.begin(), raw.end(), stdout ); fputc( '\n', stdout );
31 |     raw[3]				= 'x';	// Corrupt one symbol
32 |     std::fputs( "Corrupted: ", stdout ); ezpwd::hexout( raw.begin(), raw.end(), stdout ); fputc( '\n', stdout );
33 |     int				count	= rs.decode( raw );  // Correct any symbols possible
34 |     if ( count != 1 )
35 |         failures		       += 1;
36 |     std::fputs( "Corrected: ", stdout ); ezpwd::hexout( raw.begin(), raw.end(), stdout );
37 |     std::fputs( " : ", stdout ); std::fputc( '0'+count, stdout );
38 |     std::fputs( " errors fixed", stdout ); fputc( '\n', stdout );
39 |     // Ensure original data is recovered (ignoring parity)
40 |     for ( auto i = 0UL; i < raw.size() - 2; ++i ) {
41 |         if ( raw[i] != "Hello, world!"[i] ) {
42 | 	    failures		       += 1;
43 | 	    std::fputs( "Failed to restore origin data.\n", stdout );
44 | 	    break;
45 | 	}
46 |     }
47 | 
48 |     return failures ? 1 : 0;
49 | }
50 | 


--------------------------------------------------------------------------------
/rsencode.C:
--------------------------------------------------------------------------------
  1 | // 
  2 | // rsencode.C
  3 | // 
  4 | //     Example of using ezpwd/rs to Reed-Solomon encode a file, in chunks.  If 32 bytes of parity is
  5 | // selected, then the RS(255,255-32) == RS(255,223) codec would be used.  If an RS(511,...) or
  6 | // larger R-S codec is used (implying 9-bit or larger symbol size), then multiple bytes will be
  7 | // used 
  8 | // 
  9 | // SYNOPSIS
 10 | // 
 11 | //     rsencode [<output> [<input>]]
 12 | // 
 13 | //     Read <input> (stdin by default), R-S encode, and write to <output> (stdout by default).  Will
 14 | // not work, if the same file is 
 15 | // 
 16 | // EXAMPLES
 17 | //     rsencode - # stdin-->stdout: 32 bytes parity, w/128-byte chunks
 18 | // 
 19 | // NOTE
 20 | //     Set RSDECODE C++ preprocessor symbol to "decode", instead of "encode" data.
 21 | // 
 22 | #include <string>
 23 | #include <iostream>
 24 | #include <fstream>
 25 | #include <memory>
 26 | #include <vector>
 27 | 
 28 | #include <ezpwd/rs>
 29 | #include <ezpwd/output>
 30 | 
 31 | // Choose Reed-Solomon codeword capacity (and symbol bits), parity and default chunk size The
 32 | // CODEWORD and PARITY are fixed compile-time constants, but the chunk size (the number of symbols
 33 | // of data protected by the parity) can be changed at run-time.
 34 | #if ! defined( RSCODEWORD )
 35 | #  define RSCODEWORD 255
 36 | #endif
 37 | #if ! defined( RSPARITY )
 38 | #  define RSPARITY 32
 39 | #endif
 40 | #if ! defined( RSCHUNK )
 41 | #  define RSCHUNK 128
 42 | #endif
 43 | 
 44 | // 
 45 | // serialize	-- convert data symbols to N*(sizeof symbol_t()) string of chars
 46 | // deserialize	-- convert chunk string to N/(sizeof symbol_t()) symbols
 47 | // 
 48 | //     Big-endian (most significant bits are output first), supports arbitrary sized symbol_t
 49 | // (likely only 2 bytes).  Provide a specialization (not typically recommended practice for function
 50 | // templates) to avoid warnings on some compilers for <unsigned char> << 8.
 51 | // 
 52 | template < typename symbol_t >
 53 | std::string			serialize(
 54 | 				    const std::vector<symbol_t>
 55 | 						       &data )
 56 | {
 57 |     std::string			chunk( data.size() * sizeof symbol_t(), char( 0 ));
 58 |     for ( size_t s = 0; s < data.size(); ++s ) {
 59 | 	for ( size_t b = 0; b < sizeof symbol_t(); ++b ) {
 60 | 	    chunk[s * sizeof symbol_t() + b]
 61 | 					= uint8_t(( data[s] >> ( sizeof symbol_t() - 1 - b ) * 8 ) & 0xff );
 62 | 	}
 63 |     }
 64 |     return chunk;
 65 | }
 66 | 
 67 | template < typename symbol_t >
 68 | std::vector<symbol_t>		deserialize(
 69 | 				    const std::string  &chunk )
 70 | {
 71 |     std::vector<symbol_t>	data( chunk.size() / sizeof symbol_t() );
 72 |     for ( size_t s = 0; s < data.size(); ++s ) {
 73 | 	for ( size_t b = 0; b < sizeof symbol_t(); ++b ) {
 74 | 	    data[s]		      <<= 8;		// NO-OP on first loop (zero)
 75 | 	    data[s]		       |= uint8_t( chunk[s * sizeof symbol_t() + b] );
 76 | 	}
 77 |     }
 78 |     return data;
 79 | }
 80 | template <>
 81 | std::vector<unsigned char>	deserialize<unsigned char>(
 82 | 				    const std::string  &chunk )
 83 | {
 84 |     return std::vector<unsigned char>( chunk.begin(), chunk.end() );
 85 | }
 86 | 
 87 | // 
 88 | // encode
 89 | // decode
 90 | // 
 91 | //     Read a chunk of input and process, returning the processed chunk for future use.
 92 | // 
 93 | template<typename RS_t>
 94 | std::string		       &encode(
 95 | 				    RS_t	       &rs, // R-S codec, and its capacity, parity
 96 | 				    std::istream       &inp,
 97 | 				    size_t	       &inptotal,
 98 | 				    std::string	       &chunk,
 99 | 				    size_t		chunksize )
100 | {
101 |     typedef typename RS_t::symbol_t symbol_t;
102 | 
103 |     // R-S Encode.  Read up to chunksize (or to EOF) symbols worth of data
104 |     chunk.resize( chunksize * sizeof symbol_t() );
105 |     inp.read( &chunk.front(), chunksize * sizeof symbol_t() );
106 |     chunk.resize( inp.gcount() );
107 |     inptotal			       += inp.gcount();
108 | 
109 |     // Make sure either 0 (EOF at start of input) or an even symbol's worth of data was read.
110 |     if ( chunk.size() == 0 )
111 | 	return chunk;
112 |     if ( chunk.size() % sizeof symbol_t() )
113 | 	throw std::logic_error( std::string() << "Insufficient data for an " << rs << " encoded chunk" );
114 | 
115 |     // R-S encode (adds rs.NROOTS R-S parity symbols to chunk)
116 |     if ( sizeof symbol_t() == 1 )// <= 8-bit symbols.  Encodes in-place
117 | 	rs.encode( chunk );
118 |     else {			// >= 16-bit symbols.  Deserialize to symbols, encode, re-serialize
119 | 	auto		data	= deserialize<symbol_t>( chunk );
120 | 	rs.encode( data );
121 | 	chunk			= serialize<symbol_t>( data );
122 |     }
123 |     return chunk;
124 | }
125 | 
126 | template <typename RS_t>
127 | std::string		       &decode(
128 | 				    RS_t	       &rs,
129 | 				    std::istream       &inp,
130 | 				    size_t	       &inptotal,
131 | 				    std::string	       &chunk,
132 | 				    size_t		chunksize )
133 | {
134 |     typedef typename RS_t::symbol_t symbol_t;
135 | 
136 |     // R-S Decode.  Read up to chunk + parity (or to EOF) symbols of data
137 |     chunk.resize( ( chunksize+rs.NROOTS ) * sizeof symbol_t() );
138 |     inp.read( &chunk.front(), ( chunksize+rs.NROOTS ) * sizeof symbol_t() );
139 |     chunk.resize( inp.gcount() );
140 |     inptotal			       += inp.gcount();
141 | 
142 |     // Make sure either 0 (EOF at start of input) or an even symbol's worth of data was read.
143 |     if ( chunk.size() == 0 )
144 | 	return chunk;
145 |     if ( chunk.size() < ( rs.NROOTS + 1 ) * sizeof symbol_t() || chunk.size() % sizeof symbol_t() )
146 | 	throw std::logic_error( std::string() << "Insufficient data for an " << rs << " encoded chunk" );
147 | 
148 |     // R-S decode (raises std::exception on R-S decode failure), then remove parity
149 |     if ( rs.SYMBOL <= 8 )
150 |     // <= 8-bit symbols.  Correct in-place (leaves parity)
151 | 	rs.decode( chunk );
152 |     else {
153 | 	// >= 9-bit symbols.  Deserialize to symbols, correct, and re-serialize for output.
154 | 	auto			data	= deserialize<symbol_t>( chunk );
155 | 	// if errors corrected, serialize corrected symbols back into chunk
156 | 	if ( rs.decode( data ))
157 | 	    chunk			= serialize<symbol_t>( data );
158 |     }
159 | 
160 |     // RS_t::decode never discards parity, caller must do so.
161 |     chunk.resize( chunk.size() - rs.NROOTS * sizeof symbol_t() );
162 |     return chunk;
163 | }
164 | 
165 | int main( int argc, const char **argv )
166 | {
167 |     constexpr size_t		codeword= RSCODEWORD;	// R-S codeword size (always 2^N-1)
168 |     constexpr size_t		parity	= RSPARITY;	// symbols of parity
169 |     size_t			chunksize= RSCHUNK;	// symbols of data chunk (up to codeword-parity)
170 |     typedef ezpwd::RS<codeword,codeword-parity> \
171 | 				RS_t;
172 |     RS_t			rs;			// eg; paritysize of 32 ==> RS<255,223>
173 | 
174 |     size_t			inptotal = 0;
175 |     bool			encoding = true;
176 | 
177 |     try {
178 | 	// Pre-process and discard the initial (executable path) argument, and any '-...' options.
179 | 	while ( --argc && **++argv == '-' ) {
180 | 	    if ( argv[0][1] == '\0' )			// bare "-"
181 | 		break;
182 | 	    if ( !strcmp( *argv, "-d" ) || !strcmp( *argv, "--decode" )) {
183 | 		encoding		= false;
184 | 	    } else if ( !strcmp( *argv, "-e" ) || !strcmp( *argv, "--encode" )) {
185 | 		encoding		= true;
186 | 	    } else if ( !strcmp( *argv, "-c" ) || !strcmp( *argv, "--chunk" )) {
187 | 		if ( --argc <= 0 )
188 | 		    throw std::logic_error( std::string() << *argv << " missing value" );
189 | 		size_t		end;
190 | 		int		val	= std::stoi( *++argv, &end );
191 | 		if ( (*argv)[end] || val <= 0 )
192 | 		    throw std::logic_error( std::string() << "garbage after chunk size: " << val <<", or bad value: " << *argv );
193 | 		chunksize		= val;
194 | 	    } else {
195 | 		throw std::logic_error(
196 | 		    std::string() << "Invalid option: " << *argv << "\n"
197 | 		    << "    -e|--encode   -- R-S encode, adding parity (default)" << "\n"
198 | 		    << "    -d|--decide   -- R-S decode, correcting errors and removing parity" << "\n"
199 | 		    << "    -c|--chunk    -- set data symbol chunks; default: " << chunksize << "\n" );
200 | 	    }
201 | 	}
202 | 
203 | 	// Set 'inp' to std::cin, or a newly opened file (which will be released at end of scope)
204 | 	std::unique_ptr<std::ifstream>
205 | 				inpfile;
206 | 	if ( argc > 0 and strcmp( argv[0], "-" )) {
207 | 	    inpfile.reset( new std::ifstream( argv[1], std::ifstream::binary ));
208 | 	}
209 | 	std::istream	       &inp( inpfile ? *inpfile : std::cin );
210 | 
211 | 	// Set 'out' to std::cout, or a newly removed and opened file (also release at end of scope)
212 | 	std::unique_ptr<std::ofstream>
213 | 				outfile;
214 | 	if ( argc > 1 and strcmp( argv[1], "-" )) {
215 | 	    std::remove( argv[2] );
216 | 	    outfile.reset( new std::ofstream( argv[2], std::ifstream::binary ));
217 | 	}
218 | 	std::ostream	       &out( outfile ? *outfile : std::cout );
219 | 
220 | 	// Read, R-S encode/decode and write chunks
221 | 	std::string		chunk;
222 | 	while ( inp ) {					// 'til error/eof
223 | 	    out << ( encoding ? encode<RS_t> : decode<RS_t> )( rs, inp, inptotal, chunk, chunksize );
224 | 	    // std::cerr << "Read: " << inptotal << ", wrote: " << chunk.size() << " bytes." << std::endl;
225 | 	}
226 |     } catch ( std::exception &exc ) {
227 | 	std::cerr << "Error after " << inptotal << " bytes: " << exc.what() << std::endl;
228 | 	return 1;
229 |     }
230 |     return 0;
231 | }
232 | 


--------------------------------------------------------------------------------
/rsexample.C:
--------------------------------------------------------------------------------
 1 | // 
 2 | // rsexample.C -- Illustrate the use of the R-S codec and ezpwd::corrector APIs
 3 | // 
 4 | //     There are cases where we may have to guess how many symbols have R-S symbols been provided.
 5 | // Such is the case when we know how many R-S parity symbols are to be provided, but it is unknown
 6 | // how long the protected non-parity data is, nor how many of the parity symbols have been supplied.
 7 | // 
 8 | //     We can guess, and return an estimated likelihood that the supplied data is correct.  This is
 9 | // what ezpwd::corrector does.  Instantiate it with the known number of R-S parity symbols, and it
10 | // will evaluate the supplied codeword, performing R-S decodes with varying guesses of data and
11 | // parity symbols, returning the most likely candidate data, with an estimate of its probability of
12 | // correctness.
13 | // 
14 | #include <time.h>
15 | 
16 | #include <iostream>
17 | 
18 | #include <ezpwd/rs>
19 | #include <ezpwd/corrector>
20 | #include <ezpwd/output>
21 | 
22 | #include <ezpwd/definitions>	// must be included in one C++ compilation unit
23 | 
24 | #ifndef NROOTS
25 | #define NROOTS 3
26 | #endif
27 | 
28 | int main()
29 | {
30 |     std::string			ori	= "ba5!l";
31 |     std::cout << "Original: " << ezpwd::hexstr( ori ) << std::endl;
32 | 
33 |     ezpwd::RS<255,255-NROOTS>	rs;
34 |     for ( size_t errpos = 0; errpos < ori.size() + NROOTS + 1; ++errpos ) {
35 | 	std::cout << "Raw Reed-Solomon codec:" << std::endl;
36 | 	std::string		enc	= ori;
37 | 	rs.encode( enc );
38 | 	std::cout << "Encoded:  " << ezpwd::hexstr( enc ) << std::endl;
39 | 	std::string		err	= enc;
40 | 	if ( errpos < err.size() ) {
41 | 	    err[errpos]		       ^= 0x15; // simulated mistyped character
42 | 	    std::cout << "Mistyped: " << ezpwd::hexstr( err ) << std::endl;
43 | 	} else
44 | 	    std::cout << "Mistyped: (no)" << std::endl;
45 | 
46 | 	std::string		dec	= err;
47 | 	rs.decode( dec );
48 | 	std::cout << "Decoded:  " << ezpwd::hexstr( dec ) << std::endl;
49 | 
50 | 	std::cout << "Statistical corrector:" << std::endl;
51 | 	enc					= ori;
52 | 	ezpwd::corrector<NROOTS>::encode( enc );
53 | 	std::cout << "Encoded:  " << ezpwd::hexstr( enc ) << std::endl;
54 | 	err				= enc;
55 | 	if ( errpos < err.size() ) {
56 | 	    err[errpos]		       ^= 0x15; // simulated mistyped character
57 | 	    std::cout << "Mistyped: " << ezpwd::hexstr( err ) << std::endl;
58 | 	} else
59 | 	    std::cout << "Mistyped: (no)" << std::endl;
60 | 	for ( size_t len = 1; len <= err.size(); ++len ) {
61 | 	    std::string		sub	= err.substr( 0, len );
62 | 	    std::string		cor	= sub;
63 | 	    int			confid	= ezpwd::corrector<NROOTS>::decode( cor );
64 | 	    std::string		dsp	= cor;
65 | 
66 | 	    ezpwd::corrector<NROOTS>::encode( dsp );
67 | 	    if ( confid > 0 ) {
68 | 		//dsp.insert( 0, "\xE2\x98\x91 " );  // ballot check
69 | 		dsp.insert( 0, "\xE2\x9C\x94 " );  // heavy check
70 | 	    } else {
71 | 		//dsp.insert( 0, "\xE2\x98\x90 " ); // ballot x
72 | 		dsp.insert( 0, "\xE2\x9C\x98 " ); // heavy X
73 | 	    }
74 | 	    dsp.insert( dsp.size() - 3, " (" ) += ')';
75 | 	    std::cout
76 | 		<< "Correct:  " << ezpwd::hexstr( sub ) 
77 | 		<< std::setw( enc.size() > sub.size()
78 | 			      ? 2 * ( enc.size() - sub.size() )
79 | 			      : 0 ) << ""
80 | 		<< " ==> " << ezpwd::hexstr( cor )
81 | 		<< std::setw( enc.size() > cor.size()
82 | 			      ? 2 * ( enc.size() - cor.size() )
83 | 			      : 0 ) << ""
84 | 		<< " w/ confidence " << std::setw( 3 )  << confid << "%"
85 | 		<< " shows: " << dsp
86 | 		<< std::endl;
87 | 	}
88 |     }
89 | 
90 | }
91 | 


--------------------------------------------------------------------------------
/rsexercise.C:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <iostream>
 3 | #include <iomanip>
 4 | #include <cctype>
 5 | #include <cstring>
 6 | #include <array>
 7 | #include <vector>
 8 | 
 9 | #include <ezpwd/rs>
10 | 
11 | #include <ezpwd/definitions>	// must be included in one C++ compilation unit
12 | 
13 | #include "exercise.H"
14 | 
15 | int main() 
16 | {
17 |     exercise( ezpwd::RS<255,255-2>(), 100 );
18 |     exercise( ezpwd::RS<255,255-4>(), 100 );
19 |     exercise( ezpwd::RS<255,255-5>(), 100 );
20 |     exercise( ezpwd::RS<255,255-8>(), 100 );
21 |     exercise( ezpwd::RS<255,255-16>(), 100 );
22 |     exercise( ezpwd::RS<255,255-32>(), 100 );
23 |     exercise( ezpwd::RS_CCSDS<255,255-32>(), 100 );
24 |     exercise( ezpwd::RS_CCSDS_CONV<255,255-32>(), 100 );
25 |     exercise( ezpwd::RS<511,511-32>(), 10 );
26 |     exercise( ezpwd::RS<1023,1023-32>(), 10 );
27 |     exercise( ezpwd::RS<65535,65535-32>(), 2 );
28 |     exercise( ezpwd::RS<65535,65535-256>(), 2 );
29 | }
30 | 


--------------------------------------------------------------------------------
/rskey.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EZPWD_RSKEY_H
 2 | #define _EZPWD_RSKEY_H
 3 | 
 4 | #if defined( __cplusplus )
 5 | extern "C" {
 6 | #endif
 7 | 
 8 |     // ABCDE-FG
 9 |     int rskey_2_encode( size_t rawsiz, char *buf, size_t buflen, size_t bufsiz, size_t sep );
10 |     int rskey_2_decode( size_t rawsiz, char *buf, size_t buflen, size_t bufsiz );
11 | 
12 |     // ABCDE-FGH
13 |     int rskey_3_encode( size_t rawsiz, char *buf, size_t buflen, size_t bufsiz, size_t sep );
14 |     int rskey_3_decode( size_t rawsiz, char *buf, size_t buflen, size_t bufsiz );
15 | 
16 |     // ABCDE-FGH1
17 |     int rskey_4_encode( size_t rawsiz, char *buf, size_t buflen, size_t bufsiz, size_t sep );
18 |     int rskey_4_decode( size_t rawsiz, char *buf, size_t buflen, size_t bufsiz );
19 | 
20 |     // ABCDE-FGH1K
21 |     int rskey_5_encode( size_t rawsiz, char *buf, size_t buflen, size_t bufsiz, size_t sep );
22 |     int rskey_5_decode( size_t rawsiz, char *buf, size_t buflen, size_t bufsiz );
23 | 
24 | 
25 | #if defined( __cplusplus )
26 | } // extern "C"
27 | #endif
28 | 
29 | #endif // _EZPWD_RSKEY_H
30 | 


--------------------------------------------------------------------------------
/rskey_node.js:
--------------------------------------------------------------------------------
  1 | 
  2 | /*
  3 |  * rskey_node.js -- Demonstrate use of rskey in Node.js application
  4 |  * 
  5 |  *     Node.js "crypto" uses the Buffer type to manipulate binary data.  The
  6 |  * rskey library uses ArrayBuffer, because it is intended to be used in both
  7 |  * Node.js and Browser Javascript applications.
  8 |  * 
  9 |  *    The server will expect an Object containing (at least) card.id and
 10 |  * card.customer.id, and produce/consume card.keydata.
 11 |  * 
 12 |  */
 13 | var crypto		= require( "crypto" );
 14 | var crypto_algo		= 'blowfish'; // 64-bit block cipher
 15 | var crypto_secret	= 'not.here'; // Super secret master key; don't keep in Git...
 16 | 
 17 | var server = {
 18 |     //
 19 |     // card_keydata_encode -- Encipher card IDs into card.keydata Array
 20 |     // card_keydata_decode -- Decipher card IDs from card.keydata Array
 21 |     // 
 22 |     //     Run these on your server (of course, keeping crypto_secret... secret.)
 23 |     // 
 24 |     card_keydata_encode: function( card ) {
 25 |         // Create Buffer containing raw card ID data
 26 |         var buf		= new Buffer( 8 );
 27 |         buf.writeUInt32LE( card.customer.id,	0 );
 28 |         buf.writeUInt32LE( card.id,		4 );
 29 | 
 30 |         // Encrypt the Buffer of keydata
 31 |         var encipher	= crypto.createCipher( crypto_algo, crypto_secret );
 32 |         encipher.setAutoPadding( false ); // must use exact 64-bit blocks
 33 |         var enc		= Buffer.concat([ 
 34 |             encipher.update( buf ),
 35 |             encipher.final()
 36 |         ]);
 37 | 
 38 |         // Return card w/ encrypted IDs as plain Javascript Array in .keydata
 39 |         card.keydata	= enc.toJSON().data; // {type: 'Buffer', data: [1,2,...]}
 40 |         return card;
 41 |     },
 42 | 
 43 |     card_keydata_decode: function( card ) {
 44 |         if ( card.keydata.length != 8 )
 45 |             throw "Expected 8 bytes of card.keydata, got: " + card.keydata.length;
 46 | 
 47 |         // Decrypt the Buffer of keydata
 48 |         var decipher	= crypto.createDecipher( crypto_algo, crypto_secret );
 49 |         decipher.setAutoPadding( false ); // must use exact 64-bit blocks
 50 |         var dec		= Buffer.concat([
 51 |             decipher.update( new Buffer( card.keydata )),
 52 |             decipher.final()
 53 |         ]);
 54 | 
 55 |         // Recover raw card IDs from Buffer
 56 |         if ( card.customer == undefined )
 57 |             card.customer = {};
 58 |         card.customer.id= dec.readUInt32LE( 0 );
 59 |         card.id		= dec.readUInt32LE( 4 );
 60 |         return card;
 61 |     }
 62 | };
 63 | 
 64 | /*
 65 |  * In the client web browser, you'd use:
 66 |  * 
 67 |  *     <script
 68 |  *       src="//cdn.rawgit.com/pjkundert/ezpwd-reed-solomon/v1.7.0/js/ezpwd/rskey.js">
 69 |  *     </script>
 70 |  * 
 71 |  * Here in this Node.js demo, we'll require(...) the module
 72 |  */
 73 | var rskey		= require( './js/ezpwd/rskey.js' );
 74 | 
 75 | var client = {
 76 |     // 
 77 |     // card_key_encode( card ) -- encrypt card's IDs on the server, return RSKEY
 78 |     // card_key_decode( key )  -- recover RSKEY, decrypt IDs on server, return card
 79 |     // 
 80 |     //     These are run in the browser, and expect to call server methods that
 81 |     // run under Node.js back on the server.  For this demo, we'll all just run
 82 |     // here in Node.js...
 83 |     // 
 84 |     card_key_encode: function( card ) {
 85 |         // Get the server to encrypt the card IDs
 86 |         server.card_keydata_encode( card );
 87 |         // Produce the RSKEY from the card's keydata w/ Uint8Array's ArrayBuffer
 88 |         card.key = rskey_3_encode( 8, new Uint8Array( card.keydata ).buffer, 4 );
 89 |         return card.key;
 90 |     },
 91 | 
 92 |     card_key_decode: function( key ) {
 93 |         // Decode the ASCII key; will raise an Exception if decode fails
 94 |         var keyinfo = rskey_3_decode( 8, key );
 95 | 
 96 |         // Convert ArrayBuffer (as Uint8Array) to plain javascript Array
 97 |         var keyuint8 = new Uint8Array( keyinfo.data );
 98 |         var keydata = Array( 8 );
 99 |         for ( var i = 0; i < 8; ++i )
100 |             keydata[i]	= keyuint8[i];
101 | 
102 |         // Get the server to decrypt the card.keydata, return the card IDs
103 |         return server.card_keydata_decode({ keydata: keydata });
104 |     }
105 | }
106 | 
107 | 
108 | /*
109 |  * Test the demo interface
110 |  */
111 | card0 = {
112 |     customer: {
113 |         id: 0
114 |     },
115 |     id: 0,
116 | };
117 | client.card_key_encode( card0 );
118 | console.log( card0 );
119 | 
120 | 
121 | card0_dec		= client.card_key_decode( 'X'+card0.key.slice( 1 ));
122 | console.log( "1 Error:  ", card0_dec );
123 | 
124 | cardE_dec 		= client.card_key_decode( "psxi tpv8 snfp zm7g" );
125 | console.log( "Example:  ", cardE_dec );
126 | 
127 | try {
128 |     client.card_key_decode( 'XX'+card0.key.slice(2));
129 | } catch ( exc ) {
130 |     console.log( "2 Errors: ", exc );
131 | }
132 | 
133 | cardX_dec		= client.card_key_decode( "4g8j 48al ad9S zx8v" );
134 | console.log( "Another: ", cardX_dec );
135 | 


--------------------------------------------------------------------------------
/rskey_wrap.js:
--------------------------------------------------------------------------------
  1 | //
  2 | // Ezpwd Reed-Solomon -- Reed-Solomon encoder / decoder library
  3 | // 
  4 | // Copyright (c) 2014, Hard Consulting Corporation.
  5 | //
  6 | // Ezpwd Reed-Solomon is free software: you can redistribute it and/or modify it under the terms of
  7 | // the GNU General Public License as published by the Free Software Foundation, either version 3 of
  8 | // the License, or (at your option) any later version.  See the LICENSE file at the top of the
  9 | // source tree.  Ezpwd Reed-Solomon is also available under Commercial license.  c++/ezpwd/rs_base
 10 | // is redistributed under the terms of the LGPL, regardless of the overall licensing terms.
 11 | // 
 12 | // Ezpwd Reed-Solomon is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 13 | // without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
 14 | // the GNU General Public License for more details.
 15 | //
 16 | 
 17 | // 
 18 | // string_to_heapi8	-- allocate buffer of (at least) len of type (eg. i8), initializing from str
 19 | // heapi8_to_string	-- decode a JS string from the buffer, til NUL
 20 | // array_to_heap	-- allocate an array of max( arr.length, len ) elements of type typ
 21 | // index_in_heap	-- return pointer to index ptr[idx] in an array of type typ
 22 | // 
 23 | //     The returned buffer may be longer than the C representation of UTF-8 str, but won't be
 24 | // shorter, and will be NUL terminated.  Account for size of native type in all heap allocations and
 25 | // indexing.
 26 | // 
 27 | function string_to_heapi8( str, len ) {
 28 |     var			arr	= intArrayFromString( str ); // will NUL terminate
 29 |     if ( len && arr.length < len )
 30 |         arr.length		= len;
 31 |     return allocate( arr, 'i8', ALLOC_NORMAL );
 32 | }
 33 | 
 34 | function heapi8_to_string( ptr, len ) {
 35 |     return Pointer_stringify( ptr );
 36 | };
 37 | 
 38 | function array_to_heap( typ, arr, len ) {
 39 |     if ( len && arr.length / Runtime.getNativeTypeSize( typ ) < len )
 40 |         arr.length		= len * Runtime.getNativeTypeSize( typ );
 41 |     return allocate( arr, typ, ALLOC_NORMAL );
 42 | }
 43 | 
 44 | function index_in_heap( typ, ptr, idx ) {
 45 |     return ptr + idx * Runtime.getNativeTypeSize( typ );
 46 | }
 47 | 
 48 | // 
 49 | // rskey_<PARITY>_encode -- encodes 'rawsiz' data bytes (String or ArrayBuffer) to an RSKEY w/ PARITY
 50 | // rskey_<PARITY>_decode -- decodes 'rawsiz' data bytes from an RSKEY w/ PARITY, returning confidence
 51 | // 
 52 | // rskey_<PARITY>_encode( rawsiz, data, sep ) --> <string>
 53 | // 
 54 | //     Encoding raw string/ArrayBuffer data returns the RSKEY-encoded string, encoding exactly
 55 | // 'rawsiz' bytes of data, resuling in ((( rawsiz * 8 + 4 ) / 5 ) + PARITY ) base-32 symbols.  If
 56 | // the provided data string starts with "0x", then it is decoded as a hex string; otherwise it is
 57 | // decoded as utf-8 text.
 58 | // 
 59 | // rskey_<PARITY>_decode( rawsiz, key ) --> {
 60 | //     confidence: <int>, data: <ArrayBuffer>, utf8: <string>, hex: <string>
 61 | // }
 62 | // 
 63 | //     Decoding an RSKEY-encoded string returns an Object with properties:
 64 | // 
 65 | // confidence	-- Percentage [0,100] of parity symbols in excess, after error/erasure correction
 66 | // data		-- An <ArrayBuffer> containing the recovered data, w/ .length == rawsiz
 67 | // hex		-- The hex string representation of the data, in the form: 0x01...
 68 | // utf8		-- The UTF-8 decoded representation of the data (undefined if decoding fails)
 69 | // 
 70 | rskey_N_encode_wrap = function( func_name ) {
 71 |     var func			= Module.cwrap( func_name, 'number',
 72 |                                                 ['number'	// rawsiz
 73 |                                                  ,'number'	// buf (array, allocated here)
 74 |                                                  ,'number'	// buflen (supplied raw data, <= rawsiz)
 75 |                                                  ,'number'	// bufsiz (buffer capacity)
 76 |                                                  ,'number'] );	// sep (output a '-' every n'th symbol)
 77 |     return function( rawsiz, data, sep ) {
 78 |         if ( typeof sep == 'undefined' )
 79 |             sep			= 5;
 80 |         var 		len	= 1024; // room for error message, spaces, etc.
 81 |         var		res	= -1;
 82 |         var		str	= func_name + " invocation failed.";
 83 |         // Allocate buf at least 'len' bytes for return of key data+parity, or error.  The Array
 84 |         // must have length <= rawsiz.
 85 | 	if ( typeof data == 'string' ) {
 86 |             // A string of binary data to an int Array (do "0x..." here)
 87 |             var		arr	= [];
 88 |             var		hex	= data.match( /^0x([0-9a-fA-F]{2})*/ );
 89 |             if ( hex ) {
 90 |                 // hex[0] == 0x001122...FF
 91 |                 pairs		= hex[0].slice(2).match( /([0-9a-zA-Z]{2})/g )
 92 |                 if ( pairs )
 93 |                     // ['01', 'AB', ...]
 94 |                     arr		= pairs.map( function( n ) { return parseInt( n, 16 ); } );
 95 |             } else {
 96 |             	arr		= intArrayFromString( data );
 97 |                 arr.length     -= 1; // don't include trailing NUL
 98 |             }
 99 |         } else if ( data instanceof ArrayBuffer ) {
100 |             // Convert the ArrayBuffer bytes to an int Array.
101 |             var		u8arr	= new Uint8Array( data );
102 |             var		arr	= Array.prototype.slice.call( u8arr );
103 |         } else 
104 |             throw "Unsupported buf; must be string or ArrayBuffer"
105 | 
106 |         // Extend the int Array to the target 'len', to support return of error message.
107 |         var buflen		= arr.length;
108 |         if ( arr.length < len )
109 |             arr.length		= len;
110 |         var bufsiz		= arr.length;
111 |         var buf			= allocate( arr, 'i8', ALLOC_NORMAL );
112 |         try { // must de-allocate buf after this point
113 |             res			= func( rawsiz|0, buf, buflen, bufsiz, sep|0 );
114 |             str			= heapi8_to_string( buf );
115 |         } finally {
116 |             if ( buf ) _free( buf );
117 |         }
118 |         return str;
119 |     }
120 | }
121 | 
122 | rskey_2_encode			= rskey_N_encode_wrap( 'rskey_2_encode' );
123 | rskey_3_encode			= rskey_N_encode_wrap( 'rskey_3_encode' );
124 | rskey_4_encode			= rskey_N_encode_wrap( 'rskey_4_encode' );
125 | rskey_5_encode			= rskey_N_encode_wrap( 'rskey_5_encode' );
126 | 
127 | rskey_N_decode_wrap = function( func_name ) {
128 |     var func			= Module.cwrap( func_name, 'number',
129 |                                                 ['number', 	// rawsiz
130 |                                                  'number'	// buf (allocated here)
131 |                                                  ,'number'	// buflen (supplied key length)
132 |                                                  ,'number'] );	// bufsiz (buffer capacity)
133 |     return function( rawsiz, key ) {
134 |         var		cnf	= -1;
135 |         var		str	= func_name + " invocation failed.";
136 |         var		ret;
137 |         var 		len	= 1024; // room for error message, spaces, etc.
138 | 
139 |         var		arr	= intArrayFromString( key );
140 |         var		buflen	= arr.length - 1; // no NUL
141 |         if ( buflen < len )
142 |             arr.length		= len;
143 |         var		bufsiz	= arr.length;
144 | 
145 |         var		buf	= allocate( arr, 'i8', ALLOC_NORMAL );
146 |         try { // must de-allocate buf after this point
147 |             cnf			= func( rawsiz|0, buf, buflen, bufsiz );
148 |             if ( cnf < 0 ) {
149 |                 str		= heapi8_to_string( buf );
150 |             } else {
151 |                 var	hex	= '0x';
152 |                 u8arr		= new Uint8Array( rawsiz|0 );
153 |                 for ( var i = 0; i < rawsiz|0; ++i ) {
154 |                     u8arr[i]	= getValue( buf+i, 'i8' );
155 |                     hex	       += "0123456789ABCDEF"[(u8arr[i] >> 4) & 0x0f];
156 |                     hex	       += "0123456789ABCDEF"[(u8arr[i] >> 0) & 0x0f];
157 |                 }
158 |                 // If possible, decode data payload as utf-8; leave undefined on failure
159 |                 var utf8;
160 |                 try {
161 |                     td		= new TextDecoder( 'utf-8' );
162 |                     utf8	= td.decode( new DataView( u8arr.buffer )).replace( /\0*$/, '' );
163 |                 } catch ( exc ) {
164 |                     // leave utf8 == undefined
165 |                 }
166 |                 // Return the confidence, the raw ArrayBuffer, and its UTF-8 representation (if any)
167 |                 ret		= {
168 |                     confidence:	cnf,
169 |                     data: 	u8arr.buffer,
170 |                     utf8:	utf8,
171 |                     hex:	hex,
172 |                 };
173 |             }
174 |         } finally {
175 |             if ( buf ) _free( buf );
176 |         }
177 |         if ( cnf < 0 ) { // call failed, or call attempt failed w/o exception
178 |             throw str;
179 |         }
180 |  
181 |         return ret;
182 |     }
183 | }
184 | 
185 | rskey_2_decode		= rskey_N_decode_wrap( 'rskey_2_decode' );
186 | rskey_3_decode		= rskey_N_decode_wrap( 'rskey_3_decode' );
187 | rskey_4_decode		= rskey_N_decode_wrap( 'rskey_4_decode' );
188 | rskey_5_decode		= rskey_N_decode_wrap( 'rskey_5_decode' );
189 | 


--------------------------------------------------------------------------------
/rspwd.C:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <ezpwd/corrector>
 3 | 
 4 | #include <ezpwd/definitions>	// must be included in one C++ compilation unit
 5 | 
 6 | #include "rspwd.h"		// C API declarations
 7 | 
 8 | // 
 9 | // Implementation of "C" rspwd_encode_<N> API, as described by rspwd.h
10 | // 
11 | extern "C" {
12 |     size_t rspwd_encode_1( char *p, size_t s ) { return ezpwd::corrector<1>::encode( p, s ); }
13 |     size_t rspwd_encode_2( char *p, size_t s ) { return ezpwd::corrector<2>::encode( p, s ); }
14 |     size_t rspwd_encode_3( char *p, size_t s ) { return ezpwd::corrector<3>::encode( p, s ); }
15 |     size_t rspwd_encode_4( char *p, size_t s ) { return ezpwd::corrector<4>::encode( p, s ); }
16 |     size_t rspwd_encode_5( char *p, size_t s ) { return ezpwd::corrector<5>::encode( p, s ); }
17 | } // extern "C"
18 | 
19 | 


--------------------------------------------------------------------------------
/rspwd.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EZPWD_RSPWD_H
 2 | #define _EZPWD_RSPWD_H
 3 | 
 4 | #if defined( __cplusplus )
 5 | extern "C" {
 6 | #endif
 7 | 
 8 |     size_t rspwd_encode_1( char *p, size_t s );
 9 |     size_t rspwd_encode_2( char *p, size_t s );
10 |     size_t rspwd_encode_3( char *p, size_t s );
11 |     size_t rspwd_encode_4( char *p, size_t s );
12 |     size_t rspwd_encode_5( char *p, size_t s );
13 | 
14 | #if defined( __cplusplus )
15 | } // extern "C"
16 | #endif
17 | 
18 | #endif // _EZPWD_RSPWD_H
19 | 


--------------------------------------------------------------------------------
/rspwd_test.C:
--------------------------------------------------------------------------------
  1 | // -*- coding: utf-8 -*-
  2 | 
  3 | #include <iostream>
  4 | #include <sstream>
  5 | #include <string.h>
  6 | 
  7 | #include <ezpwd/rs>
  8 | #include <ezpwd/corrector>
  9 | 
 10 | #include <ezpwd/definitions>	// must be included in one C++ compilation unit
 11 | 
 12 | #pragma GCC diagnostic ignored "-Wstringop-truncation" // We know about the truncation of 'password'
 13 | 
 14 | // 
 15 | // rspwd_test -- test instances of ezpwd::corrector<N>, as used by "C" rspwd_decode_N API
 16 | // 
 17 | template < size_t P, size_t N >
 18 | inline int			rspwd_test( std::ostream &failmsgs, const char *password )
 19 | {
 20 |     int				failures= 0;
 21 | 
 22 |     // Get a buffer just big enough for the password (not including NUL) plus N
 23 |     // parity.  We'll copy the NUL-terminated password in there (the NUL using
 24 |     // one of the parity spots).
 25 |     char			enc[P + N];
 26 |     strncpy( enc, password, sizeof enc );
 27 |     size_t			len	= ezpwd::corrector<N>::encode( enc, sizeof enc );
 28 |     failmsgs
 29 | 	<< "expwd::corrector<"	<< N 
 30 | 	<< ">: Password: \""	<< password 
 31 | 	<< "\" ==> \""		<< enc
 32 | 	<< "\""
 33 | 	<< std::endl;
 34 |     if ( len != sizeof enc - 1 ) {
 35 | 	failmsgs << "FAILED: Expected N == " << N << " parity symbols" << std::endl;
 36 | 	++failures;
 37 |     }
 38 | 
 39 |     // 0) Full parity.  Should be able to handle up to (N-1)/2 errors in the low 6 bits.  In other
 40 |     // words, until you have 3 parity symbols, you cannot withstand a random error and have any
 41 |     // reserve parity to gain any certainty that the result is actually correct.
 42 |     for ( size_t e = 0; e <= N/2; ++e ) {
 43 | 	char			err[sizeof enc + N]; // be prepared for up to N extra symbols
 44 | 	std::copy( enc, enc + sizeof enc, err );
 45 | 	for ( size_t i = 0; i < e; ++i )
 46 | 	    err[i]	       	       ^= 1<<(i%4); // flip one of the 3 low bits, eg. entry error
 47 | 	char			fix[sizeof err];
 48 | 	std::copy( err, err + sizeof err, fix );
 49 | 	
 50 | 	int			confidence = ezpwd::corrector<N>::decode( fix, sizeof fix );
 51 | 	bool			matched	= !strcmp( fix, password );
 52 | 	bool			guessed	= confidence > 0 && matched;
 53 | 	bool			failed	= guessed != ( e <= (N-1)/2 );
 54 | 	failmsgs
 55 | 	    << ( guessed
 56 | 		 ? "GUESSED"
 57 | 		 : "default" )
 58 | 	    << ( matched
 59 | 		 ? " matching"
 60 | 		 : " MISMATCH" )
 61 | 	    << ( failed
 62 | 		 ? " FAILURE "
 63 | 		 : " success " )
 64 | 	    << "Full parity "	<< N
 65 | 	    << " w/ "		<< e
 66 | 	    << " errors;      "	<< std::setw( 16 ) << err
 67 | 	    << " ==> "		<< std::setw( 16 ) << fix
 68 | 	    << " w/ " 		<< std::setw( 3 ) << confidence
 69 | 	    << "% confidence"
 70 | 	    << std::endl;
 71 | #if ! ( defined( DEBUG ) && DEBUG >= 1 )
 72 | 	if ( failed )
 73 | #endif
 74 | 	    ++failures;
 75 |     }
 76 | 
 77 |     // 1) Part parity (no errors).  Should be able to confirm password with no errors, and (N+1)/2+1
 78 |     // to N parity symbols via R-S decoding, and from 1 to (N+1)/2 symbols by simple matching.  Clip
 79 |     // off up to all N parity symbols and try decoding.
 80 |     for ( size_t e = 1; e <= N; ++e ) {
 81 | 	char			err[sizeof enc + N]; // be prepared for up to N extra symbols
 82 | 	std::copy( enc, enc + sizeof enc, err );
 83 | 	err[strlen( enc ) - e]	= 0;		// clip off last 'e' symbols
 84 | 
 85 |         char			fix[sizeof err];
 86 | 	std::copy( err, err + sizeof err, fix );
 87 | 	int			confidence = ezpwd::corrector<N>::decode( fix, sizeof fix );
 88 | 	bool			matched	= !strcmp( fix, password );
 89 | 	bool			guessed	= confidence > 0 && matched;
 90 | 	bool			failed	= guessed != ( e < N ); // with any parity symbols, we'll get some confidence
 91 | 	failmsgs
 92 | 	    << ( guessed
 93 | 		 ? "GUESSED"
 94 | 		 : "default" )
 95 | 	    << ( matched
 96 | 		 ? " matching"
 97 | 		 : " MISMATCH" )
 98 | 	    << ( failed
 99 | 		 ? " FAILURE "
100 | 		 : " success " )
101 | 	    << "Part parity "	<< N
102 | 	    << " w/ "		<< e
103 | 	    << " parity skip  "	<< std::setw( 16 ) << err
104 | 	    << " ==> "		<< std::setw( 16 ) << fix
105 | 	    << " w/ " 		<< std::setw( 3 ) << confidence
106 | 	    << "% confidence"
107 | 	    << std::endl;
108 | #if ! ( defined( DEBUG ) && DEBUG >= 1 )
109 | 	if ( failed )
110 | #endif
111 | 	    ++failures;
112 |     }
113 | 
114 |     return failures;
115 | }
116 | 
117 | std::ostream		       &operator<<(
118 | 				    std::ostream       &lhs,
119 | 				    std::ostringstream &rhs )
120 | {
121 |     return lhs << rhs.str();
122 | }
123 | 
124 | int				main()
125 | {
126 |     std::cout
127 | 	<< "rspwd tests ..."
128 | 	<< std::endl;
129 | 
130 | #if defined( DEBUG ) && DEBUG > 0
131 |     std::ostream	       &failmsgs = std::cout;
132 | #else
133 |     std::ostringstream		failmsgs;
134 | #endif
135 |     int				failures= 0;
136 |     failures			       += rspwd_test<10,1>( failmsgs, "Mag.1ckπ" );
137 |     failures			       += rspwd_test<10,2>( failmsgs, "Mag.1ckπ" );
138 |     failures			       += rspwd_test<10,3>( failmsgs, "Mag.1ckπ" );
139 |     failures			       += rspwd_test<10,4>( failmsgs, "Mag.1ckπ" );
140 |     failures			       += rspwd_test<10,5>( failmsgs, "Mag.1ckπ" );
141 |     failures			       += rspwd_test< 7,1>( failmsgs, "sock1t" );
142 |     failures			       += rspwd_test< 7,2>( failmsgs, "sock1t" );
143 |     failures			       += rspwd_test< 7,3>( failmsgs, "sock1t" );
144 |     failures			       += rspwd_test< 7,4>( failmsgs, "sock1t" );
145 |     failures			       += rspwd_test< 7,5>( failmsgs, "sock1t" );
146 | #if ! defined( DEBUG ) || DEBUG == 0
147 |     if ( failures )
148 | 	std::cout
149 | 	    << __FILE__ << " fails " << failures << " tests: "
150 | 	    << std::endl
151 | 	    << failmsgs
152 | 	    << std::endl
153 | 	    << std::endl;
154 |     else
155 | 	std::cout
156 | 	    << "  ...all tests passed."
157 | 	    << std::endl;
158 | #endif
159 |     return failures ? 1 : 0;
160 | }
161 | 


--------------------------------------------------------------------------------
/rspwd_wrap.js:
--------------------------------------------------------------------------------
  1 | //
  2 | // Ezpwd Reed-Solomon -- Reed-Solomon encoder / decoder library
  3 | // 
  4 | // Copyright (c) 2014, Hard Consulting Corporation.
  5 | //
  6 | // Ezpwd Reed-Solomon is free software: you can redistribute it and/or modify it under the terms of
  7 | // the GNU General Public License as published by the Free Software Foundation, either version 3 of
  8 | // the License, or (at your option) any later version.  See the LICENSE file at the top of the
  9 | // source tree.  Ezpwd Reed-Solomon is also available under Commercial license.  c++/ezpwd/rs_base
 10 | // is redistributed under the terms of the LGPL, regardless of the overall licensing terms.
 11 | // 
 12 | // Ezpwd Reed-Solomon is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 13 | // without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
 14 | // the GNU General Public License for more details.
 15 | //
 16 | 
 17 | // 
 18 | // string_to_heapi8	-- allocate buffer of (at least) len of type (eg. i8), initializing from str
 19 | // heapi8_to_string	-- decode a JS string from the buffer, til NUL
 20 | // array_to_heap	-- allocate an array of max( arr.length, len ) elements of type typ
 21 | // index_in_heap	-- return pointer to index ptr[idx] in an array of type typ
 22 | // 
 23 | //     The returned buffer may be longer than the C representation of UTF-8 str, but won't be
 24 | // shorter, and will be NUL terminated.  Account for size of native type in all heap allocations and
 25 | // indexing.
 26 | // 
 27 | function string_to_heapi8( str, len ) {
 28 |     var			arr	= intArrayFromString( str ); // will NUL terminate
 29 |     if ( len && arr.length < len )
 30 |         arr.length		= len;
 31 |     return allocate( arr, 'i8', ALLOC_NORMAL );
 32 | }
 33 | 
 34 | function heapi8_to_string( ptr, len ) {
 35 |     return Pointer_stringify( ptr );
 36 | };
 37 | 
 38 | function array_to_heap( typ, arr, len ) {
 39 |     if ( len && arr.length / Runtime.getNativeTypeSize( typ ) < len )
 40 |         arr.length		= len * Runtime.getNativeTypeSize( typ );
 41 |     return allocate( arr, typ, ALLOC_NORMAL );
 42 | }
 43 | 
 44 | function index_in_heap( typ, ptr, idx ) {
 45 |     return ptr + idx * Runtime.getNativeTypeSize( typ );
 46 | }
 47 | 
 48 | // 
 49 | // rspwd_encode_<N> -- Adds <N> parity to the supplied string (w/ max. size), returning length
 50 | // rspwd_decode_<N> -- Decodes the supplied string w/ up to <N> parity, returning confidence
 51 | // 
 52 | //     Since arrays are used to communicate, they must be allocated locally and release after the
 53 | // wrapped call.  The underlying "C" decode returns a -'ve confidence and a (NUL terminated) string
 54 | // describing the error on failure, or a zero or +'ve confidence and the decoded lat/lon and
 55 | // accuracy on success.
 56 | // 
 57 | //     Decoding an EZCOD 3:10/11/12 encoded string returns an array:
 58 | // 
 59 | //         [<confidence>, <latitude>, <longitude>, <accuracy>]
 60 | // 
 61 | // <confidence>	-- The proportion [0,1] of parity symbols in excess, after error/erasure correction
 62 | // <latitude>	-- Latitude in degress [-90,90]
 63 | // <longitude>	-- Longitude in degrees [-180,180]
 64 | // <accuracy>	-- Estimated accuracty in meters
 65 | // 
 66 | rspwd_encode_N_wrap = function( func_name ) {
 67 |     var func			= Module.cwrap( func_name, 'number',
 68 |                                                 ['number'	// array (buf allocated here)
 69 |                                                  ,'number'] );	// array size
 70 |     return function( lat, lon ) {
 71 |         var 		len	= 1024; // room for error message, spaces, etc.
 72 |         var		res	= -1;
 73 |         var		str	= func_name + " invocation failed.";
 74 |         var		buf	= string_to_heapi8( "", len );
 75 |         try { // must de-allocate buf after this point
 76 |             res			= func( lat, lon, buf, len );
 77 |             str			= heapi8_to_string( buf );
 78 |         } finally {
 79 |             if ( buf ) _free( buf );
 80 |         }
 81 |         if ( res < 0 ) { // call failed, or call attempt failed w/o exception
 82 |             console.log( str );
 83 |             throw str;
 84 |         }
 85 |         return str;
 86 |     }
 87 | }
 88 | 
 89 | ezcod_3_10_encode		= ezcod_3_N_encode_wrap( 'ezcod_3_10_encode' );
 90 | ezcod_3_11_encode		= ezcod_3_N_encode_wrap( 'ezcod_3_11_encode' );
 91 | ezcod_3_12_encode		= ezcod_3_N_encode_wrap( 'ezcod_3_12_encode' );
 92 | 
 93 | ezcod_3_N_decode_wrap = function( func_name ) {
 94 |     var func			= Module.cwrap( func_name, 'number',
 95 |                                                 ['number'	// array (buf allocated here)
 96 |                                                  ,'number'	// array size
 97 |                                                  ,'number'	// lat * (pos allocated here)
 98 |                                                  ,'number'	// lon *  ''
 99 |                                                  ,'number'] );	// acc *  ''
100 |     return function( cod ) {
101 |         var		cnf	= -1;
102 |         var		str	= func_name + " invocation failed.";
103 |         var		ret;
104 |         var		pos;
105 |         var 		len	= 1024; // room for error message, spaces, etc.
106 |         var		buf	= string_to_heapi8( cod, len );
107 |         try { // must de-allocate buf and lat/lon/acc after this point
108 |             pos			= array_to_heap( 'double', [], 3 );
109 |             var		lat	= index_in_heap( 'double', pos, 0 );
110 |             var		lon	= index_in_heap( 'double', pos, 1 );
111 |             var		acc	= index_in_heap( 'double', pos, 2 );
112 |             cnf			= func( buf, len, lat, lon, acc );
113 |             if ( cnf < 0 ) {
114 |                 str		= heapi8_to_string( buf );
115 |             } else {
116 |                 ret		= [
117 |                     cnf / 100.0, getValue( lat, 'double', 1 ), getValue( lon, 'double', 1 ), getValue( acc, 'double', 1 )
118 |                 ];
119 |             }
120 |         } finally {
121 |             if ( buf ) _free( buf );
122 |             if ( pos ) _free( pos );
123 |         }
124 |         if ( cnf < 0 ) { // call failed, or call attempt failed w/o exception
125 |             console.log( str );
126 |             throw str;
127 |         }
128 |  
129 |         return ret;
130 |     }
131 | }
132 | 
133 | ezcod_3_10_decode		= ezcod_3_N_decode_wrap( 'ezcod_3_10_decode' );
134 | ezcod_3_11_decode		= ezcod_3_N_decode_wrap( 'ezcod_3_11_decode' );
135 | ezcod_3_12_decode		= ezcod_3_N_decode_wrap( 'ezcod_3_12_decode' );
136 | 


--------------------------------------------------------------------------------
/rssimple.C:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <iostream>
 3 | #include <iomanip>
 4 | #include <cctype>
 5 | #include <cstring>
 6 | #include <sys/time.h>
 7 | #include <array>
 8 | #include <vector>
 9 | 
10 | #include <ezpwd/rs>
11 | #include <ezpwd/timeofday>
12 | #include <ezpwd/output>
13 | 
14 | int main() 
15 | {
16 |     int				failures= 0;
17 | 
18 |     ezpwd::RS<255,253>		rs;		// 255 symbol codeword, up to 253 data == 2 symbols parity
19 |     std::string			orig	= "Hello, world!";
20 | 
21 |     // Most basic use of API to correct an error, in a dynamic container
22 |     std::cout << std::endl << std::endl << "Simple std::string container:" << std::endl;
23 |     {
24 | 	std::string		copy	= orig; // working copy, copy of orig
25 | 	std::cout << "Original:  " << ezpwd::hexstr( copy ) << std::endl;
26 | 	rs.encode( copy );				// 13 symbols copy + 2 symbols R-S parity added
27 | 	std::cout << "Encoded:   " << ezpwd::hexstr( copy ) << std::endl;
28 | 	copy[3]				= 'x';	// Corrupt one symbol
29 | 	std::cout << "Corrupted: " << ezpwd::hexstr( copy ) << std::endl;
30 | 	int			count	= rs.decode( copy );  // Correct any symbols possible
31 | 	std::cout << "Corrected: " << ezpwd::hexstr( copy ) << " : " << count << " errors fixed" << std::endl;
32 | 	copy.resize( copy.size() - rs.nroots() );	// Discard added R-S parity symbols
33 | 	std::cout << "Restored:  " << ezpwd::hexstr( copy ) << std::endl;
34 | 	if ( copy != orig ) {				// Ensure original copy is recovered
35 | 	    failures		       += 1;
36 | 	    std::cout << "Failed to restore origin data." << std::endl;
37 | 	}
38 |     }
39 | 
40 |     // Iterate through orig, corrupting or erasing the i'th character, and fixing it.
41 |     std::cout << std::endl << std::endl << "Iterate over std::vector container:" << std::endl;
42 |     for ( size_t i = 0; i < orig.size(); ++i ) {
43 | 	std::vector<uint8_t>	data( orig.begin(), orig.end() );
44 | 	rs.encode( data );
45 | 
46 | 	std::vector<int>	erasure;
47 | 	if ( i & 1 ) {					// every other loop...
48 | 	    erasure.push_back( i );
49 | 	    data[i]			= ' ';		// erasure
50 | 	    std::cout << "Erasure:   " << data << std::endl;
51 | 	} else {
52 | 	    data[i]		       ^= 1 << i % 8;	// error
53 | 	    std::cout << "Corrupted: " << data << std::endl;
54 | 	}
55 | 	std::vector<int>	position;
56 | 	int 			count	= rs.decode( data, erasure, &position );
57 | 	std::string		fixes( data.size() * 2, ' ' );
58 | 	for ( int i : position )
59 | 	    fixes[i*2+0] = fixes[i*2+1]	= '^';
60 | 	std::cout << "Fixed:     " << fixes << "(count: " << count << ")" << std::endl;
61 | 	std::cout << "Decoded:   " << data << std::endl << std::endl;
62 | 
63 | 	// Remove R-S parity symbols, ensure original copy is recovered
64 | 	data.resize( data.size() - rs.nroots() );
65 | 	if ( std::string( data.begin(), data.end() ) != orig ) {
66 | 	    failures		       += 1;
67 | 	    std::cout << "Failed to restore origin data." << std::endl;
68 | 	}
69 |     }
70 | 
71 |     return failures ? 1 : 0;
72 | }
73 | 


--------------------------------------------------------------------------------
/rsspeed.C:
--------------------------------------------------------------------------------
  1 | 
  2 | #include <array>
  3 | #include <vector>
  4 | #include <cctype>
  5 | #include <cmath>
  6 | #include <functional>
  7 | 
  8 | #include <ezpwd/rs>
  9 | #include <ezpwd/output>
 10 | #include <ezpwd/timeofday>
 11 | #include <ezpwd/asserter>
 12 | 
 13 | #include <ezpwd/rs_definitions>	// must be included in one C++ compilation unit
 14 | 
 15 | 
 16 | // Phil Karn's implementation
 17 | extern "C" {
 18 | #include <rs.h>
 19 | }
 20 | 
 21 | template <size_t TOTAL, size_t ROOTS, size_t PAYLOAD=TOTAL-ROOTS>
 22 | void				init(
 23 | 				     std::array<uint8_t,TOTAL> &data,
 24 | 				     std::function<void (
 25 | 					 uint8_t	       *, // should be const, but some encoders are badly typed
 26 | 					 size_t,
 27 | 					 uint8_t 	       *,
 28 | 					 size_t
 29 | 				     )>				encoder
 30 | 				 )
 31 | {
 32 |     for ( size_t i = 0; i < PAYLOAD; ++i )
 33 | 	data[i]				= i;
 34 |     for ( size_t i = 0; i < ROOTS; ++i )
 35 | 	data[PAYLOAD+i]			= 0;
 36 |     encoder( data.data(), PAYLOAD, data.data() + PAYLOAD, ROOTS );
 37 | }
 38 | 
 39 | template <size_t TOTAL, size_t ROOTS, size_t PAYLOAD=TOTAL-ROOTS>
 40 | void				dump( std::string what, std::array<uint8_t,TOTAL> &data )
 41 | {
 42 |     std::cout
 43 | 	<< std::setw( 24 ) << std::left << what << " RS(" << TOTAL << "," << (TOTAL-ROOTS)
 44 | 	<< ") w/ " << PAYLOAD << " data, " << ROOTS << " parity:" << std::endl;
 45 | 
 46 |     std::cout << "DATA:   " << std::vector<uint8_t>( data.begin(), data.begin() + PAYLOAD ) << std::endl;
 47 |     std::cout << "PARITY: " << std::vector<uint8_t>( data.begin() + PAYLOAD, data.begin() + PAYLOAD + ROOTS ) << std::endl;
 48 | }
 49 | 
 50 | 
 51 | // 
 52 | // Test a variety of 8-bit Reed-Solomon codecs.
 53 | // - Phil Karn's "FIXED" {en,de}code_rs_8 are specific to the CCSDS polynomial 0x187, w/o dual-basis
 54 | // - Phil Karn's "CCSDS" {en,de}code_rs_ccsds only works w/ CCSDS polynomial and RS(255,223), w/ dual-basis encoding
 55 | //
 56 | 
 57 | //        eg.     255,             2,            253
 58 | template <size_t TOTAL, size_t ROOTS, size_t PAYLOAD=TOTAL-ROOTS>
 59 | double 				compare(
 60 | 				    ezpwd::asserter    &assert )
 61 | {
 62 |     // Get an 'orig' payload.  This data is considered to be in "conventional basis" for normal R-S
 63 |     // operations, and is considered to be in "dual basis" for CCSDS operations (ie. it is converted
 64 |     // to "conventional basis" by the CCSDS R-S operators de/encoded, and the results restored to
 65 |     // "dual basis" on return).
 66 |     std::array<uint8_t,TOTAL>	orig;
 67 | 
 68 |     // Ensure that each RS encoder produces the same parity symbols; both Phil Karn's generic codec,
 69 |     // his CCSDS-specific implementation (for 32 == ROOTS only), and the new ezpwd/reed_solomon
 70 |     // codec.  The 'orig' will be the generic reference conventional R-S output; 'corig' will be the
 71 |     // reference dual-basis CCSDS R-S output.  The only difference should be in the parity symbol
 72 |     // encoding (orig conventional, corig dual basis).
 73 |     static const ezpwd::RS<TOTAL,TOTAL-ROOTS>
 74 | 				nrs;
 75 |     void		       *grs	= init_rs_char( 8, nrs.poly(), nrs.fcr(), nrs.prim(), ROOTS, 0 );
 76 | 
 77 |     auto karn_encoder		= [grs](
 78 | 				         uint8_t	       *payload,
 79 | 					 size_t,
 80 | 					 uint8_t 	       *parity,
 81 | 					 size_t
 82 | 					) -> void
 83 |     {
 84 | 	encode_rs_char( grs, payload, parity );
 85 |     };
 86 | 
 87 |     init<TOTAL,ROOTS>( orig, karn_encoder );
 88 |     //dump<TOTAL,ROOTS>( "Phil Karn's Generic", orig );
 89 | 
 90 |     // Get a baseline TPS rate for a simple R-S decode with an error, from Phil's general-purpose
 91 |     // decoder.  Specify half of the tests as erasures, half as errors.  Only symbols that actually
 92 |     // differ from the computed codeword symbol will be reported as corrected errors/erasures.
 93 |     int				gcorrs	= 0;
 94 |     double			gtps	= 0;
 95 |     {
 96 | 	int			geras[ROOTS];
 97 | 	std::array<uint8_t,TOTAL> gdata( orig );
 98 | 	timeval			beg	= ezpwd::timeofday();
 99 | 	timeval			end	= beg;
100 | 	end.tv_sec		       += 1;
101 | 	int			count	= 0;
102 | 	timeval			now;
103 | 	while (( now = ezpwd::timeofday() ) < end ) {
104 | 	    for ( int final = count + 997; count < final; ++count ) {
105 | 		uint8_t		err	= (final - count ) % 255; // may xor with a zero value
106 | 		geras[0]		= count % gdata.size();
107 | 		gdata[geras[0]]	       ^= err;
108 | 		int		numeras	= (ROOTS > 1 ? err&1 : 1 ); // 1 parity? erasure only
109 | 		gcorrs			= decode_rs_char( grs, gdata.data(), geras, numeras );
110 | 		if ( assert.ISEQUAL( ! gcorrs, ! err ))
111 | 		    std::cout
112 | 			<< assert << " corrections doesn't match error load!"
113 | 			<< std::endl;
114 | 	    }
115 | 	}
116 | 	double			elapsed	= ezpwd::seconds( now - beg );
117 | 	gtps				= count / elapsed;
118 | 
119 | 	if ( assert.ISTRUE( gdata == orig ))
120 | 	    std::cout
121 | 		<< assert << " Phil's Generic R-S decoder produced different results"
122 | 		<< std::endl;
123 |     }
124 |     std::cout 
125 | 	<< nrs
126 | 	<< " (Phil Karn's) corrections: "	<< gcorrs
127 | 	<< " at "				<< gtps/1000
128 | 	<< " kTPS"
129 |         << std::endl;
130 | 
131 |     // Finally, test the Ezpwd RS decoder.  Should use the same default polynomial as Phil Karn's
132 |     // generic codec.
133 |     int				ncorrs	= 0;
134 |     double			ntps	= 0;
135 |     {
136 | 	std::vector<unsigned>	neras( 1 );
137 | 	std::array<uint8_t,TOTAL> ndata( orig );
138 | 	timeval			beg	= ezpwd::timeofday();
139 | 	timeval			end	= beg;
140 | 
141 | 	end.tv_sec		       += 1;
142 | 	int			count	= 0;
143 | 	timeval			now;
144 | 	while (( now = ezpwd::timeofday() ) < end ) {
145 | 	    for ( int final = count + 997; count < final; ++count ) {
146 | 		uint8_t		err	= (final - count) % 255; // may xor with a zero value
147 | 		neras[0]		= count % ndata.size();
148 | 		ndata[neras[0]]	       ^= err;
149 | 		unsigned	numeras	= (ROOTS > 1 ? err&1 : 1 ); // 1 parity? erasure only
150 | 		ncorrs			= nrs.decode( ndata.data(), nrs.LOAD, ndata.data() + nrs.LOAD, neras.data(), numeras );
151 | 		if ( assert.ISEQUAL( ! ncorrs, ! err ))
152 | 		    std::cout
153 | 			<< assert << " corrections doesn't match error load!"
154 | 			<< std::endl;
155 | 	    }
156 | 	}
157 | 	double			elapsed	= ezpwd::seconds( now - beg );
158 | 	ntps				= count / elapsed;
159 | 	if ( assert.ISTRUE( ndata == orig ))
160 | 	    std::cout
161 | 		<< assert << " EZPWD R-S decoder produced different results"
162 | 		<< std::endl;
163 |     }
164 |     std::cout 
165 | 	<< nrs
166 | 	<< " (EZPWD's)     corrections: "	<< ncorrs
167 | 	<< " at "				<< ntps/1000
168 | 	<< " kTPS ("				<< std::abs( ntps - gtps ) / gtps * 100
169 | 	<< "% "					<< ( ntps > gtps ? "faster" : "slower" )
170 | 	<< ")"
171 |         << std::endl;
172 | 
173 |     free_rs_char( grs );
174 |     return ( ntps - gtps ) / gtps * 100;
175 | }
176 | 
177 | int main()
178 | {
179 |     ezpwd::asserter		assert;
180 |     double			avg	= 0;
181 |     int				cnt	= 0;
182 | 
183 |     avg				       += compare<255,128>( assert );	++cnt;
184 |     avg				       += compare<255, 99>( assert );	++cnt;
185 |     avg				       += compare<255, 64>( assert );	++cnt;
186 |     avg				       += compare<255, 32>( assert );	++cnt;
187 |     avg				       += compare<255, 16>( assert );	++cnt;
188 |     avg				       += compare<255, 13>( assert );	++cnt;
189 |     avg				       += compare<255,  8>( assert );	++cnt;
190 |     avg				       += compare<255,  4>( assert );	++cnt;
191 |     avg				       += compare<255,  3>( assert );	++cnt;
192 |     avg				       += compare<255,  2>( assert );	++cnt;
193 |     avg				       += compare<255,  1>( assert );	++cnt;
194 | 
195 |     std::cout << std::endl << "RS(255,...) EZPWD vs. Phil Karn's: " << avg/cnt << "% faster (avg.)" << std::endl;
196 | 
197 |     return assert.failures ? 1 : 0;
198 | }
199 | 


--------------------------------------------------------------------------------
/shell.nix:
--------------------------------------------------------------------------------
 1 | { pkgs ? import ./nixpkgs.nix {}, shell ? false }:
 2 | 
 3 | with pkgs;
 4 | 
 5 | mkShell.override { stdenv = pkgs.gcc11Stdenv; } {
 6 |   inputsFrom = lib.attrValues  (import ./. {
 7 |     inherit pkgs;
 8 |     shell = true;
 9 |   });
10 | 
11 |   buildInputs = [
12 |     # additional packages go here
13 |     ncurses
14 |   ];
15 | }
16 | 


--------------------------------------------------------------------------------
/swig/python/.gitignore:
--------------------------------------------------------------------------------
1 | *.pyc
2 | *.so
3 | ezcod_python
4 | *.egg-info
5 | build/
6 | dist/
7 | .cache
8 | 


--------------------------------------------------------------------------------
/swig/python/BCH/BCH.i:
--------------------------------------------------------------------------------
  1 | %module BCH
  2 | 
  3 | %{
  4 | #include "ezpwd/bch"
  5 | #include "ezpwd/serialize_definitions"
  6 | %}
  7 | 
  8 | %include std_string.i
  9 | %include std_pair.i
 10 | 
 11 | // 
 12 | // The <</output operations don't make sense for Python.  Supply repr/str instead.
 13 | // 
 14 | %ignore ::operator<<;
 15 | %ignore *::output;
 16 | 
 17 | // 
 18 | // The in-place {en,de}code methods don't make sense for Python; Use the pass-thru {en,de}coded
 19 | // methods.  These encode and return a copy (w/ parity added and/or placed), or decode and return a
 20 | // valid or corrected copy.  If not able to {en,de}code successfully, they raise an exception.
 21 | // 
 22 | %ignore *::encode;
 23 | %ignore *::decode;
 24 | 
 25 | %include "exception.i"
 26 | 
 27 | %exception {
 28 |     try {
 29 |         $action
 30 |     } catch ( const std::exception &e ) {
 31 |         SWIG_exception( SWIG_RuntimeError, e.what() );
 32 |     }
 33 | }
 34 | 
 35 | // 
 36 | // Instantiate some of the required vector types used by the en/decode APIs
 37 | // 
 38 | %include "std_vector.i"
 39 | namespace std {
 40 |     %template(error_position)	vector<int>;
 41 |     %template(uint8_vector)	vector<unsigned char>;
 42 | }
 43 | 
 44 | %include ezpwd/bch
 45 | 
 46 | %extend ezpwd::bch_base {
 47 |     std::string		        __repr__()
 48 |     {
 49 | 	std::ostringstream	oss;
 50 | 	oss << '<';
 51 | 	$self->output( oss );
 52 | 	oss << '>';
 53 | 	return oss.str();
 54 |     }
 55 |     std::string		        __str__()
 56 |     {
 57 | 	std::ostringstream	oss;
 58 | 	$self->output( oss );
 59 | 	return oss.str();
 60 |     }
 61 | 
 62 |     // 
 63 |     // Support some known container types for {en,de}coded template
 64 |     //
 65 |     %template(encoded) encoded<std::string>;
 66 |     %template(decoded) decoded<std::string>;
 67 |     %template(encoded) encoded<std::vector<unsigned char>>;
 68 |     %template(decoded) decoded<std::vector<unsigned char>>;
 69 | };
 70 | 
 71 | // Ship a few 8-bit bch/BCH<...> class template instantiations
 72 | // 
 73 | // BCH Codecs Available (in bits)
 74 | //        size of
 75 | //        codeword
 76 | //        |  data
 77 | //        |  payload
 78 | //        |    |    bit error
 79 | //        |    |    capacity
 80 | //        |    |    |           parity
 81 | //        |    |    |           bits  bytes
 82 | //        |    |    |            |     |
 83 | // BCH( 255, 247,   1 ); ECC =   8 /   1
 84 | // BCH( 255, 239,   2 ); ECC =  16 /   2
 85 | // BCH( 255, 231,   3 ); ECC =  24 /   3
 86 | // BCH( 255, 223,   4 ); ECC =  32 /   4
 87 | // BCH( 255, 215,   5 ); ECC =  40 /   5
 88 | // BCH( 255, 207,   6 ); ECC =  48 /   6
 89 | // BCH( 255, 199,   7 ); ECC =  56 /   7
 90 | // BCH( 255, 191,   8 ); ECC =  64 /   8
 91 | // 
 92 | // (add more here, if desired; see bch_test output for possibilites)
 93 | %template(bch_255_1)		ezpwd::bch<255,1>;
 94 | %template(bch_255_2)		ezpwd::bch<255,2>;
 95 | %template(bch_255_3)		ezpwd::bch<255,3>;
 96 | %template(bch_255_4)		ezpwd::bch<255,4>;
 97 | %template(bch_255_5)		ezpwd::bch<255,5>;
 98 | %template(bch_255_6)		ezpwd::bch<255,6>;
 99 | %template(bch_255_7)		ezpwd::bch<255,7>;
100 | %template(bch_255_8)		ezpwd::bch<255,8>;
101 | 
102 | %template(BCH_255_247_1)	ezpwd::BCH<255,247,1>;
103 | %template(BCH_255_239_2)	ezpwd::BCH<255,239,2>;
104 | %template(BCH_255_231_3)	ezpwd::BCH<255,231,3>;
105 | %template(BCH_255_223_4)	ezpwd::BCH<255,223,4>;
106 | %template(BCH_255_215_5)	ezpwd::BCH<255,215,5>;
107 | %template(BCH_255_207_6)	ezpwd::BCH<255,207,6>;
108 | %template(BCH_255_199_7)	ezpwd::BCH<255,199,7>;
109 | %template(BCH_255_191_8)	ezpwd::BCH<255,191,8>;
110 | 


--------------------------------------------------------------------------------
/swig/python/BCH/GNUmakefile:
--------------------------------------------------------------------------------
 1 | # 
 2 | # Development build of ezcod Python wrapper
 3 | # - Production build is done using setuptools (see: ../setup.py)
 4 | # 
 5 | ROOT		= ../../..
 6 | 
 7 | include $(ROOT)/GNUmakefile
 8 | 
 9 | # 
10 | # Swig interfaces.  Requires Swig >= 3.0.5
11 | # 
12 | # Find Python.h, libraries
13 | # 
14 | # On Mac:
15 | #   /usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/include/python2.7/Python.h
16 | #   $ python -e "import os; print os.__file__"
17 | #   /usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/lib/python2.7/os.pyc
18 | #  - Library:
19 | #   /usr/local//Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/lib/python2.7/config/libpython2.7.a
20 | # On Linux:
21 | #   /usr/include/python2.7/Python.h
22 | #   $ python -e "import os; print os.__file__"
23 | #   /usr/lib/python2.7/os.pyc
24 | # 
25 | PYTHON_INC	= $(shell python3 -c 'import os; segs=os.__file__.split( os.path.sep ); print( os.path.sep.join( segs[:-3]+["include"]+segs[-2:-1] ))' )
26 | PYTHON_LIB	= $(shell python3 -c 'import os, glob; segs=os.__file__.split( os.path.sep ); print( glob.glob( os.path.sep.join( segs[:-1]+["config*/"] ))[0] )' )
27 | 
28 | PYTHON_COMP	= -I$(PYTHON_INC) -fPIC $(INCLUDE_BCH)
29 | PYTHON_LINK	= -L$(PYTHON_LIB) -lpython3.10 -shared $(ROOT)/djelic_bch.o
30 | 
31 | python-BCH:		_BCH.so
32 | 
33 | python-BCH-test:	runme.py python-BCH
34 | 	python3 $<
35 | 
36 | python-BCH-clean:
37 | 	rm -f *.cpp *.o *.so *.pyc
38 | 
39 | # Forces re-build of Swig-generated code (if desired)
40 | python-BCH-pristine: python-BCH-clean
41 | 	rm -f BCH_wrap.cpp BCH.py
42 | 
43 | BCH_wrap.cpp:		BCH.i
44 | 	swig -verbose -c++ $(INCLUDE) $(INCLUDE_BCH) -python -py3 -o $@ $<
45 | 
46 | BCH_wrap.o:		BCH_wrap.cpp
47 | 	$(CXX) $(CXXFLAGS) $(PYTHON_COMP) $(INCLUDE_BCH) -c $<
48 | 
49 | _BCH.so:		BCH_wrap.o $(ROOT)/djelic_bch.o
50 | 	$(CXX) $(CXXFLAGS) $(PYTHON_LINK) -o $@ $<
51 | 


--------------------------------------------------------------------------------
/swig/python/BCH/__init__.py:
--------------------------------------------------------------------------------
 1 | 
 2 | #
 3 | # Ezpwd-reed-solomon -- Reed-Solomon Codec and utilities
 4 | #
 5 | # Copyright (c) 2015, Hard Consulting Corporation.
 6 | #
 7 | # Ezpwd-reed-solomon is free software: you can redistribute it and/or modify it
 8 | # under the terms of the GNU General Public License as published by the Free
 9 | # Software Foundation, either version 3 of the License, or (at your option) any
10 | # later version.  See the LICENSE file at the top of the source tree.
11 | #
12 | # Ezpwd-reed-solomon is distributed in the hope that it will be useful, but
13 | # WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 | # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
15 | # details.
16 | #
17 | 
18 | from __future__ import absolute_import, print_function, division
19 | 
20 | __author__                      = "Perry Kundert"
21 | __email__                       = "perry@hardconsulting.com"
22 | __copyright__                   = "Copyright (c) 2015 Hard Consulting Corporation"
23 | __license__                     = "Dual License: GPLv3 (or later) and Commercial (see LICENSE)"
24 | 
25 | # These modules form the public interface of ezpwd_reed_solomon.BCH
26 | from .BCH import *
27 | 


--------------------------------------------------------------------------------
/swig/python/BCH/runme.py:
--------------------------------------------------------------------------------
 1 | # file: runme.py
 2 | from __future__ import print_function
 3 | import BCH
 4 | 
 5 | flexi16		= BCH.bch_base( 8, 2 )
 6 | print( "BCH(255,239,2):  %r" % ( flexi16 )) # The repr...
 7 | print( dir( flexi16 ))
 8 | 
 9 | 
10 | def flip( data, bit ):
11 |     if isinstance( data, str ):
12 |         return data[:bit // 8] + chr( ord( data[bit // 8] ) ^ 1 << bit % 8) + data[bit // 8 + 1:]
13 |     elif isinstance( data, tuple ):
14 |         return data[:bit // 8] + (data[bit // 8] ^ 1 << bit % 8,) + data[bit // 8 + 1:]
15 |     elif isinstance( data, list ):
16 |         return data[:bit // 8] + [data[bit // 8] ^ 1 << bit % 8,] + data[bit // 8 + 1:]
17 |     raise RuntimeError( "Unhandled sequence: %r" % data )
18 | 
19 | 
20 | def bch_test( codec, data, errors=2 ):
21 |     raw			= data[:]
22 |     enc			= codec.encoded( raw )
23 |     print( "Encoded   %-40r: %r" % ( raw, enc ))
24 |     err			= enc
25 | 
26 |     for e in range( errors ):
27 |         err		= flip( err, ( e * 17 ) % ( len( err ) * 8 ))
28 | 
29 |     print( "Errors (%2d / %2d) %-33s: %r" % ( errors, codec.t(), '', err ))
30 |     dec			= codec.decoded( err ) # throws on failure to decode
31 |     print( "Corrected %-40r: %r" % ( err, dec[:-codec.ecc_bytes()] ))
32 |     assert dec[:-codec.ecc_bytes()] == raw, \
33 |         "Failed to correct %d errors using %s" % ( errors, codec )
34 | 
35 | 
36 | def edge_test( codec, data ):
37 |     print()
38 |     print( codec )
39 |     
40 |     errors		= codec.t()
41 |     bch_test( codec, data, errors=errors )
42 |     try:
43 |         bch_test( codec, data, errors=errors+1 )
44 |     except Exception as exc:
45 |         print( "Exception %r received, as expected" % ( exc ))
46 |     else:
47 |         raise RuntimeError( "Failed to detect errors beyond capacity" )
48 | 
49 | # Try the flexible (Galois order defined) BCH codec
50 | edge_test( flexi16, 'abc' )
51 | 
52 | # Try some example bch/BCH<...> class template instantiations (change BCH.i to add others)
53 | edge_test( BCH.BCH_255_239_2(), 'xyz' )
54 | edge_test( BCH.BCH_255_191_8(), 'abcdefghijkl' )
55 | edge_test( BCH.bch_255_8(),     'abcdefghijkl' )
56 | 
57 | edge_test( flexi16, (1,2,3) )
58 | 
59 | data=[0x11,0x22,0x33]
60 | data_parity = flexi16.encoded( data )
61 | print( repr( data_parity ))
62 | 
63 | decoded = flexi16.decoded( data_parity )
64 | print( repr( decoded ))
65 | 
66 | positions = BCH.error_position()
67 | erroneous = flip( data_parity, 5 )
68 | erroneous = flip( erroneous, 15 )
69 | corrected = flexi16.decoded( erroneous, positions )
70 | print( repr( data_parity ))
71 | print( repr( erroneous ))
72 | print( repr( corrected ))
73 | print( repr( positions ))
74 | print( repr( list( p for p in positions )))
75 | print( repr( list( positions )))
76 | 
77 | 
78 | # The error positions can be returned; a special BCH.error_position container type
79 | # must be used (due to the vagaries of the Swig-generated Python wrapper).
80 | data = [0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF]
81 | codeword = flexi16.encoded( data )
82 | 
83 | erroneous = list( codeword )
84 | erroneous[1] ^= 1 << 3 # introduce an error in the 4rd bit of the 2nd byte; 12th bit (bit index 11)
85 | positions = BCH.error_position()
86 | corrected = flexi16.decoded( erroneous, positions )
87 | assert corrected == codeword and len( positions ) == 1 and positions[0] == 11, \
88 |     "'codeword:  %r'\n'erroneous: %r'\n'corrected: %r'\n'positions: %r'" % (
89 |         codeword, erroneous, corrected, list( positions ))
90 | 


--------------------------------------------------------------------------------
/swig/python/BCH_test.py:
--------------------------------------------------------------------------------
 1 | def test_simple():
 2 |     import BCH
 3 |   
 4 |     def flip( data, bit ):
 5 |         return data[:bit // 8] + chr( ord( data[bit // 8] ) ^ 1 << bit % 8) + data[bit // 8 + 1:]
 6 |   
 7 |     flexi16 = BCH.bch_base( 8, 2 )
 8 |   
 9 |     ori = 'abc'
10 |     enc = flexi16.encoded( ori )
11 | 
12 |     # Add some bit-errors
13 |     err = flip( enc, 14 )
14 |     err = flip( err, 7 )
15 |     #err = flip( err, 21 ) # over bit-error correction capacity
16 | 
17 |     # Decode and test
18 |     dec = flexi16.decoded( err )
19 |     assert dec[:3] == ori
20 | 


--------------------------------------------------------------------------------
/swig/python/GNUmakefile:
--------------------------------------------------------------------------------
 1 | SHELL		= bash
 2 | BINDINGS	= ezcod		\
 3 | 		  BCH
 4 | 
 5 | all:
 6 | 	@echo "Python Bindings: $(BINDINGS)"
 7 | 	@echo "  install	-- install ezpwd_reed_solomon w/ all bindings"
 8 | 	@echo "  test		-- test ezpwd_reed_solomon w/ all bindings"
 9 | 	@echo "  binding-	-- Run on all bindings..."
10 | 	@echo "    clean	-- "
11 | 	@echo "    pristine	-- Force rebuild of binding"
12 | 	@echo "    test		-- Internal binding self-test"
13 | 
14 | binding-%:		FORCE
15 | 	@for binding in $(BINDINGS); do				\
16 | 	    echo "Running python-binding-$* on $$binding";	\
17 | 	    make -C $$binding python-$$binding-$*;		\
18 | 	done
19 | 
20 | clean:			binding-clean
21 | 	rm -rf build dist
22 | 
23 | pristine:		clean binding-pristine
24 | 
25 | test:			clean binding-test
26 | 
27 | install:		version.py FORCE
28 | 	python3 setup.py install
29 | 
30 | version.py:		../../VERSION
31 | 	@python -c 'print "__version_info__\t\t= (%s)" % ", ".join( open( "'$<'", "r" ).read().strip().split( "." ))' > $@
32 | 	@python -c 'print "__version__\t\t\t= \".\".join( map( str, __version_info__ ))"' >> $@
33 | 
34 | FORCE:
35 | 


--------------------------------------------------------------------------------
/swig/python/MANIFEST.in:
--------------------------------------------------------------------------------
1 | include requirements.txt
2 | 


--------------------------------------------------------------------------------
/swig/python/__init__.py:
--------------------------------------------------------------------------------
 1 | 
 2 | #
 3 | # Ezpwd-reed-solomon -- Reed-Solomon Codec and utilities
 4 | #
 5 | # Copyright (c) 2015, Hard Consulting Corporation.
 6 | #
 7 | # Ezpwd-reed-solomon is free software: you can redistribute it and/or modify it
 8 | # under the terms of the GNU General Public License as published by the Free
 9 | # Software Foundation, either version 3 of the License, or (at your option) any
10 | # later version.  See the LICENSE file at the top of the source tree.
11 | #
12 | # Ezpwd-reed-solomon is distributed in the hope that it will be useful, but
13 | # WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 | # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
15 | # details.
16 | #
17 | 
18 | from __future__ import absolute_import, print_function, division
19 | 
20 | __author__                      = "Perry Kundert"
21 | __email__                       = "perry@hardconsulting.com"
22 | __copyright__                   = "Copyright (c) 2015 Hard Consulting Corporation"
23 | __license__                     = "Dual License: GPLv3 (or later) and Commercial (see LICENSE)"
24 | 
25 | __all__                         = [ "ezcod", "BCH" ]
26 | 
27 | from .version import __version__, __version_info__
28 | 


--------------------------------------------------------------------------------
/swig/python/ezcod/GNUmakefile:
--------------------------------------------------------------------------------
 1 | # 
 2 | # Development build of ezcod Python wrapper
 3 | # - Production build is done using setuptools (see: ../setup.py)
 4 | # 
 5 | ROOT		= ../../..
 6 | 
 7 | include $(ROOT)/GNUmakefile
 8 | 
 9 | # 
10 | # Swig interfaces.  Requires Swig >= 3.0.5
11 | # 
12 | # Find Python.h, libraries
13 | # 
14 | # On Mac:
15 | #   /usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/include/python2.7/Python.h
16 | #   $ python -e "import os; print os.__file__"
17 | #   /usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/lib/python2.7/os.pyc
18 | #  - Library:
19 | #   /usr/local//Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/lib/python2.7/config/libpython2.7.a
20 | # On Linux:
21 | #   /usr/include/python2.7/Python.h
22 | #   $ python -e "import os; print os.__file__"
23 | #   /usr/lib/python2.7/os.pyc
24 | # 
25 | PYTHON_INC	= $(shell python3 -c 'import os; segs=os.__file__.split( os.path.sep ); print( os.path.sep.join( segs[:-3]+["include"]+segs[-2:-1] ))' )
26 | PYTHON_LIB	= $(shell python3 -c 'import os, glob; segs=os.__file__.split( os.path.sep ); print( glob.glob( os.path.sep.join( segs[:-1]+["config*/"] ))[0] )' )
27 | #PYTHON_INC	= $(shell python -c 'import os; segs=os.__file__.split( os.path.sep ); print os.path.sep.join( segs[:-3]+["include"]+segs[-2:-1] )' )
28 | #PYTHON_LIB	= $(shell python -c 'import os; segs=os.__file__.split( os.path.sep ); print os.path.sep.join( segs[:-1]+["config"] )' )
29 | 
30 | PYTHON_COMP	= -I$(PYTHON_INC) -fPIC $(INCLUDE)
31 | PYTHON_LINK	= -L$(PYTHON_LIB) -lpython3.10 -shared
32 | 
33 | python-ezcod:		_ezcod.so
34 | 
35 | python-ezcod-test:	runme.py python-ezcod
36 | 	python3 $<
37 | 
38 | python-ezcod-clean:
39 | 	rm -f *.cpp *.o *.so *.pyc
40 | 
41 | # Forces re-build of Swig-generated code (if desired)
42 | python-ezcod-pristine: python-ezcod-clean
43 | 	rm -f ezcod_wrap.cpp ezcod.py
44 | 
45 | ezcod_wrap.cpp:		ezcod.i
46 | 	swig -verbose -c++ $(INCLUDE) -python -py3 -o $@ $<
47 | 
48 | ezcod_wrap.o:		ezcod_wrap.cpp
49 | 	$(CXX) $(CXXFLAGS) $(PYTHON_COMP) -c $<
50 | 
51 | _ezcod.so:		ezcod_wrap.o
52 | 	$(CXX) $(CXXFLAGS) $(PYTHON_LINK) -o $@ $<
53 | 


--------------------------------------------------------------------------------
/swig/python/ezcod/__init__.py:
--------------------------------------------------------------------------------
 1 | 
 2 | #
 3 | # Ezpwd-reed-solomon -- Reed-Solomon Codec and utilities
 4 | #
 5 | # Copyright (c) 2015, Hard Consulting Corporation.
 6 | #
 7 | # Ezpwd-reed-solomon is free software: you can redistribute it and/or modify it
 8 | # under the terms of the GNU General Public License as published by the Free
 9 | # Software Foundation, either version 3 of the License, or (at your option) any
10 | # later version.  See the LICENSE file at the top of the source tree.
11 | #
12 | # Ezpwd-reed-solomon is distributed in the hope that it will be useful, but
13 | # WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 | # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
15 | # details.
16 | #
17 | 
18 | from __future__ import absolute_import, print_function, division
19 | 
20 | __author__                      = "Perry Kundert"
21 | __email__                       = "perry@hardconsulting.com"
22 | __copyright__                   = "Copyright (c) 2015 Hard Consulting Corporation"
23 | __license__                     = "Dual License: GPLv3 (or later) and Commercial (see LICENSE)"
24 | 
25 | # These modules form the public interface of ezpwd_reed_solomon.ezcod
26 | from .ezcod import *
27 | 


--------------------------------------------------------------------------------
/swig/python/ezcod/ezcod.i:
--------------------------------------------------------------------------------
 1 | %module ezcod
 2 | 
 3 | %{
 4 | #include "ezpwd/ezcod"
 5 | #include "ezpwd/serialize_definitions"
 6 | %}
 7 | 
 8 | %include std_string.i
 9 | %include std_pair.i
10 | 
11 | %ignore ::operator<<;
12 | %ignore *::output;
13 | %ignore *::symbols;
14 | 
15 | %include "exception.i"
16 | 
17 | %exception {
18 |     try {
19 |         $action
20 |     } catch ( const std::exception &e ) {
21 |         SWIG_exception( SWIG_RuntimeError, e.what() );
22 |     }
23 | }
24 | 
25 | %include ezpwd/ezcod
26 | 
27 | %extend ezpwd::ezcod {
28 |     std::string		        __repr__()
29 |     {
30 | 	std::ostringstream	oss;
31 | 	oss << '<';
32 | 	$self->output( oss );
33 | 	oss << '>';
34 | 	return oss.str();
35 |     }
36 |     std::string		        __str__()
37 |     {
38 | 	return $self->encode( $self->precision ); // default to same precision as supplied
39 |     }
40 | };
41 | 
42 | // Define the EZCOD Python API classes available
43 | %template(ezcod_3_10)		ezpwd::ezcod<1,9>;
44 | %template(ezcod_3_11)		ezpwd::ezcod<2,9>;
45 | %template(ezcod_3_12)		ezpwd::ezcod<3,9>;
46 | 
47 | // Add more ezcod_... variants, here:
48 | // eg. 20mm accuracy and up to 5-nines certainty, in 15 symbols:
49 | //%template(ezcod_20mm_13)	ezpwd::ezcod<1,12>;
50 | //%template(ezcod_20mm_14)	ezpwd::ezcod<2,12>;
51 | //%template(ezcod_20mm_15)	ezpwd::ezcod<3,12>;
52 | 


--------------------------------------------------------------------------------
/swig/python/ezcod/runme.py:
--------------------------------------------------------------------------------
 1 | # file: runme.py
 2 | from __future__ import print_function
 3 | import ezcod
 4 | 
 5 | print( "ezcod_3_10 from EZCOD:   %r" % (	# The repr...
 6 |     ezcod.ezcod_3_10( "R3U 1JU QUY.0" )))
 7 | print( "ezcod_3_10 from lat/lon: %r" % (
 8 |     ezcod.ezcod_3_10( 53.655832, -113.62543, 9, 99, ezcod.ezcod_3_10.SEP_BANG, ezcod.ezcod_3_10.CHK_DASH )))
 9 | print( "ezcod_3_10 from lat/lon: %r" % (	 # Just the EZCOD string this time
10 |     ezcod.ezcod_3_10( 53.655832, -113.62543, 9,  4, ezcod.ezcod_3_10.SEP_BANG, ezcod.ezcod_3_10.CHK_DASH ).encode( 12 )))
11 | 
12 | ec				= ezcod.ezcod_3_10( "R3U 1JU QUY.0" )
13 | print( dir( ec ))
14 | print( ec )
15 | print( ec, "confidence: %r" % ec.confidence )
16 | print( ec, "latitude:   %r" % ec.latitude )
17 | print( ec, "longitude:  %r" % ec.longitude )
18 | print( ec, "lat. error: %r" % ec.latitude_error )
19 | print( ec, "lon. error: %r" % ec.longitude_error )
20 | print( ec, "accuracy:   %r" % ec.accuracy )
21 | print( ec, "precision:  %r" % ec.precision )
22 | print( ec, "separator:  %r" % ec.separator )
23 | print( ec, "chunk:      %r" % ec.chunk )
24 | print( ec, "space:      %r" % ec.space )
25 | 
26 | print( ec, "PRECISION:  %r" % ec.PRECISION )
27 | print( ec, "CHUNK:      %r" % ec.CHUNK )
28 | 
29 | print( ec, "SEP_NONE:   %r" % ec.SEP_NONE )
30 | print( ec, "SEP_DEFAULT:%r" % ec.SEP_DEFAULT )
31 | print( ec, "SEP_SPACE:  %r" % ec.SEP_SPACE )
32 | print( ec, "SEP_DOT:    %r" % ec.SEP_DOT )
33 | print( ec, "SEP_BANG:   %r" % ec.SEP_BANG )
34 | 
35 | print( ec, "CHK_NONE:   %r" % ec.CHK_NONE )
36 | print( ec, "CHK_DEFAULT:%r" % ec.CHK_DEFAULT )
37 | print( ec, "CHK_SPACE:  %r" % ec.CHK_SPACE )
38 | print( ec, "CHK_DASH:   %r" % ec.CHK_DASH )
39 | 
40 | ec.latitude			=   53.555539
41 | ec.longitude			= -113.873870
42 | print( ec, "w/20mm acc: %r" % ec.encode( 12 ))
43 | ec.precision			= 12
44 | print( ec, " permanent: %r" % ec.encode())
45 | print( ec, "Accuracy:   %r" % ec.accuracy )
46 | print( ec, "Precision:  %r" % ec.precision )
47 | 
48 | 


--------------------------------------------------------------------------------
/swig/python/requirements.txt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pjkundert/ezpwd-reed-solomon/62a490c13f6e057fbf2dc6777fde234c7a19098e/swig/python/requirements.txt


--------------------------------------------------------------------------------
/swig/python/setup.py:
--------------------------------------------------------------------------------
 1 | from setuptools import setup, Extension
 2 | import os, sys
 3 | 
 4 | here				= os.path.abspath( os.path.dirname( __file__ ))
 5 | 
 6 | __version__			= None
 7 | __version_info__		= None
 8 | exec( open( 'version.py', 'r' ).read() )
 9 | 
10 | install_requires		= open( os.path.join( here, "requirements.txt" )).readlines()
11 | 
12 | ezcod_module			= Extension(
13 |     "_ezcod",
14 |     sources			= [
15 |         "ezcod/ezcod.i",
16 |     ],
17 |     include_dirs		= [ "../../c++" ],
18 |     swig_opts			= [ "-c++",
19 |                                       "-I./ezcod",
20 |                                       "-I../../c++",
21 |                                     "-outdir",
22 |                                       "ezcod" ],
23 |     extra_compile_args		= [ "-std=c++11", "-O3" ],
24 |     libraries			= []
25 | )
26 | 
27 | bch_module			= Extension(
28 |     "_BCH",
29 |     sources			= [
30 |         "BCH/BCH.i",
31 |     ],
32 |     include_dirs		= [ "../../c++",
33 |                                     "../../c++/ezpwd/bch_include" ],
34 |     swig_opts			= [ "-c++",
35 |                                       "-I./BCH",
36 |                                       "-I../../c++",
37 |                                       "-I../../c++/ezpwd/bch_include",
38 |                                     "-outdir",
39 |                                       "BCH" ],
40 |     extra_objects		= [ "../../djelic_bch.o" ],
41 |     extra_compile_args		= [ "-std=c++11", "-O3" ],
42 |     extra_link_args		= [ "-std=c++11", "-O3" ],
43 |     libraries			= []
44 | )
45 | 
46 | setup(
47 |     name			= "ezpwd_reed_solomon",
48 |     version			= __version__,
49 |     tests_require		= [ "pytest" ],
50 |     author			= "Perry Kundert",
51 |     author_email		= "perry@hardconsulting.com",
52 |     url				= "https://github.com/pjkundert/ezpwd_reed_solomon",
53 |     description			= """Python bindings for ezpwd_reed_solomon ezcod, BCH""",
54 |     ext_modules			= [ ezcod_module, bch_module ],
55 |     packages			= [
56 |         "ezpwd_reed_solomon",
57 |         "ezpwd_reed_solomon/ezcod",
58 |         "ezpwd_reed_solomon/BCH"
59 |     ],
60 |     package_dir			= {
61 |         "ezpwd_reed_solomon":		".",
62 |         "ezpwd_reed_solomon/ezcod":	"./ezcod",
63 |         "ezpwd_reed_solomon/BCH":	"./BCH",
64 |     },
65 |     install_requires		= install_requires,
66 |     license			= "Dual License; GPLv3 and Proprietary",
67 |     keywords			= "ezpwd ezcod reed-solomon error erasure correction",
68 |     classifiers			= [
69 |         "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
70 |         "License :: Other/Proprietary License",
71 |         "Programming Language :: Python :: 2.7",
72 |         "Programming Language :: Python :: 3.10",
73 |         "Development Status :: 5 - Production/Stable",
74 |         "Intended Audience :: Developers",
75 |         "Environment :: Console",
76 |         "Environment :: Web Environment",
77 |         "Topic :: Scientific/Engineering :: Interface Engine/Protocol Translator",
78 |         "Topic :: Text Processing :: Filters"
79 |     ],
80 | )
81 | 


--------------------------------------------------------------------------------
/swig/python/std_map/GNUmakefile:
--------------------------------------------------------------------------------
 1 | 
 2 | PYTHON_INC	= $(shell python -c 'import os; segs=os.__file__.split( os.path.sep ); print os.path.sep.join( segs[:-3]+["include"]+segs[-2:-1] )' )
 3 | PYTHON_LIB	= $(shell python -c 'import os; segs=os.__file__.split( os.path.sep ); print os.path.sep.join( segs[:-1]+["config"] )' )
 4 | 
 5 | PYTHON_COMP	= -I$(PYTHON_INC) -fPIC
 6 | PYTHON_LINK	= -L$(PYTHON_LIB) -lpython2.7 -dynamiclib
 7 | 
 8 | std_map:		_example.so
 9 | 
10 | std_map-test:		runme.py std_map
11 | 	python $<
12 | 
13 | std_map-clean:
14 | 	rm -f *.cxx *.o *.so *.pyc example.py
15 | 
16 | example_wrap.cxx:	example.i
17 | 	swig -verbose -c++ -python $<
18 | 
19 | example_wrap.o:		example_wrap.cxx
20 | 	$(CXX) $(CXXFLAGS) $(PYTHON_COMP) -c $<
21 | 
22 | _example.so:		example_wrap.o
23 | 	$(CXX) $(CXXFLAGS) $(PYTHON_LINK) -o $@ $<
24 | 


--------------------------------------------------------------------------------
/swig/python/std_map/example.h:
--------------------------------------------------------------------------------
 1 | /* File : example.h */
 2 | 
 3 | #include <map>
 4 | #include <string>
 5 | 
 6 | template<class Key, class Value>
 7 | std::map<Key,Value> half_map(const std::map<Key,Value>& v) {
 8 |   typedef typename std::map<Key,Value>::const_iterator iter;  
 9 |   std::map<Key,Value> w;
10 |   for (iter i = v.begin(); i != v.end(); ++i) {
11 |     w[i->first] = (i->second)/2;
12 |   }  
13 |   return w;
14 | }
15 | 
16 | 
17 | 
18 | 


--------------------------------------------------------------------------------
/swig/python/std_map/example.i:
--------------------------------------------------------------------------------
 1 | /* File : example.i */
 2 | %module example
 3 | 
 4 | %{
 5 | #include "example.h"
 6 | %}
 7 | 
 8 | %include std_string.i
 9 | %include std_pair.i
10 | %include std_map.i
11 | 
12 | /* instantiate the required template specializations */
13 | namespace std {
14 |   /* remember to instantiate the key,value pair! */
15 |   %template(DoubleMap) map<std::string,double>;
16 |   %template() map<std::string,int>;
17 | }
18 | 
19 | /* Let's just grab the original header file here */
20 | %include "example.h"
21 | 
22 | %template(halfd) half_map<std::string,double>;
23 | %template(halfi) half_map<std::string,int>;
24 | 
25 | 
26 | %template() std::pair<swig::SwigPtr_PyObject, swig::SwigPtr_PyObject>;
27 | %template(pymap) std::map<swig::SwigPtr_PyObject, swig::SwigPtr_PyObject>;
28 | 


--------------------------------------------------------------------------------
/swig/python/std_map/runme.py:
--------------------------------------------------------------------------------
 1 | # file: runme.py
 2 | 
 3 | import example
 4 | 
 5 | pmap = example.pymap()
 6 | pmap["hi"] = 1
 7 | pmap["hello"] = 2
 8 | 
 9 | 
10 | 
11 | 
12 | dmap = {}
13 | dmap["hello"] = 1.0
14 | dmap["hi"] = 2.0
15 | 
16 | print dmap.items()
17 | print dmap.keys()
18 | print dmap.values()
19 | 
20 | print dmap
21 | hmap = example.halfd(dmap)
22 | dmap = hmap
23 | 
24 | print dmap
25 | for i in dmap.iterkeys():
26 |     print "key", i
27 | 
28 | for i in dmap.itervalues():
29 |     print "val", i
30 | 
31 | for k,v in dmap.iteritems():
32 |     print "item", k,v
33 | 
34 | dmap = example.DoubleMap()
35 | dmap["hello"] = 1.0
36 | dmap["hi"] = 2.0
37 | 
38 | for i in dmap.iterkeys():
39 |     print "key", i
40 | 
41 | for i in dmap.itervalues():
42 |     print "val", i
43 | 
44 | for k,v in dmap.iteritems():
45 |     print "item", k,v
46 | 
47 | 
48 | print dmap.items()
49 | print dmap.keys()
50 | print dmap.values()
51 | 
52 | hmap = example.halfd(dmap)
53 | print hmap.keys()
54 | print hmap.values()
55 | 
56 | 
57 | 
58 | dmap = {}
59 | dmap["hello"] = 2
60 | dmap["hi"] = 4
61 | 
62 | hmap = example.halfi(dmap)
63 | print hmap
64 | print hmap.keys()
65 | print hmap.values()
66 | 
67 | 
68 | dmap = hmap
69 | 
70 | for i in dmap.iterkeys():
71 |     print "key", i
72 | 
73 | for i in dmap.itervalues():
74 |     print "val", i
75 | 
76 | for i in dmap.iteritems():
77 |     print "item", i
78 | 
79 | for k,v in dmap.iteritems():
80 |     print "item", k,v
81 | 
82 | print dmap
83 | 


--------------------------------------------------------------------------------
/swig/python/version.py:
--------------------------------------------------------------------------------
1 | __version_info__		= (2, 1, 0)
2 | __version__			= ".".join( map( str, __version_info__ ))
3 | 


--------------------------------------------------------------------------------
/units-test.C:
--------------------------------------------------------------------------------
  1 | 
  2 | // 
  3 | // units-test.C		-- UNITS unit tests
  4 | // 
  5 | 
  6 | /*
  7 |  * Ezpwd Reed-Solomon -- Reed-Solomon encoder / decoder library
  8 |  * 
  9 |  * Copyright (c) 2022, Dominion Research & Development Corp.
 10 |  *
 11 |  * Ezpwd Reed-Solomon is free software: you can redistribute it and/or modify it under the terms of
 12 |  * the GNU General Public License as published by the Free Software Foundation, either version 3 of
 13 |  * the License, or (at your option) any later version.  See the LICENSE file at the top of the
 14 |  * source tree.  Ezpwd Reed-Solomon is also available under Commercial license.  The Djelic BCH code
 15 |  * under djelic/ and the c++/ezpwd/bch_base wrapper is redistributed under the terms of the GPLv2+,
 16 |  * regardless of the overall licensing terms.
 17 |  * 
 18 |  * Ezpwd Reed-Solomon is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 19 |  * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
 20 |  * the GNU General Public License for more details.
 21 |  */
 22 | 
 23 | #include <ezpwd/units>
 24 | #include <ezpwd/cut>
 25 | 
 26 | #include <iostream>
 27 | #include <algorithm>
 28 | #include <string>
 29 | #include <fstream>
 30 | #include <sstream>
 31 | #include <exception>
 32 | #include <set>
 33 | #include <deque>
 34 | #include <map>
 35 | 
 36 | #if defined( __GNUC__ )
 37 | #  define UNUSED		__attribute__(( unused ))
 38 | #else
 39 | #  define UNUSED
 40 | #endif
 41 | 
 42 | 
 43 | #if defined( TESTSTANDALONE )
 44 | 
 45 | // Standalone test suite, if TESTSTANDALONE is defined.  
 46 | namespace cut {
 47 |     test			root( "Root UNITS unit test suite" );
 48 | };
 49 | 
 50 | int				main( 
 51 | 				    int			argc,
 52 | 				    char const 	      **argv )
 53 | {
 54 |     // if REQUEST_METHOD environment variable set, assume running as CGI
 55 |     bool			cgi	= getenv( "REQUEST_METHOD" );
 56 |     cut::runner		       *tests;
 57 |     if ( cgi )
 58 | 	tests				= new cut::htmlrunner( std::cout );
 59 |     else
 60 | 	tests				= new cut::runner( std::cout );
 61 | 
 62 |     // run returns true iff all test(s) successful
 63 |     if ( argc > 1 ) { 				// Named tests specified?
 64 | 	for ( int i = 1; i < argc; ++i ) {	// Run each one
 65 | 	    std::cout << "running test: " << argv[i] << std::endl;
 66 | 	    if ( ! tests->run( argv[i] )) {
 67 | 		return 1;
 68 | 	    }
 69 | 	}
 70 |     } else
 71 | 	return ! tests->run();			// Run all tests
 72 | }
 73 | 
 74 | #endif // TESTSTANDALONE
 75 | 
 76 | 
 77 | #if defined( TEST )
 78 | 
 79 | //
 80 | // Unit Tests for Units classes
 81 | // 
 82 | namespace cut {
 83 |     typedef units::type<double>	ud_t;
 84 |     ud_t			ud;
 85 |     ud_t::imperial		impd( ud );
 86 |     ud_t::us			usad( ud );
 87 |     ud_t::binary		bind( ud );
 88 | 
 89 |     typedef units::type<int> ui_t;
 90 | //  ui_t			ui( 1 );		// kg, m, s, etc.
 91 |     ui_t			ui( 100, 1000, 10 );	// decagrams, mm, s, (remaining dimensions are 1 per unit) etc.
 92 |     ui_t::imperial		impi( ui );
 93 |     ui_t::us			usai( ui );
 94 | 
 95 |     CUT( root,		Units_tests, 		"Basic Units tests" ) {
 96 | 	ud_t::Time		t	= ud.Second;
 97 | 	t 			       *= 10;				// mul/div by scalar sensible
 98 | #if ! defined( UNITS_DISABLED )	
 99 | 	assert.ISEQUALDELTA( t.scalar(), 10.0, 0.001 );
100 | #endif
101 | 	t 			       /= 1;
102 | #if ! defined( UNITS_DISABLED )	
103 | 	assert.ISEQUALDELTA( t.scalar(), 10.0, 0.001 );
104 | #endif
105 | 	t 			       += t;				// add/sub in same dimension sensible
106 | #if ! defined( UNITS_DISABLED )	
107 | 	assert.ISEQUALDELTA( t.scalar(), 20.0, 0.001 );
108 | #endif
109 | 	t 			       -= t / 2;
110 | #if ! defined( UNITS_DISABLED )	
111 | 	assert.ISEQUALDELTA( t.scalar(), 10.0, 0.001 );
112 | #endif
113 | 	t			        = - -t;
114 | #if ! defined( UNITS_DISABLED )	
115 | 	assert.ISEQUALDELTA( t.scalar(), 10.0, 0.001 );
116 | #endif
117 | 
118 | 	ud_t::Acceleration	a	= ud.Meter * 10 / ( ud.Second * ud.Second );
119 | 	ud_t::Velocity		v	= a * t;
120 | 	double			kph	= v / ( ud.Meter * 1000 / ud.Hour );
121 | 	assert.ISEQUALDELTA( double( kph ), 360.0, 0.001 );
122 | 
123 | 	ud_t::Mass		m	= ud.Kilogram;
124 | 	ud_t::Force		f	= m * ud.Gravity;		// 1kg at G == approx. 2.2 Pounds
125 | 	assert.ISEQUALDELTA( double( f / impd.Pound ), double( 2.20462 ), 0.0001 );
126 | 
127 | 	ui_t::Mass		mi	= ui.Kilogram;
128 | 	ui_t::Force		fi	= mi * ui.Gravity;
129 | 
130 | #if ! defined( UNITS_DISABLED )	
131 | 	assert.ISEQUAL( int( mi.scalar() ), 	      100 );
132 | 	assert.ISEQUAL( int( fi.scalar() ),    	     9800 );
133 | 	assert.ISEQUAL( ui.Gravity.scalar(), 	       98 );
134 | 	assert.ISEQUAL( impi.Mile.scalar(), 	  1609343 );
135 | 	assert.ISEQUAL( impi.Pound.scalar(),	     4448 );
136 | #endif
137 | 
138 | 	assert.ISEQUAL( int( fi / impi.Pound ), 	2 );
139 | 
140 | 	// Test the copy/assign operators from same dimension, different types.
141 | 	mi				= m;
142 | 	ui_t::Mass		mi2( m );
143 | 	(void)mi2;
144 |     }
145 | 
146 |     CUT( Units_tests,	Units_Bits,		"Data Units tests" ) {
147 | 	ud_t::Unitless		d	= bind.Byte * 388;
148 | 	ud_t::Frequency		r	= d / ( ud.Second * 10 );	// 388 bytes over 10 seconds
149 | 	double			bps	= r / bind.BPS;
150 | 	assert.ISEQUALDELTA( bps, 310.4, 0.001 );
151 | 	double			mbps	= r / bind.MBPS;
152 | 	assert.ISEQUALPERCENT( mbps, 310.4/1024/1024, 0.001 );
153 | 	assert.ISEQUALPERCENT( double( r / ( ud.Mega * bind.BPS )), 310.4/1000/1000, 0.001 );
154 | 
155 | 	ud_t::Unitless		nibble	= ud.Count * 4;
156 | 	assert.ISEQUAL( double( nibble ), 4.0 );
157 | 
158 |     }
159 | 
160 |     CUT( Units_tests,	Units_Speed,		"Units Speed Test" ) {
161 | 
162 | 	// Perform 1M conversions from Acre-Feet / Miles to Miles/Gallon (US and Imperial), and Liters/100KM.
163 | 	for ( int i = 0; i < 1000000; ++i ) {
164 | 	    const ud_t::Length	rod	= impd.Mile / 640;
165 | 	    const ud_t::Area	acre	= rod * impd.Mile;
166 | 
167 | 	    ud_t::Efficiency	afpm	= acre * impd.Feet * i / impd.Mile;
168 | 	    double		lp100km	= afpm / ( ud.Liter / ( ud.Kilo * ud.Meter * 100 ));
169 | 	    assert.ISEQUALPERCENT( lp100km, i * 7.6645e+07, 0.01 );
170 | 	    if ( i ) {							// Undefined for denominator 0..
171 | 		ud_t::Mileage	mpaf	= ud_t::Unitless( 1 ) / afpm;
172 | 		double		mpg	= mpaf / ( impd.Mile / impd.Gallon );
173 | 		assert.ISEQUALPERCENT( mpg, 3.68558e-06 / i, 0.01 );
174 | 
175 | 		mpg			= mpaf / ( impd.Mile / usad.Gallon );
176 | 		assert.ISEQUALPERCENT( mpg, 3.06888e-06 / i, 0.01 );
177 | 	    }
178 | 	}
179 |     }
180 | 
181 | #if ! defined( UNITS_DISABLED )
182 | 
183 | 
184 |     CUT( Units_tests,	Units_Conversion,	"Units conversion" ) {
185 | #if defined( DEBUG )
186 | 	ui_t::Mass		a( ui.Kilogram ); // 1000 g (see above)
187 | 	assert.ISEQUALPERCENT( double(   a          / ui.Kilogram ), double( 1.0  ), 0.001 );
188 | 	assert.ISEQUALPERCENT( double( ( a * 1.49 ) / ui.Kilogram ), double( 1.0  ), 0.001 );	// compiler issues int-double conversion warning (expected)
189 | #endif
190 | 	ud_t::Mass		b( ud.Kilogram ); // 1.0 kg
191 | 	assert.ISEQUALPERCENT( double( ( b * 1.49 ) / ud.Kilogram ), double( 1.49 ), 0.001 );
192 | 
193 | #if 0
194 | 	ud_t::Celsius		c( 20 );
195 | 	assert.ISEQUALDELTA( c.scalar(), 20.0, 0.001 );
196 | 	ud_t::Temperature	k( c );
197 | 	assert.ISEQUALDELTA( k.scalar(), 20.0, 0.001 );
198 | #endif
199 | 
200 | 	// Convert mileage (US Gallons), to MPG (both US and Imperial), and L/100KM.
201 |         typedef units::type<float>
202 |                                 sif_t;                                  // SI Units Types, over float
203 |         sif_t	                sif;                                    // SI Constants
204 |         sif_t::us               usf( sif );                             // US/Imperial Constants
205 |         
206 |         sif_t::Mileage          mileage = usf.Mile * 10 / usf.Gallon;
207 |         float                   mpg     = mileage / usad.MPG;
208 | 
209 |         float                   eff     = sif_t::Unitless( 1 ) / mileage / sif.L_100KM;
210 | 
211 |         assert.ISEQUALDELTA( double( mpg ),     10.0000, 0.001 );
212 |         assert.ISEQUALDELTA( double( eff ),     23.5215, 0.001 );
213 | 
214 |         sif_t::imperial         imf( sif );                             // Imperial Constants
215 |         mpg                                     = mileage / imf.MPG;
216 |         assert.ISEQUALDELTA( double( mpg ),     12.0095, 0.001 );
217 |     }
218 | #endif
219 | }
220 | 
221 | #endif // TEST
222 | 


--------------------------------------------------------------------------------