ruby-gsl-ng 0.2.2 → 0.2.3

data/lib/gslng/matrix_view.rb

@@ -9,16 +9,17 @@ module GSLng
     class View < Matrix
       attr_reader :owner # The Matrix owning the data this View uses
 
-      # Create a MatrixView of the sub-matrix starting at (x,y), of size (m,n)
+      # Create a Matrix::View of the sub-matrix starting at (x,y), of size (m,n)
       def initialize(owner, x, y, m, n) # @private
         @owner = owner
         @m,@n = m,n
         @ptr = GSLng.backend::gsl_matrix_submatrix2(owner.ptr, x, y, m, n)
-        GSLng.set_finalizer(self, :gsl_matrix_free, @ptr)
+        GSLng.define_finalizer(self, :gsl_matrix_free, @ptr)
       end
 
       # Returns a Matrix (*NOT* a View) copied from this view. In other words,
       # you'll get a Matrix which you can modify without modifying #owner elements.
+      # @return [Matrix]
       def dup
         matrix = Matrix.new(@m, @n)
         GSLng.backend::gsl_matrix_memcpy(matrix.ptr, @ptr)

data/lib/gslng/rng/gaussian.rb

@@ -0,0 +1,34 @@
+module GSLng
+  class RNG
+    class Gaussian < RNG
+      attr_reader :ptr # @private
+
+      attr_reader :mu, :sigma
+      
+      # Creates a new Gaussian distribution
+      # @param [Float] mu mean
+      # @param [Float] sigma standard deviation
+      # @param [Symbol] sample_method The method to use to sample numbers. Can be either :boxmuller, :ziggurat or :ratio_method
+      # @param generator_type (see GSLng::RNG#initialize)
+      # @see http://www.gnu.org/software/gsl/manual/html_node/The-Gaussian-Distribution.html
+      def initialize(mu = 0, sigma = 1, sample_method = :boxmuller, generator_type = nil)
+        super(generator_type)
+        @mu,@sigma = mu,sigma
+
+        case sample_method
+        when :boxmuller; @function = :gsl_ran_gaussian
+        when :ziggurat; @function = :gsl_ran_gaussian_ziggurat
+        when :ratio_method; @function = :gsl_ran_ratio_method
+        else raise "Unsupported method"
+        end
+      end
+
+      # Obtain a sample from this distribution
+      # @return [Float]
+      def sample
+        GSLng.backend.send(@function, self.ptr, @sigma) + @mu
+      end
+      alias_method :get, :sample
+    end
+  end
+end

data/lib/gslng/rng/rng.rb

@@ -0,0 +1,27 @@
+module GSLng
+  # Random Number Generator class
+  # @abstract You should use any of the descendant classes which implement the {#sample} method.
+  class RNG
+    # Create a Generator of the given type
+    # @param [Symbol] generator_type the algorithm to use (without the +gsl_rng+ prefix). Default is :mt19937.
+    # @see http://www.gnu.org/software/gsl/manual/html_node/Random-number-generator-algorithms.html
+    def initialize(generator_type = nil)
+      @type = generator_type
+      if (@type.nil?) then @type = :mt19937 end # update comment above if changed
+      
+      type = GSLng.backend.send(:"gsl_rng_#{@type}")
+      @ptr = GSLng.backend.gsl_rng_alloc(type)
+      GSLng.define_finalizer(self, :gsl_rng_free, @ptr)
+    end
+
+    def initialize_copy
+      ObjectSpace.undefine_finalizer(self)
+      type = GSLng.backend.send(:"gsl_rng_#{@type}")
+      @ptr = GSLng.backend.gsl_rng_alloc(type)
+      GSLng.define_finalizer(self, :gsl_rng_free, @ptr)
+    end
+  end
+end
+
+require 'gslng/rng/gaussian'
+require 'gslng/rng/uniform'

data/lib/gslng/rng/uniform.rb

@@ -0,0 +1,23 @@
+module GSLng
+  class RNG
+    class Uniform < RNG
+      attr_reader :ptr # @private
+      
+      # Creates a new Uniform distribution with values in [min,max)
+      # @param [Float] min
+      # @param [Float] max
+      # @param generator_type (see GSLng::RNG#initialize)
+      def initialize(min, max, generator_type = nil)
+        super(generator_type)
+        @min,@max = min,max
+      end
+
+      # Obtain a sample from this distribution
+      # @return [Float]
+      def sample
+        GSLng.backend.gsl_ran_flat(self.ptr, @min, @max)
+      end
+      alias_method :get, :sample
+    end
+  end
+end

data/lib/gslng/special.rb

@@ -0,0 +1,22 @@
+module GSLng
+  # A group of several different special functions.
+  #
+  # =Notes
+  # You can use this module simply by acessing its functions. Optionally, you can also extend the +Math+ standard module
+  # with these methods by doing:
+  #  Math.extend(GSLng::Special)
+  #
+  module Special
+    extend self # allow this module to be used as such, and as a mixin
+
+    # Restrict the given angle to the interval (-pi,pi]
+    def angle_restrict_symm(theta)
+      GSLng.backend.gsl_sf_angle_restrict_symm(theta)
+    end
+
+    # Restrict the given angle to the interval (0,2pi]
+    def angle_restrict_pos(theta)
+      GSLng.backend.gsl_sf_angle_restrict_pos(theta)
+    end
+  end
+end

data/lib/gslng/vector.rb

@@ -2,31 +2,31 @@ module GSLng
   # A fixed-size n-dimensional vector.
   #
   # =Notes
-	# * #each is implemented through calls to #[], which can be relatively slow (compared to direct C pointer access)
-	#   for big Vectors. There's a faster version (#fast_each) that can be used when there's not return value expected from the #each call.
-  # * Since this class includes Enumerable, and Enumerable's methods call #each, certain methods are redefined (like #max and #min)
-  #   so they use #fast_each instead. Thus, any other Enumerable's method not defined here will be slower.
-	# * Some functions (like #sum, #dot, and others) use BLAS functions (through GSLng's CBLAS interface).
-	# * In contrary to Array, operators [] and []= will raise an exception when accessing out-of-bounds elements.
-  # * Operator * multiplies two vectors element-by-element. To perform a dot product use the ^ operator instead (or the #dot method).
-  # * Operands are coerced to vectors so you can do vector + scalar, etc. (see #coerce)
+  # * {#each}, {#map} and similar methods are implemented with C versions which should be fast.
+  # * {#map} returns a Vector, not an Array. Use {#map_array} for that.
+  # * While this class includes Enumerable, certain methods are redefined (like {#max} and {#min})
+  #   so they use internal GSL methods.
+  # * Some functions (like {#sum}, {#dot}, and others) use BLAS functions (through GSLng's CBLAS interface).
+  # * In contrary to Array, operators {#[]} and {#[]=} will raise an exception when accessing out-of-bounds elements.
+  # * Operator {#*} multiplies two vectors element-by-element. To perform a dot product use the {#^} operator instead (or the {#dot} alias).
+  # * Operands are coerced to vectors so you can do vector + scalar, etc. (see {#coerce})
   #
   class Vector
     include Enumerable
-    
-    attr_reader :ptr	# @private
-    attr_reader :size # Vector size
+        
+    attr_reader :size
+    attr_reader :ptr  # @private
 
     #--------------------- constructors -------------------------#
     
     # Create a Vector of size n. If zero is true, the vector is initialized with zeros.
     # Otherwise, the vector will contain garbage.
-		# You can optionally pass a block, in which case #map_index! will be called with it (i.e.: it works like Array.new).
+    # You can optionally pass a block, in which case {#map_index!} will be called with it (i.e.: it works like {Array.new}).
     def initialize(n, zero = false)
       @size = n
       @ptr = (zero ? GSLng.backend::gsl_vector_calloc(n) : GSLng.backend::gsl_vector_alloc(n))
-      GSLng.set_finalizer(self, :gsl_vector_free, @ptr)
-			if (block_given?) then self.map_index!(Proc.new) end
+      GSLng.define_finalizer(self, :gsl_vector_free, @ptr)
+      if (block_given?) then self.map_index!(Proc.new) end
     end
 
     def initialize_copy(other) # @private
@@ -34,41 +34,45 @@ module GSLng
       
       @size = other.size
       @ptr = GSLng.backend::gsl_vector_alloc(other.size)
-      GSLng.set_finalizer(self, :gsl_vector_free, @ptr)
+      GSLng.define_finalizer(self, :gsl_vector_free, @ptr)
       
       GSLng.backend::gsl_vector_memcpy(@ptr, other.ptr)
     end
 
-		# Same as Vector.new(n, true)
-		def Vector.zero(n); Vector.new(n, true) end
+    # Same as Vector.new(n, true)
+    def Vector.zero(n); Vector.new(n, true) end
 
-		# Create a vector from an Array.
-		def Vector.from_array(array)
-			if (array.empty?) then raise "Can't create empty vector" end
-			Vector.new(array.size) {|i| array[i]}
-		end
+    # Create a vector from an Array.
+    def Vector.from_array(array)
+      if (array.empty?) then raise "Can't create empty vector" end
+      v = Vector.new(array.size)
+      GSLng.backend.gsl_vector_from_array(v.ptr.to_i, array)
+      return v
+    end
 
-		# Creates a Vector from an Array (see #from_array) or a Range. For example:
-    #  Vector[1,2,3]
-    #  Vector[1..3]
-		def Vector.[](*args)
+    # Creates a Vector from an Array or a Range
+    # @see Vector::from_array    
+    # @example
+    #   Vector[1,2,3]
+    #   Vector[1..3]
+    def Vector.[](*args)
       array = (args.size == 1 && Range === args[0] ? args[0].to_a : args)
-			Vector.from_array(array)
-		end
+      Vector.from_array(array)
+    end
 
     # Generates a Vector of n random numbers between 0 and 1.
-    # NOTE: This simply uses Kernel::rand
+    # NOTE: This simply uses {Kernel::rand}
     def Vector.random(n)
-			Vector.new(n).map!{|x| Kernel::rand}
+      Vector.new(n).map!{|x| Kernel::rand}
     end
-		class << self; alias_method :rand, :random end
+    class << self; alias_method :rand, :random end
 
     #--------------------- setting values -------------------------#
     
     # Set all values to v
     def all!(v); GSLng.backend::gsl_vector_set_all(self.ptr, v); return self end
-		alias_method :set!, :all!
-		alias_method :fill!, :all!
+    alias_method :set!, :all!
+    alias_method :fill!, :all!
     
     # Set all values to zero
     def zero!; GSLng.backend::gsl_vector_set_zero(self.ptr); return self end
@@ -79,53 +83,57 @@ module GSLng
     #--------------------- operators -------------------------#
     
     # Add (element-by-element) other to self
+    # @return [Vector] self
     def add!(other)
       case other
       when Numeric; GSLng.backend::gsl_vector_add_constant(self.ptr, other.to_f)
       when Vector; GSLng.backend::gsl_vector_add(self.ptr, other.ptr)
       else
-				x,y = other.coerce(self)
-				x.add!(y)
-			end
-			return self
+        x,y = other.coerce(self)
+        x.add!(y)
+      end
+      return self
     end
     
     # Substract (element-by-element) other from self
+    # @return [Vector] self    
     def substract!(other)
       case other
       when Numeric; GSLng.backend::gsl_vector_add_constant(self.ptr, -other.to_f)
       when Vector; GSLng.backend::gsl_vector_sub(self.ptr, other.ptr)
       else
-				x,y = other.coerce(self)
-				x.sub!(y)
-			end
-			return self
+        x,y = other.coerce(self)
+        x.sub!(y)
+      end
+      return self
     end
     alias_method :sub!, :substract!
     
     # Multiply (element-by-element) other with self
+    # @return [Vector] self
     def multiply!(other)
       case other
       when Numeric; GSLng.backend::gsl_blas_dscal(other.to_f, self.ptr)
       when Vector; GSLng.backend::gsl_vector_mul(self.ptr, other.ptr)
       else
-				x,y = other.coerce(self)
-				x.mul!(y)
-			end
-			return self
+        x,y = other.coerce(self)
+        x.mul!(y)
+      end
+      return self
     end
     alias_method :mul!, :multiply!
     
     # Divide (element-by-element) self by other
+    # @return [Vector] self
     def divide!(other)
       case other
       when Numeric; GSLng.backend::gsl_blas_dscal(1.0 / other, self.ptr)
       when Vector;  GSLng.backend::gsl_vector_div(self.ptr, other.ptr)
       else
-				x,y = other.coerce(self)
-				x.div!(y)
-			end
-			return self
+        x,y = other.coerce(self)
+        x.div!(y)
+      end
+      return self
     end
     alias_method :div!, :divide!
 
@@ -136,14 +144,17 @@ module GSLng
     def -(other); self.dup.sub!(other) end
 
     # Element-by-element product
+    # @example
+    #  Vector[1,2,3] * 2 => [2.0, 4.0, 6.0]:Vector
+    #  Vector[1,2,3] * Vector[0,1,2] => [0.0, 2.0, 6.0]:Vector    
     def *(other)
       case other
       when Numeric; self.dup.mul!(other)
       when Vector; self.dup.mul!(other)
       else
-				x,y = other.coerce(self)
-				x * y
-			end
+        x,y = other.coerce(self)
+        x * y
+      end
     end
 
     # Element-by-element division
@@ -155,6 +166,9 @@ module GSLng
     #--------------------- other math -------------------------#
 
     # Dot product between self and other (uses BLAS's ddot)
+    # @return [Float]
+    # @example
+    #  Vector[1,2,3] ^ Vector[0,1,2] => 8.0
     def dot(other)
       out = FFI::Buffer.new(:double)
       GSLng.backend::gsl_blas_ddot(self.ptr, other.ptr, out)
@@ -180,29 +194,54 @@ module GSLng
     # Swap the i-th element with the j-th element
     def swap(i,j); GSLng.backend::gsl_vector_swap_elements(self.ptr, i, j); return self end
 
-		def sort!; GSLng.backend::gsl_sort_vector(self.ptr); return self end
-		def sort; self.dup.sort! end
+    def sort!; GSLng.backend::gsl_sort_vector(self.ptr); return self end
+    def sort; self.dup.sort! end
 
     # Copy other's values into self
     def copy(other); GSLng.backend::gsl_vector_memcpy(self.ptr, other.ptr); return self end
 
+    # Wraps self into the interval [min,max) by adding or substracting (max-min) to each component as necessary.
+    # Note that wrapping is done only with a single addition/substraction.
+    # @param [Vector,Numeric] min 
+    # @param [Vector,Numeric] max
+    # @return [Vector] a vector of values -1, 1 or 0, if (max-min) was substracted, added to the coordinate,
+    # or not modified, respectively.
+    # @example Assuming that +v = Vector[-8,2,8]+
+    #  v.wrap(0, 5) => [1.0 0.0 -1.0]:Vector
+    #  v => [-3.0 2.0 3.0]:Vector
+    def wrap!(min, max)
+      min,other = self.coerce(min)
+      max,other = self.coerce(max)
+      delta = Vector.new(self.size)
+      range = max - min
+      
+      self.map_index! do |i|
+        if (self[i] < min[i]) then delta[i] = 1; self[i] + range[i]
+        elsif (self[i] >= max[i]) then delta[i] = -1; self[i] - range[i]
+        else delta[i] = 0; self[i] end
+      end
+      return delta
+    end
+
     #--------------------- set/get -------------------------#
 
-		# Access the i-th element (*NOTE*: throws exception if out-of-bounds).
-		# If _index_ is negative, it counts from the end (-1 is the last element).
-		# TODO: support ranges
+    # Access the i-th element.
+    # If _index_ is negative, it counts from the end (-1 is the last element).
+    # @raise [RuntimeError] if out-of-bounds
+    # @todo support ranges    
     def [](index)
-			GSLng.backend::gsl_vector_get(self.ptr, (index < 0 ? @size + index : index))
+      GSLng.backend::gsl_vector_get(self.ptr, (index < 0 ? @size + index : index))
     end
 
-		# Set the i-th element (*NOTE*: throws exception if out-of-bounds).
-		# If _index_ is negative, it counts from the end (-1 is the last element).
-		# TODO: support ranges
+    # Set the i-th element.
+    # If _index_ is negative, it counts from the end (-1 is the last element).
+    # @raise [RuntimeError] if out-of-bounds
+    # @todo support ranges    
     def []=(index, value)
-			GSLng.backend::gsl_vector_set(self.ptr, (index < 0 ? @size + index : index), value.to_f)
+      GSLng.backend::gsl_vector_set(self.ptr, (index < 0 ? @size + index : index), value.to_f)
     end
 
-    # Create a Vector::View from this Vector.
+    # Create a {Vector::View} from this Vector.
     # If _size_ is nil, it is computed automatically from _offset_ and _stride_
     def view(offset = 0, size = nil, stride = 1)
       if (stride <= 0) then raise 'stride must be positive' end
@@ -223,15 +262,24 @@ module GSLng
     def subvector(*args); subvector_view(*args).to_vector end
 
     #------------ utility methods for 2D,3D and 4D vectors -----------#
+
+    # Same as Vector#[0]
     def x; GSLng.backend::gsl_vector_get(self.ptr, 0) end
+    # Same as Vector#[1]
     def y; GSLng.backend::gsl_vector_get(self.ptr, 1) end
-    def z; GSLng.backend::gsl_vector_get(self.ptr, 2) end
-    def w; GSLng.backend::gsl_vector_get(self.ptr, 3) end
+    # Same as Vector#[2]
+    def z; GSLng.backend::gsl_vector_get(self.ptr, 2) end 
+    # Same as Vector#[3]
+    def w; GSLng.backend::gsl_vector_get(self.ptr, 3) end 
 
+    # Same as Vector#[0]=
     def x=(v); GSLng.backend::gsl_vector_set(self.ptr, 0, v.to_f) end
+    # Same as Vector#[1]=
     def y=(v); GSLng.backend::gsl_vector_set(self.ptr, 1, v.to_f) end
+    # Same as Vector#[2]=
     def z=(v); GSLng.backend::gsl_vector_set(self.ptr, 2, v.to_f) end
-    def w=(v); GSLng.backend::gsl_vector_set(self.ptr, 3, v.to_f) end
+    # Same as Vector#[3]=
+    def w=(v); GSLng.backend::gsl_vector_set(self.ptr, 3, v.to_f) end 
     
     #--------------------- predicate methods -------------------------#
 
@@ -243,10 +291,22 @@ module GSLng
 
     #if all elements are strictly negative (<0)
     def negative?; GSLng.backend::gsl_vector_isneg(self.ptr) == 1 ? true : false end
-		
+    
     # if all elements are non-negative (>=0)
     def nonnegative?; GSLng.backend::gsl_vector_isnonneg(self.ptr) == 1 ? true : false end
 
+    # If each element of self is less than other's elements
+    def <(other); (other - self).positive? end
+
+    # If each element of self is greater than other's elements
+    def >(other); (other - self).negative? end
+
+    # If each element of self is less-or-equal than other's elements
+    def <=(other); (other - self).nonnegative? end
+
+    # If each element of self is less-or-equal than other's elements
+    def >=(other); (self - other).nonnegative? end
+
     #--------------------- min/max -------------------------#
 
     # Return maximum element of vector
@@ -255,7 +315,7 @@ module GSLng
     # Return minimum element of vector
     def min; GSLng.backend::gsl_vector_min(self.ptr) end
 
-		# Same as Array#minmax
+    # Same as {Array#minmax}
     def minmax
       min = FFI::Buffer.new(:double)
       max = FFI::Buffer.new(:double)
@@ -263,87 +323,97 @@ module GSLng
       return [min[0].get_float64(0),max[0].get_float64(0)]
     end
 
-		# Same as #minmax, but returns the indices to the elements
+    # Same as {#minmax}, but returns the indices to the elements
     def minmax_index
       min = FFI::Buffer.new(:size_t)
       max = FFI::Buffer.new(:size_t)
       GSLng.backend::gsl_vector_minmax_index(self.ptr, min, max)
       #return [min[0].get_size_t(0),max[0].get_size_t(0)]
-			return [min[0].get_ulong(0),max[0].get_ulong(0)]
+      return [min[0].get_ulong(0),max[0].get_ulong(0)]
     end
     
-    # Same as #min, but returns the index to the element
+    # Same as {#min}, but returns the index to the element
     def min_index; GSLng.backend::gsl_vector_min_index(self.ptr) end
 
-    # Same as #max, but returns the index to the element
+    # Same as {#max}, but returns the index to the element
     def max_index; GSLng.backend::gsl_vector_max_index(self.ptr) end
 
     #--------------------- block handling -------------------------#
-    
-    # Yields the block for each element in the Vector
-		def each # :yield: obj
-			@size.times {|i| yield(self[i])}
-		end
-
-    # Same as #each, but faster. The catch is that this method returns nothing.
-    def fast_each(block = Proc.new) #:yield: obj
-      GSLng.backend::gsl_vector_each(self.ptr, block)
+
+    # Same as {#each}, but faster. The catch is that this method returns nothing.
+    # @yield [elem]
+    def each(block = Proc.new)
+      GSLng.backend::gsl_vector_each(self.ptr.to_i, &block)
     end
 
-    def fast_each_with_index(block = Proc.new) #:yield: obj,i
-      GSLng.backend::gsl_vector_each_with_index(self.ptr, block)
+    # @see #each
+    # @yield [elem,i]
+    def each_with_index(block = Proc.new)
+      GSLng.backend::gsl_vector_each_with_index(self.ptr.to_i, &block)
     end
 
-		# Efficient map! implementation
-		def map!(block = Proc.new); GSLng.backend::gsl_vector_map(self.ptr, block); return self end
+    # Efficient {#map!} implementation.
+    def map!(block = Proc.new); GSLng.backend::gsl_vector_map!(self.ptr.to_i, &block); return self end
 
-		# Alternate version of #map!, in this case the block receives the index as a parameter.
-		def map_index!(block = Proc.new); GSLng.backend::gsl_vector_map_index(self.ptr, block); return self end
+    # Similar to {#map!}, but passes the index to the element instead.
+    # @yield [i]
+    def map_index!(block = Proc.new); GSLng.backend::gsl_vector_map_index!(self.ptr.to_i, &block); return self end
 
-		# See #map!. Returns a Vector.
-		def map(block = Proc.new); self.dup.map!(block) end
+    # @return [Vector]
+    # @see map_index!
+    # @yield [i]
+    def map_index(block = Proc.new); self.dup.map_index!(block) end
 
-    # Same as #map but returns an Array
-    def map_array(block = Proc.new) ary = []; self.fast_each {|elem| ary << block.call(elem)}; return ary end
+    alias_method :map_array, :map
+
+    # @return [Vector]
+    # @yield [elem]
+    def map(block = Proc.new); self.dup.map!(block) end
 
     #--------------------- conversions -------------------------#
 
-    # Same as Array#join
-		def join(sep = $,)
-			s = ''
-			GSLng.backend::gsl_vector_each(self.ptr, lambda {|e| s += (s.empty?() ? e.to_s : "#{sep}#{e}")})
-			return s
-		end
+    # @see Array#join
+    # @return [String]
+    def join(sep = $,)
+      s = ''
+      self.each do |e|
+        s += (s.empty?() ? e.to_s : "#{sep}#{e}")
+      end
+      return s
+    end
 
-    # Coerces _other_ to be a Vector. If _other_ is a scalar (a Numeric) a vector of the same size as self
-    # will be created with all values set to _other_.
-		def coerce(other)
+    # Coerces _other_ to be a Vector. 
+    # @example
+    #  Vector[1,2].coerce(5) => [[5.0, 5.0]:Vector, [1.0, 2.0]:Vector]
+    def coerce(other)
       case other
-			when Vector
-				[ other, self ]
-			when Numeric
-				[ Vector.new(@size).set!(other), self ]
-			else
-				raise TypeError, "Can't coerce #{other.class} into #{self.class}"
-			end
-		end
-
-    # Convert to String (same format as Array#to_s):
+      when Vector
+        [ other, self ]
+      when Numeric
+        [ Vector.new(@size).set!(other), self ]
+      else
+        raise TypeError, "Can't coerce #{other.class} into #{self.class}"
+      end
+    end
+
+    # @return [String] same format as {Array#to_s}
+    # @example
     #  Vector[1,2,3].to_s => "[1.0, 2.0, 3.0]"
-		def to_s
-			"[" + self.join(', ') + "]"
-		end
+    def to_s
+      "[" + self.join(', ') + "]"
+    end
 
     def inspect # @private
       "#{self}:Vector"
     end
 
-    # Convert to Array
-		def to_a
-			Array.new(@size) {|i| self[i]}
-		end
+    # @return [Array]
+    def to_a
+      GSLng.backend.gsl_vector_to_a(self.ptr.to_i)
+    end
 
     # Create a row matrix from this vector
+    # @return [Matrix]
     def to_matrix
       m = Matrix.new(1, @size)
       GSLng.backend::gsl_matrix_set_row(m.ptr, 0, self.ptr)
@@ -352,6 +422,7 @@ module GSLng
     alias_method :to_row, :to_matrix
 
     # Create a column matrix from this vector
+    # @return [Matrix]
     def transpose
       m = Matrix.new(@size, 1)
       GSLng.backend::gsl_matrix_set_col(m.ptr, 0, self.ptr)
@@ -361,13 +432,13 @@ module GSLng
 
     #--------------------- equality -------------------------#
 
-		# Element-by-element comparison. Admits comparing to Array.
-		def ==(other)
-			if (self.size != other.size) then return false end
-			self.fast_each_with_index do |elem,i|
-				if (elem != other[i]) then return false end
-			end
-			return true
-		end
+    # Element-by-element comparison. Admits comparing to Array.
+    def ==(other)
+      if (self.size != other.size) then return false end
+      self.each_with_index do |elem,i|
+        if (elem != other[i]) then return false end
+      end
+      return true
+    end
   end
 end