nmatrix 0.1.0.rc5 → 0.1.0

data/lib/nmatrix/io/fortran_format.rb

@@ -0,0 +1,135 @@
+#--
+# = NMatrix
+#
+# A linear algebra library for scientific computation in Ruby.
+# NMatrix is part of SciRuby.
+#
+# NMatrix was originally inspired by and derived from NArray, by
+# Masahiro Tanaka: http://narray.rubyforge.org
+#
+# == Copyright Information
+#
+# SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
+#
+# Please see LICENSE.txt for additional copyright notices.
+#
+# == Contributing
+#
+# By contributing source code to SciRuby, you agree to be bound by
+# our Contributor Agreement:
+#
+# * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
+#
+# == io/matlab/fortran_format.rb
+#
+# A parser for making sense of FORTRAN formats.
+# => Only handles R (real), F (float) and E (exponential) format codes. 
+#++
+
+class NMatrix
+  module IO
+    module FortranFormat
+
+      # Class for reading strings in FORTRAN format for specifying attributes
+      # of numerical data in a file. Supports F (float), E (exponential) and 
+      # R (real).
+      # 
+      # == Usage
+      # 
+      #   p = NMatrix::IO::FortranFormat::Reader.new("(16I5)")
+      #   v = p.parse
+      #   puts v #=> { :format_code => "INT_ID", 
+      #          #=>   :repeat      =>       16,
+      #          #=>   :field_width =>        5 }
+      class Reader
+
+        # Accepts a string in FORTRAN format and initializes the 
+        # NMatrix::IO::FortranFormat::Reader object for further parsing of the 
+        # data.
+        # 
+        # == Arguments
+        # 
+        # * +string+ - FORTRAN format string to be parsed.
+        def initialize string
+          @string = string
+        end
+
+        # Parses the FORTRAN format string passed in initialize and returns
+        # a hash of the results.
+        # 
+        # == Result Hash Format
+        # 
+        # Take note that some of the below parameters may be absent in the hash
+        # depending on the type of string being parsed.
+        # 
+        # * +:format_code+ - A string containing the format code of the read data. 
+        #                    Can be "INT_ID", "FP_ID" or "EXP_ID" 
+        # * +:repeat+      - Number of times this format will repeat in a line.
+        # * +:field_width+ - Width of the numerical part of the number.
+        # * +:post_decimal_width+ - Width of the numerals after the decimal point.
+        # * +:exponent_width+ - Width of exponent part of the number.
+        def parse
+          raise(IOError, "Left or right parentheses missing") if parentheses_missing? # change tests to handle 'raise' not return
+
+          @result = {}
+          @string = @string[1..-2]
+
+          if valid_fortran_format?
+            load_result
+          else
+            raise(IOError, "Invalid FORTRAN format specified. Only Integer, Float or Exponential acceptable.")
+          end
+
+          @result
+        end
+
+       private
+        def parentheses_missing?
+          true if @string[0] != '(' or @string[-1] != ')'
+        end
+
+        # Changing any of the following regular expressions can lead to disaster
+        def valid_fortran_format?
+          @mdata = @string.match(/\A(\d*)(I)(\d+)\z/) # check for integer format
+          @mdata = @string.match(/\A(\d*)(F)(\d+)\.(\d+)\z/) if @mdata.nil? # check for floating point if not integer
+          @mdata =  @string.match(/\A(\d*)(E)(\d+)\.(\d+)(E)?(\d*)\z/) if @mdata.nil? # check for exponential format if not floating point
+
+          @mdata
+        end
+
+        def load_result
+          if @mdata.to_a.include? "I"
+            create_integer_hash
+          elsif @mdata.to_a.include? "F"
+            create_float_hash
+          else
+            create_exp_hash
+          end
+        end
+
+        def create_integer_hash
+          @result[:format_code] = "INT_ID"
+          @result[:repeat]      = @mdata[1].to_i if !@mdata[1].empty?
+          @result[:field_width] = @mdata[3].to_i
+        end
+
+        def create_float_hash
+          @result[:format_code]        = "FP_ID"
+          @result[:repeat]             = @mdata[1].to_i if !@mdata[1].empty?
+          @result[:field_width]        = @mdata[3].to_i
+          @result[:post_decimal_width] = @mdata[4].to_i
+        end
+
+        def create_exp_hash
+          @result[:format_code]        = "EXP_ID"
+          @result[:repeat]             = @mdata[1].to_i if !@mdata[1].empty?
+          @result[:field_width]        = @mdata[3].to_i
+          @result[:post_decimal_width] = @mdata[4].to_i
+          @result[:exponent_width]     = @mdata[6].to_i if !@mdata[6].empty?
+        end
+      end
+      
+    end
+  end
+end

data/lib/nmatrix/io/harwell_boeing.rb

@@ -0,0 +1,220 @@
+#--
+# = NMatrix
+#
+# A linear algebra library for scientific computation in Ruby.
+# NMatrix is part of SciRuby.
+#
+# NMatrix was originally inspired by and derived from NArray, by
+# Masahiro Tanaka: http://narray.rubyforge.org
+#
+# == Copyright Information
+#
+# SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
+#
+# Please see LICENSE.txt for additional copyright notices.
+#
+# == Contributing
+#
+# By contributing source code to SciRuby, you agree to be bound by
+# our Contributor Agreement:
+#
+# * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
+#
+# == io/matlab/harwell_boeing.rb
+#
+# Harwell Boeing file reader (and eventually writer too).
+# => Supports only assembled, non-symmetric, real matrices
+# => Data types supported are exponential, floating point and integer
+# => Returned NMatrix is of type :float64
+#++
+
+require_relative './fortran_format.rb'
+
+class NMatrix
+  module IO
+    module HarwellBoeing
+
+      class << self
+        # Loads the contents of a valid Harwell Boeing format file and 
+        # returns an NMatrix object with the values of the file and optionally
+        # only the header info.
+        # 
+        # Supports only assembled, non-symmetric, real matrices. File name must
+        # have matrix type as extension.
+        # 
+        # Example - test_file.rua
+        # 
+        # == Arguments
+        # 
+        # * +file_path+ - Path of the Harwell Boeing file  to load.
+        # * +opts+      - Options for specifying whether you want the values and 
+        #                 header or only the header.
+        # 
+        # == Options
+        # 
+        # * +:header+ - If specified as *true*, will return only the header of the HB file.
+        #               Will return the NMatrix object and header as an array if 
+        #               left blank.
+        # 
+        # == Usage
+        # 
+        #   mat, head = NMatrix::IO::HarwellBoeing.load("test_file.rua")
+        # 
+        #   head = NMatrix::IO::HarwellBoeing.load("test_file.rua", {header: true})
+        # 
+        # == Alternate Usage
+        # 
+        # You can specify the file using NMatrix::IO::Reader.new("path/to/file") and
+        # then call *header* or *values* on the resulting object.
+        def load file_path, opts={}
+          hb_obj = NMatrix::IO::HarwellBoeing::Reader.new(file_path)
+
+          return hb_obj.header if opts[:header]
+
+          [hb_obj.values, hb_obj.header]
+        end
+      end
+
+      class Reader
+        def initialize file_name
+          raise(IOError, "Unsupported file format. Specify file as \
+            file_name.rua.") if !file_name.match(/.*\.[rR][uU][aA]/)
+
+          @file_name   = file_name
+          @header      = {}
+          @body        = nil
+        end
+
+        def header
+          return @header if !@header.empty?
+          @file = File.open @file_name, "r"
+
+          line = @file.gets
+
+          @header[:title] = line[0...72].strip
+          @header[:key]   = line[72...80].strip
+
+          line = @file.gets
+
+          @header[:totcrd] = line[0...14] .strip.to_i
+          @header[:ptrcrd] = line[14...28].strip.to_i
+          @header[:indcrd] = line[28...42].strip.to_i
+          @header[:valcrd] = line[42...56].strip.to_i
+          @header[:rhscrd] = line[56...70].strip.to_i
+
+          raise(IOError, "Right hand sides not supported.") if @header[:rhscrd] > 0
+
+          line = @file.gets
+
+          @header[:mxtype] = line[0...3]
+
+          raise(IOError, "Currently supports only real, assembled, unsymmetric \
+            matrices.") if !@header[:mxtype].match(/RUA/)
+
+          @header[:nrow]   = line[13...28].strip.to_i
+          @header[:ncol]   = line[28...42].strip.to_i
+          @header[:nnzero] = line[42...56].strip.to_i
+          @header[:neltvl] = line[56...70].strip.to_i
+
+          line = @file.gets
+
+          fortran_reader = NMatrix::IO::FortranFormat::Reader
+
+          @header[:ptrfmt] = fortran_reader.new(line[0...16].strip) .parse
+          @header[:indfmt] = fortran_reader.new(line[16...32].strip).parse
+          @header[:valfmt] = fortran_reader.new(line[32...52].strip).parse
+          @header[:rhsfmt] = fortran_reader.new(line[52...72].strip).parse
+
+          @header
+        end
+
+        def values
+          @header      = header if @header.empty?
+          @file.lineno = 5      if @file.lineno != 5
+          @matrix      = NMatrix.new([ @header[:nrow], @header[:ncol] ], 
+                                      0, dtype: :float64)
+
+          read_column_pointers
+          read_row_indices
+          read_values
+
+          @file.close
+          
+          assemble_matrix
+
+          @matrix
+        end
+
+       private
+
+        def read_column_pointers
+          @col_ptrs  = []
+          pointer_lines     = @header[:ptrcrd]
+          pointers_per_line = @header[:ptrfmt][:repeat]
+          pointer_width     = @header[:ptrfmt][:field_width]
+
+          @col_ptrs = read_numbers :to_i, pointer_lines, pointers_per_line, 
+                                             pointer_width
+
+          @col_ptrs.map! {|c| c -= 1}
+        end
+
+        def read_row_indices
+          @row_indices     = []
+          row_lines        = @header[:indcrd]
+          indices_per_line = @header[:indfmt][:repeat]
+          row_width        = @header[:indfmt][:field_width]
+
+          @row_indices = read_numbers :to_i, row_lines, indices_per_line, 
+                                      row_width
+
+          @row_indices.map! {|r| r -= 1}
+        end
+
+        def read_values
+          @vals = []
+          value_lines = @header[:valcrd]
+          values_per_line = @header[:valfmt][:repeat]
+          value_width    = @header[:valfmt][:field_width]
+
+          @vals = read_numbers :to_f, value_lines, values_per_line, 
+                                  value_width
+        end
+
+        def read_numbers to_dtype, num_of_lines, numbers_per_line, number_width
+          data = []
+
+          num_of_lines.times do 
+            line  = @file.gets
+            index = 0
+
+            numbers_per_line.times do
+              delimiter = index + number_width
+
+              data << line[index...delimiter].strip.send(to_dtype)
+
+              break if line.length <= delimiter
+              index += number_width
+            end
+          end
+
+          data
+        end
+
+        def assemble_matrix
+          col = 0
+          @col_ptrs[0..-2].each_index do |index|
+            @col_ptrs[index].upto(@col_ptrs[index+1] - 1) do |row_ptr|
+              row               = @row_indices[row_ptr]
+              @matrix[row, col] = @vals[row_ptr]
+            end
+
+            col += 1
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/nmatrix/io/market.rb

@@ -26,30 +26,42 @@
 #
 #++
 
+# Matrix Market is a repository of test data for use in studies of algorithms
+# for numerical linear algebra. There are 3 file formats used:
+#
+# - Matrix Market Exchange Format.
+# - Harwell-Boeing Exchange Format.
+# - Coordinate Text File Format. (to be phased out)
+#
+# This module can load and save the first format. We might support
+# Harwell-Boeing in the future.
+#
+# The MatrixMarket format is documented in:
+# * http://math.nist.gov/MatrixMarket/formats.html
 module NMatrix::IO::Market
   CONVERTER_AND_DTYPE = {
     :real => [:to_f, :float64],
     :complex => [:to_c, :complex128],
     :integer => [:to_i, :int64],
     :pattern => [:to_i, :byte]
-  }
+  } #:nodoc:
 
   ENTRY_TYPE = {
     :byte => :integer, :int8 => :integer, :int16 => :integer, :int32 => :integer, :int64 => :integer,
     :float32 => :real, :float64 => :real, :complex64 => :complex, :complex128 => :complex
-  }
+  } #:nodoc:
 
   class << self
-    #
+
     # call-seq:
-    #     load(filename) ->
+    #     load(filename) -> NMatrix
+    #
+    # Load a MatrixMarket file. Requires a +filename+ as an argument.
     #
     # * *Arguments* :
     #   - +filename+ -> String with the filename to be saved.
     # * *Raises* :
     #   - +IOError+ -> expected type code line beginning with '%%MatrixMarket matrix'
-    #
-    # Load a MatrixMarket file. Requires a filename as an argument.
     def load(filename)
 
       f = File.new(filename, "r")
@@ -71,7 +83,6 @@ module NMatrix::IO::Market
       end
     end
 
-    #
     # call-seq:
     #     save(matrix, filename, options = {}) -> true
     #
@@ -85,7 +96,6 @@ module NMatrix::IO::Market
     # * *Raises* :
     #   - +DataTypeError+ -> MatrixMarket does not support rational or Ruby objects.
     #   - +ArgumentError+ -> Expected two-dimensional NMatrix.
-    #
     def save(matrix, filename, options = {})
       options = {:pattern => false,
         :symmetry => :general}.merge(options)

data/lib/nmatrix/io/mat5_reader.rb

@@ -30,27 +30,16 @@
 require_relative './mat_reader.rb'
 
 module NMatrix::IO::Matlab
-  #
+
   # Reader (and eventual writer) for a version 5 .mat file.
-  #
-  class Mat5Reader < MatReader
+  class Mat5Reader < MatReader #:nodoc:
     attr_reader :file_header, :first_tag_field, :first_data_field
 
-    class Compressed
+    class Compressed #:nodoc:
       include Packable
-      # include TaggedDataEnumerable
 
       attr_reader :byte_order
 
-      #
-      # call-seq:
-      #     new(stream = nil, byte_order = nil, content_or_bytes = nil) -> Mat5Reader::Compressed
-      #
-      # * *Arguments* :
-      #   - ++ ->
-      # * *Raises* :
-      #   - ++ ->
-      #
       def initialize(stream = nil, byte_order = nil, content_or_bytes = nil)
         @stream			= stream
         @byte_order	= byte_order
@@ -60,69 +49,33 @@ module NMatrix::IO::Matlab
 
         elsif content_or_bytes.is_a?(Fixnum)
           @padded_bytes = content_or_bytes
-          #else
-          #  raise ArgumentError, "Need a content string or a number of bytes; content_or_bytes is #{content_or_bytes.class.to_s}."
         end
       end
 
-      #
-      # call-seq:
-      #     compressed ->
-      #
       def compressed
         require "zlib"
         # [2..-5] removes headers
         @compressed ||= Zlib::Deflate.deflate(content)
       end
 
-      #
-      # call-seq:
-      #     content ->
-      #
       def content
         @content ||= extract
       end
 
-      #
-      # call-seq:
-      #     padded_bytes ->
-      #
       def padded_bytes
         @padded_bytes ||= content.size % 4 == 0 ? content.size : (content.size / 4 + 1) * 4
       end
 
-      #
-      # call-seq:
-      #     write_packed(packedio, options = {}) ->
-      #
-      # * *Arguments* :
-      #   - ++ ->
-      # * *Returns* :
-      #   -
-      #
       def write_packed(packedio, options = {})
         packedio << [compressed, {:bytes => padded_bytes}.merge(options)]
       end
 
-      #
-      # call-seq:
-      #     read_packed(packedio, options = {}) ->
-      #
-      # * *Arguments* :
-      #   - ++ ->
-      # * *Returns* :
-      #   -
-      #
       def read_packed(packedio, options)
         @compressed = (packedio >> [String, options]).first
         content
       end
 
       protected
-      #
-      # call-seq:
-      #     extract ->
-      #
       def extract
         require 'zlib'
 
@@ -140,26 +93,17 @@ module NMatrix::IO::Matlab
                                   :matlab_class, :dimensions, :matlab_name, :real_part,
                                   :imaginary_part, :row_index, :column_index)
 
-    class MatrixData < MatrixDataStruct
+    class MatrixData < MatrixDataStruct #:nodoc:
       include Packable
 
-      #
-      # call-seq:
-      #     write_packed(packedio, options) ->
-      #
-      # * *Arguments* :
-      #   - ++ ->
-      # * *Returns* :
-      #   -
-      #
       def write_packed(packedio, options)
         raise NotImplementedError
         packedio << [info, {:bytes => padded_bytes}.merge(options)]
       end
 
-      #
       # call-seq:
-      #     to_ruby -> NMatrix or Array
+      #     to_ruby -> NMatrix
+      #     to_ruby -> Array
       #
       # Figure out the appropriate Ruby type to convert to, and do it. There
       # are basically two possible types: +NMatrix+ and +Array+. This method
@@ -172,7 +116,6 @@ module NMatrix::IO::Matlab
       # appropriate stype (:yale or :dense, respectively).
       #
       # See also to_nm, which is responsible for NMatrix instantiation.
-      #
       def to_ruby
         case matlab_class
         when :mxSPARSE	then	return to_nm
@@ -181,7 +124,6 @@ module NMatrix::IO::Matlab
         end
       end
 
-      #
       # call-seq:
       #     guess_dtype_from_mdtype -> Symbol
       #
@@ -189,7 +131,6 @@ module NMatrix::IO::Matlab
       #
       # TODO: Needs to be verified that unsigned MATLAB types are being
       # converted to the correct NMatrix signed dtypes.
-      #
       def guess_dtype_from_mdtype
         dtype = MatReader::MDTYPE_TO_DTYPE[self.real_part.tag.data_type]
 
@@ -228,10 +169,6 @@ module NMatrix::IO::Matlab
 
       end
 
-      #
-      # call-seq:
-      #     repacked_data(to_dtype = nil) ->
-      #
       # Unpacks and repacks data into the appropriate format for NMatrix.
       #
       # If data is already in the appropriate format, does not unpack or
@@ -291,15 +228,10 @@ module NMatrix::IO::Matlab
          to_dtype]
       end
 
-      #
-      # call-seq:
-      #     repacked_indices ->
-      #
       # Unpacks and repacks index data into the appropriate format for NMatrix.
       #
       # If data is already in the appropriate format, does not unpack or
       # repack, just returns directly.
-      #
       def repacked_indices
         repacked_row_indices = ::NMatrix::IO::Matlab.repack( self.row_index.data, :miINT32, :itype )
         repacked_col_indices = ::NMatrix::IO::Matlab.repack( self.column_index.data, :miINT32, :itype )
@@ -352,29 +284,17 @@ module NMatrix::IO::Matlab
         end
       end
 
-      #
-      # call-seq:
-      #     read_packed(packedio, options) ->
-      #
-      # * *Arguments* :
-      #   - ++ ->
-      # * *Returns* :
-      #   -
-      #
       def read_packed(packedio, options)
         flags_class, self.nonzero_max = packedio.read([Element, options]).data
 
         self.matlab_class   = MatReader::MCLASSES[flags_class % 16]
-        #STDERR.puts "Matrix class: #{self.matlab_class}"
 
         self.logical        = (flags_class >> 8) % 2 == 1 ? true : false
         self.global         = (flags_class >> 9) % 2 == 1 ? true : false
         self.complex        = (flags_class >> 10) % 2 == 1 ? true : false
-        #STDERR.puts "nzmax: #{self.nonzero_max}"
 
         dimensions_tag_data = packedio.read([Element, options])
         self.dimensions     = dimensions_tag_data.data
-        #STDERR.puts "dimensions: #{self.dimensions}"
 
         begin
           name_tag_data			= packedio.read([Element, options])
@@ -390,7 +310,6 @@ module NMatrix::IO::Matlab
           raise(e)
         end
 
-        #STDERR.puts [flags_class.to_s(2), self.complex, self.global, self.logical, nil, self.mclass, self.nonzero_max].join("\t")
         if self.matlab_class == :mxCELL
           # Read what may be a series of matrices
           self.cells = []
@@ -404,8 +323,6 @@ module NMatrix::IO::Matlab
           if self.matlab_class == :mxSPARSE
             self.column_index = packedio.read(read_opts)
             self.row_index    = packedio.read(read_opts)
-
-            # STDERR.puts "row and col indices: #{self.row_index.inspect}, #{self.column_index.inspect}"
           end
 
           self.real_part			= packedio.read(read_opts)
@@ -413,15 +330,6 @@ module NMatrix::IO::Matlab
         end
       end
 
-      #
-      # call-seq:
-      #     ignore_padding(packedio, bytes) ->
-      #
-      # * *Arguments* :
-      #   - ++ ->
-      # * *Returns* :
-      #   -
-      #
       def ignore_padding(packedio, bytes)
         packedio.read([Integer, {:unsigned => true, :bytes => bytes}]) if bytes > 0
       end
@@ -433,7 +341,6 @@ module NMatrix::IO::Matlab
                                             :miCOMPRESSED	=> [Compressed, {}],
                                             :miMATRIX			=> [MatrixData, {}]
                                           })
-    # include TaggedDataEnumerable
 
     FIRST_TAG_FIELD_POS = 128
 
@@ -441,6 +348,8 @@ module NMatrix::IO::Matlab
     # Instance Methods for Mat5Reader #
     ###################################
 
+    # call-seq:
+    #     NMatrix::IO::Mat5Reader.new(stream, options = {}) -> NMatrix
     def initialize(stream, options = {})
       super(stream, options)
       @file_header = seek_and_read_file_header
@@ -492,11 +401,9 @@ module NMatrix::IO::Matlab
       self
     end
 
-    ####################
-    # Internal Classes #
-    ####################
+    # Internal Classes.
 
-    class Header < Struct.new(:desc, :data_offset, :version, :endian)
+    class Header < Struct.new(:desc, :data_offset, :version, :endian) #:nodoc:
 
       include Packable
 
@@ -506,7 +413,7 @@ module NMatrix::IO::Matlab
       VERSION_LENGTH			= 2
       BYTE_ORDER_POS			= 126
 
-      ## TODO: TEST WRITE.
+      # TODO: TEST WRITE.
       def write_packed(packedio, options)
         packedio <<	[desc,				{:bytes => DESC_LENGTH				}] <<
           [data_offset,	{:bytes => DATA_OFFSET_LENGTH	}] <<
@@ -529,13 +436,13 @@ module NMatrix::IO::Matlab
       end
     end
 
-    class Tag < Struct.new(:data_type, :raw_data_type, :bytes, :small)
+    class Tag < Struct.new(:data_type, :raw_data_type, :bytes, :small) #:nodoc:
       include Packable
 
       DATA_TYPE_OPTS = BYTES_OPTS = {:bytes => 4, :signed => false}
       LENGTH = DATA_TYPE_OPTS[:bytes] + BYTES_OPTS[:bytes]
 
-      ## TODO: TEST WRITE.
+      # TODO: TEST WRITE.
       def write_packed packedio, options
         packedio << [data_type, DATA_TYPE_OPTS] << [bytes, BYTES_OPTS]
       end
@@ -575,7 +482,7 @@ module NMatrix::IO::Matlab
     end
 
 
-    class ElementDataIOError < IOError
+    class ElementDataIOError < IOError #:nodoc:
       attr_reader :tag
 
       def initialize(tag = nil, msg = nil)
@@ -589,7 +496,7 @@ module NMatrix::IO::Matlab
     end
 
 
-    class Element < Struct.new(:tag, :data)
+    class Element < Struct.new(:tag, :data) #:nodoc:
       include Packable
 
       def write_packed packedio, options
@@ -600,11 +507,9 @@ module NMatrix::IO::Matlab
         raise(ArgumentError, 'Missing mandatory option :endian.') unless options.has_key?(:endian)
 
         tag = packedio.read([Tag, {:endian => options[:endian]}])
-        #STDERR.puts tag.inspect
         data_type = MDTYPE_UNPACK_ARGS[tag.data_type]
 
         self.tag = tag
-        #STDERR.puts self.tag.inspect
 
         raise ElementDataIOError.new(tag, "Unrecognized Matlab type #{tag.raw_data_type}") if data_type.nil?
 
@@ -651,7 +556,7 @@ module NMatrix::IO::Matlab
 
     # Doesn't unpack the contents of the element, e.g., if we want to handle
     # manually, or pass the raw string of bytes into NMatrix.
-    class RawElement < Element
+    class RawElement < Element #:nodoc:
       def read_packed(packedio, options)
         raise(ArgumentError, 'Missing mandatory option :endian.') unless options.has_key?(:endian)