csrmatrix 1.0.0 → 1.0.1

data/lib/csrmatrix/functions.rb

@@ -1,33 +1,69 @@
 module CsrMatrix
     module Functions
-        
+        include Contracts::Core
+        include Contracts::Builtin
+        C = Contracts
+
+        def self.included(exceptions)
+            exceptions.send :include, Exceptions
+        end
+
+        Contract C::None => C::Num
         def determinant()
+            # identifies the determinant of a matrix
+            is_invariant?
+            if !self.square?()
+                raise Exceptions::MatrixDimException.new, "Matrix is not square."
+                return false
+            end
+
             m = Matrix.rows(self.decompose)
-            m.det()
-        end
+            return m.det()
+        end # determinant
 
+        Contract C::None => C::Num
         def det()
-            self.determinant()
-        end
+            # alias for determinant
+            # identifies the determinant of a matrix
+            is_invariant?
+            return self.determinant()
+        end # det
 
+        Contract C::None => C::Num
         def rank()
+            # identifies the rank of a matrix
+            is_invariant?
             m = Matrix.rows(self.decompose)
-            m.rank()
-        end
+            return m.rank()
+        end # rank
 
+        #FIXME: I'm not sure whats going on here?
         def round(ndig = 0)
-            m = Matrix.rows(self.decompose)
-            self.build_from_array(m.round(ndig).to_a())
-        end
+            # identifies the round of a matrix (that is, each value rounded by a specific degree)
+            # pre   integer of degree, existing matrix (matrix.not_null?)
+            is_invariant?
+            # post  rounded array
+            for i in 0..self.val.count-1
+                self.val[i] = self.val[i].round(ndig)
+            end    
+            self.val
+        end # round
 
+        Contract C::None => Contracts::Num
         def trace()
+            # identifies the trace of the matrix
+            is_invariant?
             m = Matrix.rows(self.decompose)
-            m.trace()
-        end
+            return m.trace()
+        end # trace
 
+        Contract C::None => Contracts::Num
         def tr()
-            self.trace()
-        end
+            # alias for trace
+            # identifies the trace of the matrix
+            is_invariant?
+            return self.trace()
+        end # tr
 
-    end
-end
+    end # Functions
+end # CsrMatrix

data/lib/csrmatrix/helpers.rb

@@ -6,8 +6,10 @@ module CsrMatrix
 		# for pre-processing of matrix
 		#
 
-		# Identifies the 'column' value of an array (eg. the number of entries in a column)
 		def max_col(array)
+			# Identifies the 'column' value of an array (eg. the number of entries in a column)
+			# pre 	array
+			# post 	column count of array
 			values = array
 			max_count = 0
 			# Loop over indexes.
@@ -23,19 +25,24 @@ module CsrMatrix
 			  end
 			end
 			return max_count
-		end
+		end # max_col
 
-		# Identifies the 'row' value of an array (eg. the number of entries in a row)
 		def max_row(array)
+			# Identifies the 'row' value of an array (eg. the number of entries in a row)
+			# pre 	array
+			# post 	row count of array
 			values = array
 			max_count = 0
 			values.each_index do |i|
 			  max_count += 1
 			end
 			return max_count
-		end
+		end # max_row
 
 		def count_nonzero(array) 
+			# Finds all nonzero values in an array.
+			# pre 	array 
+			# post 	int nonzero count of array
 			max_count = 0
 			array.each_index do |i|
 				subarray = array[i]
@@ -46,10 +53,13 @@ module CsrMatrix
 			  end
 			end
 			return max_count
-		end
+		end # count_nonzero
 
-		# Code taken from http://stackoverflow.com/questions/9545613/getting-dimension-of-multidimensional-array-in-ruby
 		def depth(array)
+			# Code from http://stackoverflow.com/questions/9545613/getting-dimension-of-multidimensional-array-in-ruby
+			# Identifies the depth of an array.
+			# pre 	array
+			# post 	int depth of array
 	    return 0 if array.class != Array
 			result = 1
 			array.each do |sub_a|
@@ -59,10 +69,12 @@ module CsrMatrix
 			  end
 			end
 			return result
-		end	
+		end	# depth
 
-		# Counts all elements in array - assumed 2d
     def count_total(array) 
+    	# Counts all elements in array - assumed 2d
+    	# pre 	array
+    	# post 	int count of all elements
       max_count = 0
       array.each_index do |i|
         subarray = array[i]
@@ -71,7 +83,7 @@ module CsrMatrix
         end
       end
       return max_count
-    end
+    end # count_total
 	
-  end
-end
+  end # Helpers
+end # CsrMatrix

data/lib/csrmatrix/mcontracts.rb

@@ -0,0 +1,9 @@
+module CsrMatrix    
+  module MContracts
+    class TwoDMatrixType
+      def self.valid? val
+        val.is_a? TwoDMatrix
+      end
+    end
+  end
+end

data/lib/csrmatrix/operations.rb

@@ -1,33 +1,75 @@
+require "csrmatrix/exceptions"
+
 module CsrMatrix
     module Operations
+        include Contracts::Core
+        C = Contracts
+
+        Contract C::Nat => C::Num
         def get_value(index)
+            # gets the value off of the index of matrix
+            is_invariant?
             return @val[index]
-        end
+        end # get_value
+
+        Contract C::Nat, C::Or[C::Nat, nil] => C::Num 
+        def index(row, col=nil)
+            # gets the index in the matrix at row, col
+            is_invariant?
+                
+            if col == nil
+                if @val.count < row
+                  raise CsrMatrix::Exceptions::IndexOutOfRangeException.new, "Index out of Bounds"
+                  return false
+                end
+
+              return @val[row-1]
+            else
+              if !checkInputBounds(row, col)
+                raise CsrMatrix::Exceptions::IndexOutOfRangeException.new, "Index out of Bounds"
+                return false
+              end
 
+              num_elm_in_prev = row_ptr[row-1]
+              num_elm_in_row = row_ptr[row] - num_elm_in_prev
+                
+              (0...num_elm_in_row).each do | x |
+                if ( col-1 == @col_ind[num_elm_in_prev+x] )
+                  return @val[num_elm_in_prev+x]
+                end
+              end
+              return 0
+            end
+        end # index
+
+        Contract C::None => C::Any
         def print_full()
-            (0...@col_ind.length).each do |iter|
-                (0...@col_ind.length).each do |col|
-                    if (iter == @row_ptr[iter] and col == @col_ind[iter])
-                        print "#{get_value(iter)}  "
-                    else
-                        print "0  "
-                    end
+            # prints the full matrix for user
+            is_invariant?
+            full_matrix = self.decompose()
+            full_matrix.each do | row |
+                row.each do | val |
+                    print "#{val}  "
                 end
                 puts ""
-            end    
-        end
+            end
+        end # print_full
 
+        Contract C::None => C::Any
         def print_sparse()
-            (0...@col_ind.length).each do |iter|
-                (0...@col_ind.length).each do |col|
-                    if (iter == @row_ptr[iter] and col == @col_ind[iter])
-                        print "#{get_value(iter)}  "
+            # prints all nonzero values of matrix for user
+            is_invariant?
+            full_matrix = self.decompose()
+            full_matrix.each do | row |
+                row.each do | val |
+                    if val == 0
+                        print "---"
                     else
-                        print "0  "
+                        print " #{val} "    
                     end
                 end
                 puts ""
             end
-        end    
-    end
-end
+        end # print_sparse   
+    end # Operations
+end # CsrMatrix

data/lib/csrmatrix/properties.rb

@@ -1,98 +1,221 @@
-module CsrMatrix
-    module Properties
-
-        def self.included(exceptions)
-          exceptions.send :include, Exceptions
-        end 
-        
-        # Determines if the matrix is diagonal; wherein the values outside the main diagonal are all zero.
-        def diagonal?
-            m = Matrix.rows(self.decompose)
-            return m.diagonal?
-        end
-
-        # Determines if the matrix is empty; wherein all the values are zero.
-        def empty?
-            m = Matrix.rows(self.decompose)
-            return m.empty?
-        end
-
-        # Determine if the matrix is hermitian.
-        def hermitian?
-            m = Matrix.rows(self.decompose)
-            return m.hermitian?
-        end
-
-        # Determines if the matrix is lower-diagonal; wherein all the values only exist on and below the diagonal line.
-        def lower_triangular?
-            m = Matrix.rows(self.decompose)
-            return m.lower_triangular?
-        end
-
-        # Determines if the matrix is normal; wherein if the number of rows or columns is 0
-        def normal? 
-            m = Matrix.rows(self.decompose)
-            return m.normal?
-        end
-
-        # Determines if the matrix is orthogonal; wherein the rows and columns are orthogonal unit vectors.
-        def orthogonal?
-            m = Matrix.rows(self.decompose)
-            return m.orthogonal?
-        end
-
-        # Determines if the matrix is a permutation; wherein it is an nxn version of the identity matrix.
-        def permutation?
-            m = Matrix.rows(self.decompose)
-            return m.permutation?
-        end
-
-        # Determines if the matrix is real; wherein the matrix consists entirely of real numbers.
-        def real?
-            m = Matrix.rows(self.decompose)
-            return m.real?
-        end
-
-        # Determines if the matrix is nonsingular
-        def nonsingular?
-            return !self.singular?
-        end
-
-        # Determines if the matrix is singular
-        def singular?
-            m = Matrix.rows(self.decompose)
-            return m.singular?
-        end
-
-        # Determines if the matrix is square
-        def square?
-            m = Matrix.rows(self.decompose)
-            return m.square?
-        end
-
-        # Determines if the matrix is symmetric
-        def symmetric?
-            m = Matrix.rows(self.decompose)
-            return m.symmetric?
-        end
-
-        # Determines if the matrix is unitary
-        def unitary?
-            m = Matrix.rows(self.decompose)
-            return m.unitary?
-        end
-
-        # Determines if the matrix is upper-triangular
-        def upper_triangular?
-            m = Matrix.rows(self.decompose)
-            return m.upper_triangular?
-        end
-
-        # Determines if the matrix is zero
-        def zero?
-            m = Matrix.rows(self.decompose)
-            return m.zero?
-        end
+require "matrix"
+require "csrmatrix/exceptions"
+require "contracts"
 
+module CsrMatrix
+  module Properties
+    include Contracts::Core
+    C = Contracts
+
+    def self.included(exceptions)
+      exceptions.send :include, Exceptions
+    end 
+    
+    Contract C::None => C::Bool
+    def diagonal?
+    	# Determines if the matrix is diagonal; wherein the values outside the main diagonal are all zero.
+      is_invariant?
+      for i in 0..self.columns-1
+				if (self.col_ind[i] != i) || (self.row_ptr[i] != i)
+					return false
+				end
+			end
+			return true
+    end # diagonal?
+
+    Contract C::None => C::Bool
+    def empty?
+      # Determines if the matrix is empty; wherein all the values are zero.
+      is_invariant?
+			if self.val.count() == 0
+				return true
+			end
+			return false
+    end # empty?
+
+    Contract C::None => C::Bool
+    def lower_triangular?
+      # Determines if the matrix is lower-diagonal; wherein all the values only exist on and below the diagonal line.
+      is_invariant?
+			for i in 0..self.columns-1
+				for column_index in row_ptr[i]..row_ptr[i+1]-1
+					if (self.col_ind[column_index] > i)
+						return false
+					end
+				end
+			end
+			return true
+    end # lower_triangular?
+
+		#USES COMPLEX MATRIX
+    Contract C::None => C::Bool
+    def normal? 
+      # Determines if the matrix is normal
+      is_invariant?
+			if !self.square?
+			  raise Exceptions::MatrixDimException.new, "Matrix is not square."
+        return false
+      end
+
+      m = Matrix.rows(self.decompose)
+      return m.normal?
+    end # normal?
+
+    Contract C::None => C::Bool
+    def orthogonal?
+      # Determines if the matrix is orthogonal; wherein the rows and columns are orthogonal unit vectors.
+      is_invariant?
+      if !self.square?
+        raise Exceptions::MatrixDimException.new, "Matrix is not square."
+        return false
+      end
+
+			# transpose the existing matrix
+			@matrix_transpose = TwoDMatrix.new
+			@matrix_transpose.build_from_csr(self.row_ptr, self.col_ind, self.val, self.columns, self.rows)
+			@matrix_transpose.transpose()
+
+			# build an orthogonal matrix
+			@matrix_orthogonal = TwoDMatrix.new
+			@matrix_orthogonal.build_from_array(self.multiply_csr(@matrix_transpose))
+			
+			# test the values in the orthogonal matrix
+			for i in 0..@matrix_orthogonal.val.count()-1
+				if @matrix_orthogonal.val[i] != 1
+					return false
+				end
+			end
+			return true
+    end # orthogonal?
+
+    Contract C::None => C::Bool
+    def permutation?
+      # Determines if the matrix is a permutation; wherein it is an nxn version of the identity matrix.
+      is_invariant?
+	    if !self.square?
+		    raise Exceptions::MatrixDimException.new, "Matrix is not square."
+        return false
+      end
+
+			#Check the proper number of values
+			if self.val.length != self.columns
+				return false
+			end
+
+			#check for the proper values. ie only 1's				
+			for value in self.val
+				if value != 1
+					return false
+				end
+			end
+
+			column_ind = self.col_ind
+      for column_index in self.col_ind
+				if column_ind.include?(column_index)
+					column_ind.remove(column_index)
+				else
+					return false
+				end
+			end
+    end # permutation?
+
+    Contract C::None => C::Bool
+    def real?
+      # Determines if the matrix is real; wherein the matrix consists entirely of real numbers.
+      is_invariant?
+      for value in self.val
+				if !value.is_a? Numeric
+					return false
+				end
+			end
+			return true
+    end # real?
+
+    Contract C::None => C::Bool
+    def not_null?
+      if @val == nil
+        return false
+      end
+      return true
     end
-end
+
+    Contract C::None => C::Bool
+    def nonsingular?
+      # Determines if the matrix is nonsingular ; simply the inverse of the singular function
+      is_invariant?
+      return !self.singular?
+    end # nonsingular?
+
+    Contract C::None => C::Bool
+    def singular?
+      # Determines if the matrix is singular
+      is_invariant?
+      if self.determinant != 0
+				return false
+			end
+			return true
+    end # singular?
+
+    Contract C::None => C::Bool
+    def symmetric?
+      # Determines if the matrix is symmetric
+      is_invariant?
+			if !self.square?
+				raise Exceptions::MatrixDimException.new, "Matrix is not square."
+        return false
+      end
+			
+      # transpose the existing matrix
+			@matrix_transpose = TwoDMatrix.new
+			@matrix_transpose.build_from_csr(self.row_ptr, self.col_ind, self.val, self.columns, self.rows)
+			@matrix_transpose.transpose()
+
+			for i in 0..self.val.count()-1
+				if self.val[i] != @matrix_transpose.val[i]
+					return false
+				end
+			end
+			return true
+    end # symmetric? 
+
+		#USES COMPLEX MATRIX
+    Contract C::None => C::Bool
+    def unitary?
+      # Determines if the matrix is unitary
+      is_invariant?
+			if !self.square?
+				raise Exceptions::MatrixDimException.new, "Matrix is not square."
+        return false
+      end
+      m = Matrix.rows(self.decompose)
+      return m.unitary?
+    end # unitary?
+
+    Contract C::None => C::Bool
+    def upper_triangular?
+      # Determines if the matrix is upper-triangular
+      is_invariant?
+      for i in 0..self.columns-1
+				for column_index in row_ptr[i]..row_ptr[i+1]-1
+					if (self.col_ind[column_index] < i)
+						return false
+					end
+				end
+			end
+			return true
+    end # upper triangular?
+
+    Contract C::None => C::Bool
+    def zero?
+      # Determines if the matrix is zero
+      is_invariant?
+      for value in self.val
+				if value != 0
+					return false
+				end
+			end
+			return true
+    end # zero?
+
+  end # Properties
+end # CsrMatrix

data/lib/csrmatrix/version.rb

@@ -1,3 +1,3 @@
 module CsrMatrix
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end