nmatrix 0.2.1 → 0.2.3

data/ext/nmatrix/storage/list/list.cpp

@@ -551,7 +551,7 @@ void set(VALUE left, SLICE* slice, VALUE right) {
     v                = reinterpret_cast<D*>(t->elements);
     v_size           = nm_storage_count_max_elements(t);
 
-  } else if (TYPE(right) == T_ARRAY) {
+  } else if (RB_TYPE_P(right, T_ARRAY)) {
     nm_register_nmatrix(nm_and_free.first);
     v_size = RARRAY_LEN(right);
     v      = NM_ALLOC_N(D, v_size);
@@ -1016,7 +1016,7 @@ VALUE nm_list_map_merged_stored(VALUE left, VALUE right, VALUE init) {
   void* scalar_init = NULL;
 
   // right might be a scalar, in which case this is a scalar operation.
-  if (TYPE(right) != T_DATA || (RDATA(right)->dfree != (RUBY_DATA_FUNC)nm_delete && RDATA(right)->dfree != (RUBY_DATA_FUNC)nm_delete_ref)) {
+  if (!IsNMatrixType(right)) {
     nm::dtype_t r_dtype = Upcast[NM_DTYPE(left)][nm_dtype_min(right)];
     scalar_init         = rubyobj_to_cval(right, r_dtype); // make a copy of right
 

data/ext/nmatrix/storage/yale/class.h

@@ -376,7 +376,7 @@ public:
       v       = reinterpret_cast<D*>(s->elements);
       v_size  = nm_storage_count_max_elements(s);
 
-    } else if (TYPE(right) == T_ARRAY) {
+    } else if (RB_TYPE_P(right, T_ARRAY)) {
       v_size = RARRAY_LEN(right);
       v      = NM_ALLOC_N(D, v_size);
       if (dtype() == nm::RUBYOBJ) {

data/lib/nmatrix/blas.rb

@@ -9,8 +9,8 @@
 #
 # == Copyright Information
 #
-# SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
-# NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
+# SciRuby is Copyright (c) 2010 - 2016, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012 - 2016, John Woods and the Ruby Science Foundation
 #
 # Please see LICENSE.txt for additional copyright notices.
 #
@@ -68,10 +68,19 @@ module NMatrix::BLAS
     #   - +ArgumentError+ -> +c+ must be +nil+ or a dense matrix.
     #   - +ArgumentError+ -> The dtype of the matrices must be equal.
     #
-    def gemm(a, b, c = nil, alpha = 1.0, beta = 0.0, transpose_a = false, transpose_b = false, m = nil, n = nil, k = nil, lda = nil, ldb = nil, ldc = nil)
-      raise(ArgumentError, 'Expected dense NMatrices as first two arguments.') unless a.is_a?(NMatrix) and b.is_a?(NMatrix) and a.stype == :dense and b.stype == :dense
-      raise(ArgumentError, 'Expected nil or dense NMatrix as third argument.') unless c.nil? or (c.is_a?(NMatrix) and c.stype == :dense)
-      raise(ArgumentError, 'NMatrix dtype mismatch.')              unless a.dtype == b.dtype and (c ? a.dtype == c.dtype : true)
+    def gemm(a, b, c = nil, alpha = 1.0, beta = 0.0,
+             transpose_a = false, transpose_b = false, m = nil,
+             n = nil, k = nil, lda = nil, ldb = nil, ldc = nil)
+
+      raise(ArgumentError, 'Expected dense NMatrices as first two arguments.') \
+            unless a.is_a?(NMatrix) and b.is_a? \
+            (NMatrix) and a.stype == :dense and b.stype == :dense
+
+      raise(ArgumentError, 'Expected nil or dense NMatrix as third argument.') \
+            unless c.nil? or (c.is_a?(NMatrix)  \
+            and c.stype == :dense)
+      raise(ArgumentError, 'NMatrix dtype mismatch.') \
+            unless a.dtype == b.dtype and (c ? a.dtype == c.dtype : true)
 
       # First, set m, n, and k, which depend on whether we're taking the
       # transpose of a and b.
@@ -108,7 +117,8 @@ module NMatrix::BLAS
       end
 
       # For argument descriptions, see: http://www.netlib.org/blas/dgemm.f
-      ::NMatrix::BLAS.cblas_gemm(:row, transpose_a, transpose_b, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
+      ::NMatrix::BLAS.cblas_gemm(:row, transpose_a, transpose_b,
+       m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
 
       return c
     end
@@ -140,17 +150,27 @@ module NMatrix::BLAS
     # * *Raises* :
     #   - ++ ->
     #
-    def gemv(a, x, y = nil, alpha = 1.0, beta = 0.0, transpose_a = false, m = nil, n = nil, lda = nil, incx = nil, incy = nil)
-      raise(ArgumentError, 'Expected dense NMatrices as first two arguments.') unless a.is_a?(NMatrix) and x.is_a?(NMatrix) and a.stype == :dense and x.stype == :dense
-      raise(ArgumentError, 'Expected nil or dense NMatrix as third argument.') unless y.nil? or (y.is_a?(NMatrix) and y.stype == :dense)
-      raise(ArgumentError, 'NMatrix dtype mismatch.')              unless a.dtype == x.dtype and (y ? a.dtype == y.dtype : true)
+    def gemv(a, x, y = nil, alpha = 1.0, beta = 0.0,
+             transpose_a = false, m = nil, n = nil, lda = nil,
+             incx = nil, incy = nil)
+      raise(ArgumentError, 'Expected dense NMatrices as first two arguments.') \
+       unless a.is_a?(NMatrix) and x.is_a?(NMatrix) and \
+       a.stype == :dense and x.stype == :dense
+
+      raise(ArgumentError, 'Expected nil or dense NMatrix as third argument.') \
+       unless y.nil? or (y.is_a?(NMatrix) and y.stype == :dense)
+
+      raise(ArgumentError, 'NMatrix dtype mismatch.') \
+       unless a.dtype == x.dtype and (y ? a.dtype == y.dtype : true)
 
       m ||= transpose_a == :transpose ? a.shape[1] : a.shape[0]
       n ||= transpose_a == :transpose ? a.shape[0] : a.shape[1]
-      raise(ArgumentError, "dimensions don't match") unless x.shape[0] == n && x.shape[1] == 1
+      raise(ArgumentError, "dimensions don't match") \
+       unless x.shape[0] == n && x.shape[1] == 1
 
       if y
-        raise(ArgumentError, "dimensions don't match") unless y.shape[0] == m && y.shape[1] == 1
+        raise(ArgumentError, "dimensions don't match") \
+         unless y.shape[0] == m && y.shape[1] == 1
       else
         y = NMatrix.new([m,1], dtype: a.dtype)
       end
@@ -159,7 +179,8 @@ module NMatrix::BLAS
       incx ||= 1
       incy ||= 1
 
-      ::NMatrix::BLAS.cblas_gemv(transpose_a, m, n, alpha, a, lda, x, incx, beta, y, incy)
+      ::NMatrix::BLAS.cblas_gemv(transpose_a, m, n,
+       alpha, a, lda, x, incx, beta, y, incy)
 
       return y
     end
@@ -178,18 +199,27 @@ module NMatrix::BLAS
     #   - +incx+ -> stride of NMatrix +x+
     #   - +incy+ -> stride of NMatrix +y+
     #   - +n+ -> number of elements to consider in x and y
-    #   - +in_place+ -> true if it's okay to modify the supplied +x+ and +y+ parameters directly; false if not. Default is false.
+    #   - +in_place+ -> true   if it's okay to modify the supplied
+    #                           +x+ and +y+ parameters directly;
+    #                   false if not. Default is false.
     # * *Returns* :
     #   - Array with the results, in the format [xx, yy]
     # * *Raises* :
     #   - +ArgumentError+ -> Expected dense NMatrices as first two arguments.
     #   - +ArgumentError+ -> NMatrix dtype mismatch.
-    #   - +ArgumentError+ -> Need to supply n for non-standard incx, incy values.
+    #   - +ArgumentError+ -> Need to supply n for non-standard incx,
+    #                         incy values.
     #
     def rot(x, y, c, s, incx = 1, incy = 1, n = nil, in_place=false)
-      raise(ArgumentError, 'Expected dense NMatrices as first two arguments.')    unless x.is_a?(NMatrix) and y.is_a?(NMatrix) and x.stype == :dense and y.stype == :dense
-      raise(ArgumentError, 'NMatrix dtype mismatch.')                 unless x.dtype == y.dtype
-      raise(ArgumentError, 'Need to supply n for non-standard incx, incy values') if n.nil? && incx != 1 && incx != -1 && incy != 1 && incy != -1
+      raise(ArgumentError, 'Expected dense NMatrices as first two arguments.') \
+       unless x.is_a?(NMatrix) and y.is_a?(NMatrix) \
+       and x.stype == :dense and y.stype == :dense
+
+      raise(ArgumentError, 'NMatrix dtype mismatch.') \
+       unless x.dtype == y.dtype
+
+      raise(ArgumentError, 'Need to supply n for non-standard incx, incy values') \
+       if n.nil? && incx != 1 && incx != -1 && incy != 1 && incy != -1
 
       n ||= [x.size/incx.abs, y.size/incy.abs].min
 
@@ -223,9 +253,11 @@ module NMatrix::BLAS
     # call-seq:
     #     rotg(ab) -> [Numeric, Numeric]
     #
-    # Apply givens plane rotation to the coordinates (a,b), returning the cosine and sine of the angle theta.
+    # Apply givens plane rotation to the coordinates (a,b),
+    #  returning the cosine and sine of the angle theta.
     #
-    # Since the givens rotation includes a square root, integers are disallowed.
+    # Since the givens rotation includes a square root,
+    #  integers are disallowed.
     #
     # * *Arguments* :
     #   - +ab+ -> NMatrix with two elements
@@ -235,7 +267,8 @@ module NMatrix::BLAS
     #   - +ArgumentError+ -> Expected dense NMatrix of size 2
     #
     def rotg(ab)
-      raise(ArgumentError, "Expected dense NMatrix of shape [2,1] or [1,2]") unless ab.is_a?(NMatrix) && ab.stype == :dense && ab.size == 2
+      raise(ArgumentError, "Expected dense NMatrix of shape [2,1] or [1,2]") \
+       unless ab.is_a?(NMatrix) && ab.stype == :dense && ab.size == 2
 
       ::NMatrix::BLAS.cblas_rotg(ab)
     end
@@ -245,10 +278,12 @@ module NMatrix::BLAS
     # call-seq:
     #     asum(x, incx, n) -> Numeric
     #
-    # Calculate the sum of absolute values of the entries of a vector +x+ of size +n+
+    # Calculate the sum of absolute values of the entries of a
+    #  vector +x+ of size +n+
     #
     # * *Arguments* :
-    #   - +x+ -> an NMatrix (will also allow an NMatrix, but will treat it as if it's a vector )
+    #   - +x+ -> an NMatrix (will also allow an NMatrix,
+    #             but will treat it as if it's a vector )
     #   - +incx+ -> the skip size (defaults to 1)
     #   - +n+ -> the size of +x+ (defaults to +x.size / incx+)
     # * *Returns* :
@@ -259,9 +294,12 @@ module NMatrix::BLAS
     #
     def asum(x, incx = 1, n = nil)
       n ||= x.size / incx
-      raise(ArgumentError, "Expected dense NMatrix for arg 0") unless x.is_a?(NMatrix)
-      raise(RangeError, "n out of range") if n*incx > x.size || n*incx <= 0 || n <= 0
-      ::NMatrix::BLAS.cblas_asum(n, x, incx)
+      raise(ArgumentError, "Expected dense NMatrix for arg 0") \
+       unless x.is_a?(NMatrix)
+
+      raise(RangeError, "n out of range") \
+       if n*incx > x.size || n*incx <= 0 || n <= 0
+       ::NMatrix::BLAS.cblas_asum(n, x, incx)
     end
 
     #
@@ -271,7 +309,8 @@ module NMatrix::BLAS
     # Calculate the 2-norm of a vector +x+ of size +n+
     #
     # * *Arguments* :
-    #   - +x+ -> an NMatrix (will also allow an NMatrix, but will treat it as if it's a vector )
+    #   - +x+ -> an NMatrix (will also allow an
+    #             NMatrix, but will treat it as if it's a vector )
     #   - +incx+ -> the skip size (defaults to 1)
     #   - +n+ -> the size of +x+ (defaults to +x.size / incx+)
     # * *Returns* :
@@ -282,24 +321,54 @@ module NMatrix::BLAS
     #
     def nrm2(x, incx = 1, n = nil)
       n ||= x.size / incx
-      raise(ArgumentError, "Expected dense NMatrix for arg 0") unless x.is_a?(NMatrix)
-      raise(RangeError, "n out of range") if n*incx > x.size || n*incx <= 0 || n <= 0
-      ::NMatrix::BLAS.cblas_nrm2(n, x, incx)
+      raise(ArgumentError, "Expected dense NMatrix for arg 0") \
+       unless x.is_a?(NMatrix)
+
+      raise(RangeError, "n out of range") \
+       if n*incx > x.size || n*incx <= 0 || n <= 0
+       ::NMatrix::BLAS.cblas_nrm2(n, x, incx)
+    end
+
+    #
+    # call-seq:
+    #     scal(alpha, vector, incx, n)
+    #
+    # Scale a matrix by a given scaling factor
+    #
+    # * *Arguments* :
+    #   - +alpha+ -> a scaling factor
+    #   - +vector+ -> an NMatrix
+    #   - +incx+ -> the skip size (defaults to 1)
+    #   - +n+ -> the size of +x+ (defaults to +x.size / incx+)
+    # * *Returns* :
+    #   - The scaling result
+    # * *Raises* :
+    #   - +ArgumentError+ -> Expected dense NMatrix for arg 0
+    #   - +RangeError+ -> n out of range
+    #
+    def scal(alpha, vector, incx=1, n=nil)
+      n ||= vector.size / incx
+      raise(ArgumentError, "Expected dense NMatrix for arg 0") unless vector.is_a?(NMatrix)
+      raise(RangeError, "n out of range") if n*incx > vector.size || n*incx <= 0 || n <= 0
+      ::NMatrix::BLAS.cblas_scal(n, alpha, vector, incx)
     end
 
     # The following are functions that used to be implemented in C, but
     # now require nmatrix-atlas or nmatrix-lapcke to run properly, so we can just
     # implemented their stubs in Ruby.
     def cblas_trmm(order, side, uplo, trans_a, diag, m, n, alpha, a, lda, b, ldb)
-      raise(NotImplementedError,"cblas_trmm requires either the nmatrix-lapacke or nmatrix-atlas gem")
+      raise(NotImplementedError,"cblas_trmm requires either the
+       nmatrix-lapacke or nmatrix-atlas gem")
     end
 
     def cblas_syrk(order, uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
-      raise(NotImplementedError,"cblas_syrk requires either the nmatrix-lapacke or nmatrix-atlas gem")
+      raise(NotImplementedError,"cblas_syrk requires either the
+       nmatrix-lapacke or nmatrix-atlas gem")
     end
 
     def cblas_herk(order, uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
-      raise(NotImplementedError,"cblas_herk requires either the nmatrix-lapacke or nmatrix-atlas gem")
+      raise(NotImplementedError,"cblas_herk requires either the
+       nmatrix-lapacke or nmatrix-atlas gem")
     end
   end
 end

data/lib/nmatrix/io/fortran_format.rb

@@ -9,8 +9,8 @@
 #
 # == Copyright Information
 #
-# SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
-# NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
+# SciRuby is Copyright (c) 2010 - 2016, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012 - 2016, John Woods and the Ruby Science Foundation
 #
 # Please see LICENSE.txt for additional copyright notices.
 #
@@ -70,7 +70,8 @@ class NMatrix
         # * +: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
+          raise(IOError, "Left or right parentheses missing") \
+           if parentheses_missing? # change tests to handle 'raise' not return
 
           @result = {}
           @string = @string[1..-2]
@@ -92,8 +93,10 @@ class NMatrix
         # 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 = @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

data/lib/nmatrix/io/harwell_boeing.rb

@@ -9,8 +9,8 @@
 #
 # == Copyright Information
 #
-# SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
-# NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
+# SciRuby is Copyright (c) 2010 - 2016, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012 - 2016, John Woods and the Ruby Science Foundation
 #
 # Please see LICENSE.txt for additional copyright notices.
 #
@@ -48,14 +48,14 @@ class NMatrix
         # == 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.
+        # * +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.
+        # * +: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
         # 
@@ -65,8 +65,8 @@ class NMatrix
         # 
         # == 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.
+        # 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)
 
@@ -103,7 +103,8 @@ class NMatrix
           @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
+          raise(IOError, "Right hand sides not supported.") \
+           if @header[:rhscrd] > 0
 
           line = @file.gets
 

data/lib/nmatrix/io/market.rb

@@ -8,8 +8,8 @@
 #
 # == Copyright Information
 #
-# SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
-# NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
+# SciRuby is Copyright (c) 2010 - 2016, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012 - 2016, John Woods and the Ruby Science Foundation
 #
 # Please see LICENSE.txt for additional copyright notices.
 #
@@ -47,8 +47,9 @@ module NMatrix::IO::Market
   } #:nodoc:
 
   ENTRY_TYPE = {
-    :byte => :integer, :int8 => :integer, :int16 => :integer, :int32 => :integer, :int64 => :integer,
-    :float32 => :real, :float64 => :real, :complex64 => :complex, :complex128 => :complex
+    :byte => :integer, :int8 => :integer, :int16 => :integer,
+    :int32 => :integer, :int64 => :integer,:float32 => :real,
+    :float64 => :real, :complex64 => :complex, :complex128 => :complex
   } #:nodoc:
 
   class << self
@@ -68,7 +69,8 @@ module NMatrix::IO::Market
 
       header = f.gets
       header.chomp!
-      raise(IOError, "expected type code line beginning with '%%MatrixMarket matrix'") if header !~ /^\%\%MatrixMarket\ matrix/
+      raise(IOError, "expected type code line beginning with '%%MatrixMarket matrix'") \
+       if header !~ /^\%\%MatrixMarket\ matrix/
 
       header = header.split
 
@@ -106,7 +108,8 @@ module NMatrix::IO::Market
       end
       entry_type = options[:pattern] ? :pattern : ENTRY_TYPE[matrix.dtype]
 
-      raise(ArgumentError, "expected two-dimensional NMatrix") if matrix.dim != 2
+      raise(ArgumentError, "expected two-dimensional NMatrix") \
+       if matrix.dim != 2
 
       f = File.new(filename, 'w')
 

data/lib/nmatrix/io/mat5_reader.rb

@@ -9,8 +9,8 @@
 #
 # == Copyright Information
 #
-# SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
-# NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
+# SciRuby is Copyright (c) 2010 - 2016, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012 - 2016, John Woods and the Ruby Science Foundation
 #
 # Please see LICENSE.txt for additional copyright notices.
 #
@@ -63,7 +63,8 @@ module NMatrix::IO::Matlab
       end
 
       def padded_bytes
-        @padded_bytes ||= content.size % 4 == 0 ? content.size : (content.size / 4 + 1) * 4
+        @padded_bytes ||= content.size % 4 == 0 ? \
+         content.size : (content.size / 4 + 1) * 4
       end
 
       def write_packed(packedio, options = {})
@@ -89,9 +90,10 @@ module NMatrix::IO::Matlab
     end
 
     MatrixDataStruct = Struct.new(
-                                  :cells, :logical, :global, :complex, :nonzero_max,
-                                  :matlab_class, :dimensions, :matlab_name, :real_part,
-                                  :imaginary_part, :row_index, :column_index)
+                                  :cells, :logical, :global, :complex,
+                                  :nonzero_max,:matlab_class, :dimensions,
+                                  :matlab_name, :real_part,:imaginary_part,
+                                  :row_index, :column_index)
 
     class MatrixData < MatrixDataStruct #:nodoc:
       include Packable
@@ -196,16 +198,19 @@ module NMatrix::IO::Matlab
           imag_mdtype = self.imaginary_part.tag.data_type
 
           # Make sure we convert both mdtypes do the same dtype
-          to_dtype ||= NMatrix.upcast(MatReader::MDTYPE_TO_DTYPE[real_mdtype], MatReader::MDTYPE_TO_DTYPE[imag_mdtype])
+          to_dtype ||= NMatrix.upcast(MatReader::MDTYPE_TO_DTYPE[real_mdtype], \
+           MatReader::MDTYPE_TO_DTYPE[imag_mdtype])
 
-          # Let's make sure we don't try to send NMatrix complex integers. We need complex floating points.
+          # Let's make sure we don't try to send NMatrix complex integers.
+          #  We need complex floating points.
           unless [:float32, :float64].include?(to_dtype)
             to_dtype = NMatrix.upcast(to_dtype, :float32)
           end
 
           STDERR.puts "imag: Requesting dtype #{to_dtype.inspect}"
           # Repack the imaginary part
-          components[1] = ::NMatrix::IO::Matlab.repack( self.imaginary_part.data, imag_mdtype, :dtype => to_dtype )
+          components[1] = ::NMatrix::IO::Matlab.repack( self.imaginary_part.data, \
+           imag_mdtype, :dtype => to_dtype )
 
         else
 
@@ -221,10 +226,12 @@ module NMatrix::IO::Matlab
 
         # Repack the real part
         STDERR.puts "real: Requesting dtype #{to_dtype.inspect}"
-        components[0] = ::NMatrix::IO::Matlab.repack( self.real_part.data, real_mdtype, :dtype => to_dtype )
+        components[0] = ::NMatrix::IO::Matlab.repack( \
+         self.real_part.data, real_mdtype, :dtype => to_dtype )
 
         # Merge the two parts if complex, or just return the real part.
-        [self.complex ? ::NMatrix::IO::Matlab.complex_merge( components[0], components[1], to_dtype ) : components[0],
+        [self.complex ? ::NMatrix::IO::Matlab.complex_merge( \
+         components[0], components[1], to_dtype ) : components[0],
          to_dtype]
       end
 
@@ -233,8 +240,10 @@ module NMatrix::IO::Matlab
       # 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 )
+        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 )
 
         [repacked_row_indices, repacked_col_indices]
       end
@@ -276,7 +285,8 @@ module NMatrix::IO::Matlab
           # MATLAB always uses :miINT32 for indices according to the spec
           ia_ja                     = repacked_indices
           data_str, repacked_dtype  = repacked_data(dtype)
-          NMatrix.new(:yale, self.dimensions.reverse, repacked_dtype, ia_ja[0], ia_ja[1], data_str, repacked_dtype)
+          NMatrix.new(:yale, self.dimensions.reverse, repacked_dtype, \
+           ia_ja[0], ia_ja[1], data_str, repacked_dtype)
 
         else
           # Call regular dense constructor.
@@ -298,7 +308,9 @@ module NMatrix::IO::Matlab
 
         begin
           name_tag_data   = packedio.read([Element, options])
-          self.matlab_name = name_tag_data.data.is_a?(Array) ? name_tag_data.data.collect { |i| i.chr }.join('') : name_tag_data.data.chr
+          self.matlab_name = name_tag_data.data.is_a?(Array) ? \
+           name_tag_data.data.collect { |i| i.chr }.join('') : \
+           name_tag_data.data.chr
 
         rescue ElementDataIOError => e
           STDERR.puts "ERROR: Failure while trying to read Matlab variable name: #{name_tag_data.inspect}"
@@ -315,10 +327,12 @@ module NMatrix::IO::Matlab
           self.cells = []
           STDERR.puts("Warning: Cell array does not yet support reading multiple dimensions") if dimensions.size > 2 || (dimensions[0] > 1 && dimensions[1] > 1)
           number_of_cells = dimensions.inject(1) { |prod,i| prod * i }
-          number_of_cells.times { self.cells << packedio.read([Element, options]) }
+          number_of_cells.times { self.cells << \
+           packedio.read([Element, options]) }
 
         else
-          read_opts = [RawElement, {:bytes => options[:bytes], :endian => :native}]
+          read_opts = [RawElement, {:bytes => options[:bytes], \
+           :endian => :native}]
 
           if self.matlab_class == :mxSPARSE
             self.column_index = packedio.read(read_opts)
@@ -331,7 +345,8 @@ module NMatrix::IO::Matlab
       end
 
       def ignore_padding(packedio, bytes)
-        packedio.read([Integer, {:unsigned => true, :bytes => bytes}]) if bytes > 0
+        packedio.read([Integer, {:unsigned => true, \
+         :bytes => bytes}]) if bytes > 0
       end
     end
 
@@ -386,7 +401,8 @@ module NMatrix::IO::Matlab
     def each(&block)
       stream.each(Element, {:endian => byte_order}) do |element|
         if element.data.is_a?(Compressed)
-          StringIO.new(element.data.content, 'rb').each(Element, {:endian => byte_order}) do |compressed_element|
+          StringIO.new(element.data.content, 'rb').each(Element, \
+             {:endian => byte_order}) do |compressed_element|
             yield compressed_element.data
           end
 
@@ -456,7 +472,8 @@ module NMatrix::IO::Matlab
       end
 
       def read_packed packedio, options
-        self.raw_data_type = packedio.read([Integer, DATA_TYPE_OPTS.merge(options)])
+        self.raw_data_type = packedio.read([Integer, \
+         DATA_TYPE_OPTS.merge(options)])
 
         # Borrowed from a SciPy patch
         upper = self.raw_data_type >> 16
@@ -504,20 +521,23 @@ module NMatrix::IO::Matlab
       end
 
       def read_packed(packedio, options)
-        raise(ArgumentError, 'Missing mandatory option :endian.') unless options.has_key?(:endian)
+        raise(ArgumentError, 'Missing mandatory option :endian.') \
+         unless options.has_key?(:endian)
 
         tag = packedio.read([Tag, {:endian => options[:endian]}])
         data_type = MDTYPE_UNPACK_ARGS[tag.data_type]
 
         self.tag = tag
 
-        raise ElementDataIOError.new(tag, "Unrecognized Matlab type #{tag.raw_data_type}") if data_type.nil?
+        raise ElementDataIOError.new(tag, "Unrecognized Matlab type #{tag.raw_data_type}") \
+         if data_type.nil?
 
         if tag.bytes == 0
           self.data = []
 
         else
-          number_of_reads = data_type[1].has_key?(:bytes) ? tag.bytes / data_type[1][:bytes] : 1
+          number_of_reads = data_type[1].has_key?(:bytes) ? \
+           tag.bytes / data_type[1][:bytes] : 1
           data_type[1].merge!({:endian => options[:endian]})
 
           if number_of_reads == 1
@@ -531,7 +551,8 @@ module NMatrix::IO::Matlab
           end
 
           begin
-            ignore_padding(packedio, (tag.bytes + tag.size) % 8) unless [:miMATRIX, :miCOMPRESSED].include?(tag.data_type)
+            ignore_padding(packedio, (tag.bytes + tag.size) % 8) \
+             unless [:miMATRIX, :miCOMPRESSED].include?(tag.data_type)
 
           rescue EOFError
             STDERR.puts self.tag.inspect
@@ -545,7 +566,8 @@ module NMatrix::IO::Matlab
           #STDERR.puts "Ignored #{8 - bytes} on #{self.tag.data_type}"
           ignored = packedio.read(8 - bytes)
           ignored_unpacked = ignored.unpack("C*")
-          raise(IOError, "Nonzero padding detected: #{ignored_unpacked}") if ignored_unpacked.any? { |i| i != 0 }
+          raise(IOError, "Nonzero padding detected: #{ignored_unpacked}") \
+           if ignored_unpacked.any? { |i| i != 0 }
         end
       end
 
@@ -558,13 +580,16 @@ module NMatrix::IO::Matlab
     # manually, or pass the raw string of bytes into NMatrix.
     class RawElement < Element #:nodoc:
       def read_packed(packedio, options)
-        raise(ArgumentError, 'Missing mandatory option :endian.') unless options.has_key?(:endian)
+        raise(ArgumentError, 'Missing mandatory option :endian.') \
+         unless options.has_key?(:endian)
 
-        self.tag = packedio.read([Tag,   {:endian => options[:endian]           }])
-        self.data = packedio.read([String, {:endian => options[:endian], :bytes => tag.bytes }])
+        self.tag = packedio.read([Tag,   {:endian => options[:endian]}])
+        self.data = packedio.read([String, {:endian => options[:endian], \
+         :bytes => tag.bytes }])
 
         begin
-          ignore_padding(packedio, (tag.bytes + tag.size) % 8) unless [:miMATRIX, :miCOMPRESSED].include?(tag.data_type)
+          ignore_padding(packedio, (tag.bytes + tag.size) % 8) \
+           unless [:miMATRIX, :miCOMPRESSED].include?(tag.data_type)
 
         rescue EOFError
           STDERR.puts self.tag.inspect