crc 0.2 → 0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ccf4d480da684a319f684082517b687ec6bd9974
-  data.tar.gz: c97ed329ce7093405e7db797ede21ff6f8d9acbc
+  metadata.gz: 0e420d67c8c057164c47f3fd4a1d6096d28f66a2
+  data.tar.gz: 77ec3196b4ba3164e0659fcffa7a9833e162aa0c
 SHA512:
-  metadata.gz: 2c026e783622209e7fd9ff23783a773a6da6c2514f685c177ade3225b560b9c2db5ebe126e6bedbe98e7a039c24d0974ae73139bf623d771fc47f07cb04b39ce
-  data.tar.gz: a4b27b3b7262c4c46e616048d587c3ae9b809dd104d7e76686f611f830c9f761eccbef0a693cf46acede424205a1984247b351e7f9ef78442fc800489577a68d
+  metadata.gz: 7b313c40122e1ee2d953e8fe07520f7787bbea4af884de0fcea1b92263b4791ed189b70696b8885d19bbf33fb56fdcf0f12412a44ade7e2a5f6f91e57d946421
+  data.tar.gz: 157a966f25728523a2edb3de9bf293f0af0bbc1e6484a0bc7b5db8548f6a34abdb5c599d532c5e7b5a119bd41174161517b81d0cf75c49cccdf2596619adfdb8

data/HISTORY.ja.md

@@ -2,6 +2,28 @@ This document is written in Japanese.
 
 # crc for ruby の更新履歴
 
+## crc-0.3 (平成28年7月31日 日曜日)
+
+互換性を損なう変更があります。
+
+  * CRC::BasicCRC クラスと CRC::Generator クラスを、CRC クラスに統合
+      * ruby オブジェクト CRC をモジュールからクラスに変更しました。
+      * CRC::BasicCRC クラスと CRC::Generator クラスを削除しました。
+      * crc-0.2 まで CRC::BasicCRC の派生クラスだった各 crc モジュールは
+        CRC クラスから派生するようになりました。
+  * CRC.create\_module を削除し、CRC.new に統合
+      * crc-0.2 まであった CRC.create\_module メソッドを削除しました。
+      * CRC.new メソッドが変わりの役割を担うようになりました。
+  * crc モジュールの別名も CRC クラスの定数 (クラスの別名) として追加するように変更
+  * CRC としての整数値を得るメソッドを引数なしで呼び出した場合、CRC モジュールを返すように変更
+      * 例えば ``CRC.crc32`` を引数なしで呼び出すと、CRC::CRC32 クラスオブジェクトが返るようになりました。
+  * CRC-64-ISO の修正
+  * CRC モジュール名の整理
+  * 初期値以外が同じかどうかを確認する CRC.variant? メソッドを追加
+  * ``CRC#initial_crc`` を廃止
+  * 定義が不確かな CRC モジュールを無効化
+  * (実験的) 任意の CRC 値から逆算してバイト列を生成する機能 CRC.acrc (crc/acrc.rb) を追加
+
 ## crc-0.2 (平成28年5月15日 (日))
 
   * CRC モジュールの追加と修正

data/README.md

@@ -7,7 +7,7 @@ It is written by pure ruby with based on slice-by-eight algorithm (slice-by-16 a
 
 Included built-in CRC modules are CRC-32, CRC-64-ECMA, CRC-64-ISO, CRC-16-CCITT, CRC-16-IBM, CRC-8, CRC-5-USB, CRC-5-EPC and many more.
 
-Additional your customized CRC modules are defined to posible.
+Customization is posible for 1 to 64 bit width, any polynomial primitives, and with/without bit reflection input/output.
 
 This library is slower than ×85+ of zlib/crc32, and slower than ×120+ of extlzma/crc32 on FreeBSD 10.3R amd64.
 
@@ -20,51 +20,98 @@ If you need more speed, please use [crc-turbo](https://rubygems/gems/crc-turbo).
   * author: dearblue (mailto:dearblue@users.osdn.me)
   * report issue to: <https://osdn.jp/projects/rutsubo/ticket/>
   * how to install: ``gem install crc``
-  * version: 0.2
-  * release quality: thechnical preview
+  * version: 0.3
+  * release quality: technical preview
   * licensing: BSD-2-Clause<br>any parts are under Creative Commons License Zero (CC0 / Public Domain), and zlib-style License.
   * dependency gems: none
-  * dependency external c libraries: none
-  * bundled external c libraries: none
+  * dependency external C libraries: none
+  * bundled external C libraries: none
 
 
-## Features
+## API Guide
 
-This examples are used CRC-32 module. Please see CRC::BasicCRC for more details.
+This examples are used CRC-32 module. Please see CRC for more details.
 
-  * CRC.crc32(seq, init = 0) -> crc-32 integer (likely as ``Zlib.crc32``)
-  * CRC::CRC32.crc(seq, init = 0) -> crc-32 integer (likely as ``Zlib.crc32``)
-  * CRC::CRC32.digest(seq, init = 0) -> crc-32 digest (likely as ``Digest::XXXX.digest``)
-  * CRC::CRC32.hexdigest(seq, init = 0) -> crc-32 hex-digest (likely as ``Digest::XXXX.hexdigest``)
-  * CRC::CRC32.new(init = 0) -> crc-32 context (likely as ``Digest::XXXX.new``)
-  * CRC::CRC32#update(seq) -> self (likely as ``Digest::XXXX#update``)
-  * CRC::CRC32#state -> crc-32 integer
-  * CRC::CRC32#digest -> crc-32 digest (likely as ``Digest::XXXX#digest``)
-  * CRC::CRC32#hexdigest -> crc-32 hex-digest (likely as ``Digest::XXXX#hexdigest``)
-  * CRC.crc("crc-32", seq, init = 0) -> crc-32 integer
-  * CRC.digest("crc-32", seq, init = 0) -> crc-32 digest
-  * CRC.hexdigest("crc-32", seq, init = 0) -> crc-32 hex-digest
-  * CRC::CRC32.combine(CRC.crc32("123"), CRC.crc32("456789"), 6) -> 3421780262 (likely as ``Zlib.crc32_comibne``)
-  * CRC.CRC32("123") + CRC.CRC32("456") + CRC.CRC32("789") -> &#35;&lt;CRC::CRC32:CBF43926&gt;
+  * Calcurate by direct
 
-----
+      * ``CRC.crc32(seq, init = CRC::CRC32.initial_crc) => crc-32 integer`` (likely as ``Zlib.crc32``)
+      * ``CRC.crc32.crc(seq, init = CRC::CRC32.initial_crc) => crc-32 integer`` (likely as ``Zlib.crc32``)
+      * ``CRC.crc32.digest(seq, init = CRC::CRC32.initial_crc) => crc-32 digest`` (likely as ``Digest::XXXX.digest``)
+      * ``CRC.crc32.hexdigest(seq, init = 0) -> crc-32 hex-digest`` (likely as ``Digest::XXXX.hexdigest``)
+      * ``CRC.crc32[seq, init = 0, current_length = 0] -> crc-32 generator``
+      * ``CRC.crc32.new(seq, init = 0, current_length = 0) -> crc-32 generator``
 
-  * CRC.create\_module(bitsize, poly, init\_state, refin, refout, xorout) -> new crc module class
+  * Calcurate by streaming
+
+      * ``CRC.crc32[init = 0, current_length = 0] => crc-32 generator``
+      * ``CRC.crc32.new(init = 0, current_length = 0) => crc-32 generator``
+      * ``CRC.crc32#update(seq) => self`` (likely as ``Digest::XXXX.update``)
+      * ``CRC.crc32#finish => crc-32 integer`` (likely as ``Digest::XXXX.finish``)
+      * ``CRC.crc32#crc => crc-32 integer`` (same as ``CRC.crc32#finish``)
+      * ``CRC.crc32#digest => crc-32 digest`` (likely as ``Digest::XXXX.digest``)
+      * ``CRC.crc32#hexdigest => crc-32 hex-digest`` (likely as ``Digest::XXXX.hexdigest``)
+
+    Example:
+
+    ``` ruby:ruby
+    x = CRC.crc32.new     # => #<CRC::CRC32:00000000>
+    x.update "123"        # => #<CRC::CRC32:884863D2>
+    x.update "456789"     # => #<CRC::CRC32:CBF43926>
+    x.crc                 # => 3421780262
+    x.digest              # => "\xCB\xF49&"
+    x.hexdigest           # => "CBF43926"
+    ```
+
+  * Combine
+
+      * ``CRC.combine(crc1, crc2, len2) => combined crc integer`` (likely as ``Zlib.crc32_comibne``)
+      * ``CRC#+(right_crc) => combined crc generator``
+
+    Example-1:
+
+    ``` ruby:ruby
+    CRC.crc32.combine(CRC.crc32("123"), CRC.crc32("456789"), 6) # => 3421780262
+    ```
+
+    Example-2:
+
+    ``` ruby:ruby
+    CRC.crc32["123"] + CRC.crc32["456"] + CRC.crc32["789"] # => #<CRC::CRC32:CBF43926>
+    ```
+
+  * Create customized crc module
+
+      * ``CRC.new(bitsize, poly, initial_crc = 0, refin = true, refout = true, xor_output = ~0) => new crc module class``
 
     ``` ruby:ruby
-    MyCRC32 = CRC.create_module(32, 0x04C11DB7)
-    p MyCRC32.class  # => Class
-    p MyCRC32.hexdigest("123456789")  # => "CBF43926"
+    MyCRC32 = CRC.new(32, 0x04C11DB7)
+    MyCRC32.class                     # => Class
+    MyCRC32.hexdigest("123456789")    # => "CBF43926"
+    MyCRC32.new("123456789")          # => #<MyCRC32:CBF43926>
     ```
 
+  * Calcurate arc-crc (***EXPERIMENTAL***)
+
+      * ``CRC.acrc(pre, post = nil, want_crc = 0) => arc-crc byte string``
+
+    ``` ruby:ruby
+    a = "12"
+    c = "789"
+    wantcrc = 0xCBF43926
+    b = CRC.crc32.acrc(a, c, wantcrc)   # => "3456"
+    CRC.crc32[a + b + c]                # => #<CRC::CRC32:CBF43926>
+    ```
+
+    See CRC::ModuleClass.acrc for more detail.
+
 
 ## Built-in CRC modules
 
 ``` shell:shell
-% ruby -rcrc -e 'puts CRC::MODULE_TABLE.values.uniq.map { |m| m::GENERATOR.name }.join(", ")'
+% ruby -rcrc -e 'puts CRC::MODULE_TABLE.values.uniq.map { |m| m.name }.join(", ")'
 ```
 
-CRC-1, CRC-3-ROHC, CRC-4-INTERLAKEN, CRC-4-ITU, CRC-5-EPC, CRC-5-ITU, CRC-5-USB, CRC-6-CDMA2000-A, CRC-6-CDMA2000-B, CRC-6-DARC, CRC-6-ITU, CRC-7, CRC-7-MVB, CRC-7-ROHC, CRC-7-UMTS, CRC-8, CRC-8-CCITT, CRC-8-MAXIM, CRC-8-DARC, CRC-8-SAE, CRC-8-WCDMA, CRC-8-CDMA2000, CRC-8-DVB-S2, CRC-8-EBU, CRC-8-I-CODE, CRC-8-ITU, CRC-8-LTE, CRC-8-ROHC, CRC-10, CRC-10-CDMA2000, CRC-11, CRC-11-UMTS, CRC-12-CDMA2000, CRC-12-DECT, CRC-12-UMTS, CRC-13-BBC, CRC-14-DARC, CRC-15, CRC-15-MPT1327, Chakravarty, ARC, CRC-16-ARINC, CRC-16-AUG-CCITT, CRC-16-CDMA2000, CRC-16-DECT-R, CRC-16-DECT-X, CRC-16-T10-DIF, CRC-16-DNP, CRC-16-BUYPASS, CRC-16-CCITT-FALSE, CRC-16-DDS-110, CRC-16-EN-13757, CRC-16-GENIBUS, CRC-16-LJ1200, CRC-16-MAXIM, CRC-16-MCRF4XX, CRC-16-RIELLO, CRC-16-TELEDISK, CRC-16-TMS37157, CRC-16-USB, CRC-A, KERMIT, MODBUS, X-25, XMODEM, CRC-17-CAN, CRC-21-CAN, CRC-24, CRC-24-Radix-64, CRC-24-OPENPGP, CRC-24-BLE, CRC-24-FLEXRAY-A, CRC-24-FLEXRAY-B, CRC-24-INTERLAKEN, CRC-24-LTE-A, CRC-24-LTE-B, CRC-30, CRC-30-CDMA, CRC-31-PHILIPS, CRC-32, CRC-32-BZIP2, CRC-32C, CRC-32D, CRC-32-MPEG-2, CRC-32-POSIX, CRC-32K, CRC-32K2, CRC-32Q, JAMCRC, XFER, CRC-40-GSM, CRC-64, CRC-64-ECMA, CRC-64-WE, CRC-64-ISO
+CRC-1, CRC-3-ROHC, CRC-4-INTERLAKEN, CRC-4-ITU, CRC-5-EPC, CRC-5-ITU, CRC-5-USB, CRC-6-CDMA2000-A, CRC-6-CDMA2000-B, CRC-6-DARC, CRC-6-ITU, CRC-7, CRC-7-MVB, CRC-7-ROHC, CRC-7-UMTS, CRC-8, CRC-8-CCITT, CRC-8-MAXIM, CRC-8-DARC, CRC-8-SAE, CRC-8-WCDMA, CRC-8-CDMA2000, CRC-8-DVB-S2, CRC-8-EBU, CRC-8-I-CODE, CRC-8-ITU, CRC-8-LTE, CRC-8-ROHC, CRC-10, CRC-10-CDMA2000, CRC-11, CRC-11-UMTS, CRC-12-CDMA2000, CRC-12-DECT, CRC-12-UMTS, CRC-13-BBC, CRC-14-DARC, CRC-15, CRC-15-MPT1327, Chakravarty, CRC-16, CRC-16-ARINC, CRC-16-AUG-CCITT, CRC-16-CDMA2000, CRC-16-DECT-R, CRC-16-DECT-X, CRC-16-T10-DIF, CRC-16-DNP, CRC-16-BUYPASS, CRC-16-CCITT-FALSE, CRC-16-DDS-110, CRC-16-EN-13757, CRC-16-GENIBUS, CRC-16-LJ1200, CRC-16-MAXIM, CRC-16-MCRF4XX, CRC-16-RIELLO, CRC-16-TELEDISK, CRC-16-TMS37157, CRC-16-USB, CRC-16-A, CRC-16-KERMIT, CRC-16-MODBUS, CRC-16-X-25, CRC-16-XMODEM, CRC-17-CAN, CRC-21-CAN, CRC-24, CRC-24-Radix-64, CRC-24-OPENPGP, CRC-24-BLE, CRC-24-FLEXRAY-A, CRC-24-FLEXRAY-B, CRC-24-INTERLAKEN, CRC-24-LTE-A, CRC-24-LTE-B, CRC-30, CRC-30-CDMA, CRC-31-PHILIPS, CRC-32, CRC-32-BZIP2, CRC-32C, CRC-32D, CRC-32-MPEG-2, CRC-32-POSIX, CRC-32K, CRC-32K2, CRC-32Q, CRC-32-JAMCRC, CRC-32-XFER, CRC-40-GSM, CRC-64-XZ, CRC-64-ECMA, CRC-64-WE, CRC-64-ISO
 
 
 ## Environment variables for behavior
@@ -75,6 +122,69 @@ CRC-1, CRC-3-ROHC, CRC-4-INTERLAKEN, CRC-4-ITU, CRC-5-EPC, CRC-5-ITU, CRC-5-USB,
   * ``RUBY_CRC_NOFAST=3``: Switch to reference algorithm from slice-by-16 algorithm. Slower than about 7% (when CRC-32).
 
 
-## About CRC::Generator#combine
+## About CRC.combine
+
+CRC.combine is ported from Mark Adler's crccomb.c in <https://stackoverflow.com/questions/29915764/generic-crc-8-16-32-64-combine-implementation#29928573>.
+
+
+## arc-crc (***EXPERIMENTAL***)
+
+(Written in japanese from here)
+
+crc-0.3 にて、任意の CRC となるバイト列を逆算する機能が***実験的に***追加されました。
+
+今のところは、reflect-input/output 限定となっています。
+
+``require "crc/acrc"`` にて、その機能が利用可能となります。
+
+名前の由来は、arc-sin などの C 関数である asin と同様に、arc-crc => acrc となっています。
+
+以下は使用例です。
+
+  * 文字列 "123456789????" を CRC32 した場合に 0 となるような、???? の部分を逆算する
+
+    ``` ruby:ruby
+    require "crc/acrc"
+
+    seq = "123456789"
+    seq << CRC.crc32.acrc(seq)
+    p CRC.crc32[seq] # => #<CRC::CRC32:00000000>
+    ```
+
+  * 文字列 "123456789????ABCDEFG" の、???? の部分を逆算する
+
+    ``` ruby:ruby
+    require "crc/acrc"
+
+    seq1 = "123456789"
+    seq2 = "ABCDEFG"
+    seq = seq1 + CRC.crc32.acrc(seq1, seq2) + seq2
+    p CRC.crc32[seq] # => #<CRC::CRC32:00000000>
+    ```
+
+  * 文字列 "123456789????ABCDEFG" を CRC32 した場合に 0x12345678 となるような、???? の部分を逆算する
+
+    ``` ruby:ruby
+    require "crc/acrc"
+
+    seq1 = "123456789"
+    seq2 = "ABCDEFG"
+    target_crc = 0x12345678
+    seq = seq1 + CRC.crc32.acrc(seq1, seq2, target_crc) + seq2
+    p CRC.crc32[seq] # => #<CRC::CRC32:12345678>
+    ```
+
+  * 独自仕様の CRC モジュールにも対応
+
+    ``` ruby:ruby
+    require "crc/acrc"
+
+    seq1 = "123456789"
+    seq2 = "ABCDEFG"
+    target_crc = 0x12345678
+    MyCRC = CRC.new(29, rand(1 << 29) | 1)
+    seq = seq1 + MyCRC.acrc(seq1, seq2, target_crc) + seq2
+    p MyCRC[seq] # => #<MyCRC:12345678>
+    ```
 
-CRC::Generator#combine is ported from Mark Adler's crccomb.c in https://stackoverflow.com/questions/29915764/generic-crc-8-16-32-64-combine-implementation#29928573 .
+[EOF]

data/benchmark.rb

@@ -9,8 +9,9 @@ require "zlib"
 require "crc"
 begin; require "extlzma"; rescue LoadError; no_extlzma = true; end
 begin; require "digest/crc"; rescue LoadError; no_digest_crc = true; end
+begin; require "crc32"; rescue LoadError; no_crc32 = true; end
 
-def measure(generator_name)
+def measure(size, generator_name)
   print "  * measuring for #{generator_name}..."
   $stdout.flush
   realms = 5.times.map do
@@ -19,7 +20,7 @@ def measure(generator_name)
     $stdout.flush
     real
   end.min
-  puts " (#{(realms * 100).round / 100.0} ms.)\n"
+  printf " (%.2f ms.) (peak: %0.2f MiB / s)\n", realms, size / (realms / 1000)
   [generator_name, realms]
 end
 
@@ -38,17 +39,22 @@ puts " ** preparing #{size} MiB data...\n"
 #s = SecureRandom.random_bytes(size << 20)
 s = "0" * (size << 20)
 
-crc = measure("ruby-crc/crc32") { CRC.crc32(s) }[1]
+crc = measure(size, "crc/crc32") { CRC.crc32(s) }[1]
 comparisons = []
-comparisons << measure("zlib/crc-32") { Zlib.crc32(s) }
-comparisons << measure("extlzma/crc-32") { LZMA.crc32(s) } unless no_extlzma
-comparisons << measure("digest/crc-32") { Digest::CRC32.digest(s) } unless no_digest_crc
-comparisons << measure("ruby-crc/crc-64") { CRC.crc64(s) }
-comparisons << measure("extlzma/crc-64") { LZMA.crc64(s) } unless no_extlzma
+comparisons << measure(size, "zlib/crc-32") { Zlib.crc32(s) }
+comparisons << measure(size, "extlzma/crc-32") { LZMA.crc32(s) } unless no_extlzma
+comparisons << measure(size, "digest/crc-32") { Digest::CRC32.digest(s) } unless no_digest_crc
+comparisons << measure(size, "crc32/crc-32") { Crc32.calculate(s, s.bytesize, 0) } unless no_crc32
+comparisons << measure(size, "crc/crc-64") { CRC.crc64(s) }
+comparisons << measure(size, "extlzma/crc-64") { LZMA.crc64(s) } unless no_extlzma
+comparisons << measure(size, "crc/crc-5-usb") { CRC.crc5_usb(s) }
+comparisons << measure(size, "crc/crc-16-usb") { CRC.crc16_usb(s) }
+comparisons << measure(size, "crc/crc-32-posix") { CRC.crc32_posix(s) }
+comparisons << measure(size, "crc/crc-32c") { CRC.crc32c(s) }
 
 puts <<'EOS'
 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-                                          (slowly at over 1.0)
+                             (ruby-crc/crc32 is slowly at over 1.0)
 EOS
 
 comparisons.each do |name, meas|

data/gemstub.rb

@@ -1,12 +1,13 @@
+require_relative "lib/crc/version"
+
 GEMSTUB = Gem::Specification.new do |s|
   s.name = "crc"
-  s.version = "0.2"
+  s.version = CRC::VERSION
   s.summary = "general CRC generator"
   s.description = <<EOS
 This is a general CRC (Cyclic Redundancy Check) generator for ruby.
-It is written by pure ruby with based on slice-by-eight algorithm (slice-by-16 algorithm as byte-order free and byte-alignment free).
-Included built-in CRC modules are CRC-32, CRC-64-XZ, CRC-64-ECMA, CRC-64-ISO, CRC-16-CCITT, CRC-16-IBM, CRC-8, CRC-5-USB, CRC-5-EPC and many more.
-Additional your customized CRC modules are defined to posible.
+It is written by pure ruby.
+Customization is posible for 1 to 64 bit width, any polynomial primitives, and with/without bit reflection input/output.
 If you need more speed, please use crc-turbo.
 EOS
   s.homepage = "https://osdn.jp/projects/rutsubo/"
@@ -15,7 +16,7 @@ EOS
   s.email = "dearblue@users.osdn.me"
 
   s.required_ruby_version = ">= 2.0"
-  s.add_development_dependency "rake", "~> 11.0"
+  s.add_development_dependency "rake"
 end
 
 EXTRA << "benchmark.rb"

data/lib/crc.rb

@@ -10,6 +10,8 @@ else
   end
 end
 
+require_relative "crc/version"
+
 #
 # This is a general CRC generator.
 #
@@ -30,15 +32,18 @@ end
 #       crc32 << s
 #     end
 #     p crc32           # => #<CRC::CRC32:6A632AA5>
-#     p crc32.state     # => 1784883877
+#     p crc32.crc       # => 1784883877
 #     p crc32.digest    # => "jc*\xA5"
 #     p crc32.hexdigest # => "6A632AA5"
 #
-module CRC
+class CRC
   CRC = self
 
   extend Utils
 
+  #
+  # Utilities.
+  #
   module Utils
     extend self
 
@@ -141,20 +146,23 @@ module CRC
 
   extend Utils
 
+  #
+  # Internal using module.
+  #
   module Aux
-    def self.DIGEST(state, bitsize)
+    def self.DIGEST(num, bitsize)
       bits = (bitsize + 7) / 8 * 8
-      seq = "".b
-      (bits - 8).step(0, -8) { |i| seq << yield((state >> i) & 0xff) }
+      seq = ""
+      (bits - 8).step(0, -8) { |i| seq << yield((num >> i) & 0xff) }
       seq
     end
 
-    def self.digest(state, bitsize)
-      DIGEST(state, bitsize) { |n| [n].pack("C") }
+    def self.digest(num, bitsize)
+      DIGEST(num, bitsize) { |n| n.chr(Encoding::BINARY) }
     end
 
-    def self.hexdigest(state, bitsize)
-      DIGEST(state, bitsize) { |n| "%02X" % n }
+    def self.hexdigest(num, bitsize)
+      DIGEST(num, bitsize) { |n| "%02X" % n }
     end
 
     #
@@ -174,34 +182,75 @@ module CRC
     end
   end
 
-  class Generator
-    def crc(seq, state = nil)
-      finish(update(seq, setup(state)))
+  module ModuleClass
+    def setup(crc = nil)
+      crc ||= initial_crc
+      crc = CRC.bitreflect(crc, bitsize) if reflect_input? ^ reflect_output?
+      crc ^ xor_output
     end
 
-    def setup(state = nil)
-      state ||= initial_state
-      state = CRC.bitreflect(state, bitsize) if reflect_input ^ reflect_output
-      state ^ xor_output
-    end
+    alias init setup
 
     def finish(state)
-      state = CRC.bitreflect(state, bitsize) if reflect_input ^ reflect_output
+      state = CRC.bitreflect(state, bitsize) if reflect_input? ^ reflect_output?
       state ^ xor_output
     end
 
-    alias reflect_input? reflect_input
-    alias reflect_output? reflect_output
+    def crc(seq, crc = nil)
+      finish(update(seq, setup(crc)))
+    end
 
-    def digest(seq, state = nil)
-      Aux.digest(crc(seq, state), bitsize)
+    def digest(seq, crc = nil)
+      Aux.digest(crc(seq, crc), bitsize)
     end
 
-    def hexdigest(seq, state = nil)
-      Aux.hexdigest(crc(seq, state), bitsize)
+    def hexdigest(seq, crc = nil)
+      Aux.hexdigest(crc(seq, crc), bitsize)
     end
 
-    def to_s
+    def variant?(obj)
+      case
+      when obj.kind_of?(CRC)
+        mod = obj.class
+      when obj.kind_of?(Class) && obj < CRC
+        mod = obj
+      else
+        return false
+      end
+
+      if bitsize == mod.bitsize &&
+         polynomial == mod.polynomial &&
+         reflect_input? == mod.reflect_input? &&
+         reflect_output? == mod.reflect_output? &&
+         xor_output == mod.xor_output
+        true
+      else
+        false
+      end
+    end
+
+    #
+    # call-seq:
+    #   combine(crc1, crc2) -> new combined crc
+    #   combine(crc1_int, crc2_int, crc2_len) -> new combined crc
+    #
+    def combine(*args)
+      case args.size
+      when 2
+        unless args[0].kind_of?(CRC) && args[1].kind_of?(CRC)
+          raise ArgumentError, "When given two arguments, both arguments are should be CRC instance"
+        end
+
+        crc1 + crc2
+      when 3
+        Aux.combine(Integer(args[0].to_i), Integer(args[1].to_i), Integer(args[2].to_i),
+                    bitsize, polynomial, initial_crc, reflect_input?, reflect_output?, xor_output)
+      else
+        raise ArgumentError, "wrong number of arguments (given #{args.size}, expect 2..3)"
+      end
+    end
+
+    def to_str
       case
       when bitsize > 64 then width = 20
       when bitsize > 32 then width = 16
@@ -210,17 +259,17 @@ module CRC
       else                   width =  2
       end
 
-      if reflect_input
-        ref = ", reflect-in#{reflect_output ? "/out" : ""}"
+      if reflect_input?
+        ref = " reflect-in#{reflect_output? ? "/out" : ""}"
       else
-        ref = reflect_output ? ", reflect-out" : ""
+        ref = reflect_output? ? " reflect-out" : ""
       end
 
-      case initial_state
+      case initial_crc
       when 0        then init = "0"
       when bitmask  then init = "~0"
       when 1        then init = "1"
-      else               init = "0x%0#{width}X" % initial_state
+      else               init = "0x%0#{width}X" % initial_crc
       end
 
       case xor_output
@@ -230,15 +279,11 @@ module CRC
       else               xor = "0x%0#{width}X" % xor_output
       end
 
-      if nm = name
-        "#{nm}(CRC-%d-0x%0#{width}X%s init=%s, xor=%s)" % [bitsize, polynomial, ref, init, xor]
-      else
-        "(CRC-%d-0x%0#{width}X%s init=%s, xor=%s)" % [bitsize, polynomial, ref, init, xor]
-      end
+      "CRC-%d-0x%0#{width}X%s init=%s xor=%s" % [bitsize, polynomial, ref, init, xor]
     end
 
     def inspect
-      "\#<#{self.class} #{to_s}>"
+      "#{super}{#{to_str}}"
     end
 
     def pretty_inspect(q)
@@ -246,189 +291,136 @@ module CRC
     end
   end
 
-  class BasicCRC < Struct.new(:internal_state, :initial_state, :size)
-    BasicStruct = superclass
-
-    class BasicStruct
-      alias state! internal_state
-      alias set_state! internal_state=
-    end
+  attr_accessor :state, :size
 
-    #
-    # call-seq:
-    #   initialize(initial_state = nil, size = 0)
-    #   initialize(seq, initial_state = nil, size = 0)
-    #
-    def initialize(*args)
-      initialize_args(args) do |seq, initial_state, size|
-        g = self.class::GENERATOR
-        initial_state ||= g.initial_state
-        super g.setup(initial_state.to_i), initial_state.to_i, size.to_i
-        update(seq) if seq
-      end
+  #
+  # call-seq:
+  #   initialize(initial_crc = nil, size = 0)
+  #   initialize(seq, initial_crc = nil, size = 0)
+  #
+  def initialize(*args)
+    initialize_args(args) do |seq, initial_crc, size|
+      m = self.class
+      @state = m.setup((initial_crc || m.initial_crc).to_i)
+      @size = size.to_i
+      update(seq) if seq
     end
+  end
 
-    def reset(initial_state = self.initial_state, size = 0)
-      g = self.class::GENERATOR
-      initial_state ||= g.initial_state
-      set_state! g.setup(initial_state)
-      self.initial_state = initial_state
-      self.size = size.to_i
-      self
-    end
+  def reset(initial_crc = nil, size = 0)
+    m = self.class
+    @state = m.setup((initial_crc || m.initial_crc).to_i)
+    @size = size.to_i
+    self
+  end
 
-    def update(seq)
-      set_state! self.class::GENERATOR.update(seq, state!)
-      self.size += seq.bytesize
-      self
-    end
+  def update(seq)
+    @state = self.class.update(seq, state)
+    @size += seq.bytesize
+    self
+  end
 
-    alias << update
+  alias << update
 
-    def state
-      self.class::GENERATOR.finish(state!)
-    end
+  def crc
+    self.class.finish(state)
+  end
 
-    def +(crc2)
-      raise ArgumentError, "not a CRC instance (#{crc2.inspect})" unless crc2.kind_of?(BasicCRC)
-      c1 = self.class
-      g1 = c1::GENERATOR
-      g2 = crc2.class::GENERATOR
-      unless g1.bitsize == g2.bitsize &&
-             g1.polynomial == g2.polynomial &&
-             g1.reflect_input == g2.reflect_input &&
-             g1.reflect_output == g2.reflect_output &&
-             # g1.initial_state == g2.initial_state &&
-             g1.xor_output == g2.xor_output
-        raise ArgumentError, "different CRC module (#{g1.inspect} and #{g2.inspect})"
-      end
-      c1.new(g1.combine(state, crc2.state, crc2.size), size + crc2.size)
-    end
+  def +(crc2)
+    raise ArgumentError, "not a CRC instance (#{crc2.inspect})" unless crc2.kind_of?(CRC)
+    m1 = self.class
+    m2 = crc2.class
+    unless m1.bitsize == m2.bitsize &&
+           m1.polynomial == m2.polynomial &&
+           m1.reflect_input? == m2.reflect_input? &&
+           m1.reflect_output? == m2.reflect_output? &&
+           # m1.initial_crc == m2.initial_crc &&
+           m1.xor_output == m2.xor_output
+      raise ArgumentError, "different CRC module (#{m1.inspect} and #{m2.inspect})"
+    end
+    m1.new(m1.combine(crc, crc2.crc, crc2.size), size + crc2.size)
+  end
 
-    def ==(a)
-      case a
-      when BasicCRC
-        c1 = self.class
-        g1 = c1::GENERATOR
-        g2 = a.class::GENERATOR
-        if g1.bitsize == g2.bitsize &&
-           g1.polynomial == g2.polynomial &&
-           g1.reflect_input == g2.reflect_input &&
-           g1.reflect_output == g2.reflect_output &&
-           # g1.initial_state == g2.initial_state &&
-           g1.xor_output == g2.xor_output &&
-           state! == a.state!
-          true
-        else
-          false
-        end
-      when Integer
-        state == a
+  def ==(a)
+    case a
+    when CRC
+      m1 = self.class
+      m2 = a.class
+      if m1.bitsize == m2.bitsize &&
+         m1.polynomial == m2.polynomial &&
+         m1.reflect_input? == m2.reflect_input? &&
+         m1.reflect_output? == m2.reflect_output? &&
+         # m1.initial_crc == m2.initial_crc &&
+         m1.xor_output == m2.xor_output &&
+         state == a.state
+        true
       else
-        super
+        false
       end
+    when Integer
+      crc == a
+    else
+      super
     end
+  end
 
-    alias to_i state
-    alias to_int state
-
-    def to_a
-      [state]
-    end
-
-    def digest
-      Aux.DIGEST(state, self.class::GENERATOR.bitsize) { |n| [n].pack("C") }
-    end
-
-    # return digest as internal state
-    def digest!
-      Aux.DIGEST(state!, self.class::GENERATOR.bitsize) { |n| [n].pack("C") }
-    end
-
-    def hexdigest
-      Aux.DIGEST(state, self.class::GENERATOR.bitsize) { |n| "%02X" % n }
-    end
-
-    # return hex-digest as internal state
-    def hexdigest!
-      Aux.DIGEST(state!, self.class::GENERATOR.bitsize) { |n| "%02X" % n }
-    end
+  alias to_i crc
+  alias to_int crc
 
-    alias to_str hexdigest
-    alias to_s hexdigest
+  def to_a
+    [crc]
+  end
 
-    def inspect
-      "\#<#{self.class}:#{hexdigest}>"
-    end
+  def digest
+    Aux.digest(crc, self.class.bitsize)
+  end
 
-    def pretty_inspect(q)
-      q.text inspect
-    end
+  # return digest as internal state
+  def digest!
+    Aux.digest(state, self.class.bitsize)
+  end
 
-    class << self
-      alias [] new
-
-      #
-      # call-seq:
-      #   combine(crc1, crc2) -> new combined crc
-      #   combine(crc1_int, crc2_int, crc2_len) -> new combined crc
-      #
-      def combine(crc1, crc2, len2 = nil)
-        return crc1 + crc2 if crc1.kind_of?(BasicCRC) && crc2.kind_of?(BasicCRC)
-        self::GENERATOR.combine(crc1.to_i, crc2.to_i, len2)
-      end
+  def hexdigest
+    Aux.hexdigest(crc, self.class.bitsize)
+  end
 
-      def crc(seq, state = nil)
-        self::GENERATOR.crc(seq, state)
-      end
+  # return hex-digest as internal state
+  def hexdigest!
+    Aux.hexdigest(state, self.class.bitsize)
+  end
 
-      def digest(seq, state = nil)
-        Aux.digest(self::GENERATOR.crc(seq, state), self::GENERATOR.bitsize)
-      end
+  alias to_str hexdigest
+  alias to_s hexdigest
 
-      def hexdigest(seq, state = nil)
-        Aux.hexdigest(self::GENERATOR.crc(seq, state), self::GENERATOR.bitsize)
-      end
+  def inspect
+    "\#<#{self.class}:#{hexdigest}>"
+  end
 
-      def inspect
-        if const_defined?(:GENERATOR)
-          if nm = name
-            "#{nm}(#{self::GENERATOR.to_s})"
-          else
-            super.sub(/(?=\>$)/) { " #{self::GENERATOR.to_s}" }
-          end
-        else
-          super
-        end
-      end
+  def pretty_inspect(q)
+    q.text inspect
+  end
 
-      def pretty_inspect(q)
-        q.text inspect
+  private
+  def initialize_args(args)
+    case args.size
+    when 0
+      yield nil, nil, 0
+    when 1
+      if args[0].kind_of?(String)
+        yield args[0], nil, 0
+      else
+        yield nil, args[0], 0
       end
-    end
-
-    private
-    def initialize_args(args)
-      case args.size
-      when 0
-        yield nil, nil, 0
-      when 1
-        if args[0].kind_of?(String)
-          yield args[0], nil, 0
-        else
-          yield nil, args[0], 0
-        end
-      when 2
-        if args[0].kind_of?(String)
-          yield args[0], args[1], 0
-        else
-          yield nil, args[0], args[1].to_i
-        end
-      when 3
-        yield args[0], args[1], args[2].to_i
+    when 2
+      if args[0].kind_of?(String)
+        yield args[0], args[1], 0
       else
-        raise ArgumentError, "wrong argument size (given #{args.size}, expect 0..3)"
+        yield nil, args[0], args[1].to_i
       end
+    when 3
+      yield args[0], args[1], args[2].to_i
+    else
+      raise ArgumentError, "wrong argument size (given #{args.size}, expect 0..3)"
     end
   end
 
@@ -443,23 +435,16 @@ module CRC
 
     alias [] lookup
 
-    def crc(modulename, seq, state = nil)
-      lookup(modulename).crc(seq, state)
-    end
-
-    def digest(modulename, seq, state = nil)
-      lookup(modulename).digest(seq, state)
+    def crc(modulename, seq, crc = nil)
+      lookup(modulename).crc(seq, crc)
     end
 
-    def hexdigest(modulename, seq, state = nil)
-      lookup(modulename).hexdigest(seq, state)
+    def digest(modulename, seq, crc = nil)
+      lookup(modulename).digest(seq, crc)
     end
 
-    def create_module(bitsize, polynomial, initial_state = 0, refin = true, refout = true, xor = ~0, name = nil)
-      g = Generator.new(bitsize, polynomial, initial_state, refin, refout, xor, name)
-      crc = Class.new(BasicCRC)
-      crc.const_set :GENERATOR, g
-      crc
+    def hexdigest(modulename, seq, crc = nil)
+      lookup(modulename).hexdigest(seq, crc)
     end
   end
 
@@ -469,10 +454,11 @@ module CRC
   #
   # Create CRC module classes.
   #
-  LIST.each do |bitsize, polynomial, refin, refout, initial_state, xor, check, *names|
+  LIST.each do |bitsize, polynomial, refin, refout, initial_crc, xor, check, *names|
+    names.flatten!
     names.map! { |nm| nm.freeze }
 
-    crc = create_module(bitsize, polynomial, initial_state, refin, refout, xor, names[0])
+    crc = CRC.new(bitsize, polynomial, initial_crc, refin, refout, xor, names[0])
     crc.const_set :NAME, names
 
     names.each do |nm|
@@ -481,31 +467,36 @@ module CRC
         raise NameError, "collision crc-module name: #{nm} (#{crc::GENERATOR} and #{MODULE_TABLE[nm1]::GENERATOR})"
       end
       MODULE_TABLE[nm1] = crc
+
+      name = nm.sub(/(?<=\bCRC)-(?=\d+)/, "").gsub(/[\W]+/, "_")
+      const_set(name, crc)
+
+      define_singleton_method(name.upcase, ->(*args) { crc.new(*args) })
+      define_singleton_method(name.downcase, ->(*args) {
+        if args.size == 0
+          crc
+        else
+          crc.crc(*args)
+        end
+      })
     end
-    name = names[0].sub(/(?<=\bCRC)-(?=\d+)/, "").gsub(/[\W]+/, "_")
-    const_set(name, crc)
 
     check = Integer(check.to_i) if check
     crc.const_set :CHECK, check
-
-    g = crc::GENERATOR
-    define_singleton_method(name.upcase, ->(*args) { crc.new(*args) })
-    define_singleton_method(name.downcase, ->(*args) { g.crc(*args) })
   end
 
   if $0 == __FILE__
     $stderr.puts "#{__FILE__}:#{__LINE__}: SELF CHECK for CRC modules (#{File.basename($".grep(/_(?:byruby|turbo)/)[0]||"")})\n"
     MODULE_TABLE.values.uniq.each do |crc|
-      g = crc::GENERATOR
       check = crc::CHECK
-      checked = g.crc("123456789")
+      checked = crc.crc("123456789")
       case check
       when nil
-        $stderr.puts "| %20s(\"123456789\") = %16X (check only)\n" % [g.name, checked]
+        $stderr.puts "| %20s(\"123456789\") = %16X (check only)\n" % [crc.name, checked]
       when checked
         ;
       else
-        $stderr.puts "| %20s(\"123456789\") = %16X (expect to %X)\n" % [g.name, checked, check]
+        $stderr.puts "| %20s(\"123456789\") = %16X (expect to %X)\n" % [crc.name, checked, check]
       end
     end
     $stderr.puts "#{__FILE__}:#{__LINE__}: DONE SELF CHECK\n"