matrizHM 0.0.1 → 1.0.1

data/.gitignore

@@ -15,3 +15,5 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+*~
+*.*~

data/Guardfile

@@ -0,0 +1,10 @@
+guard 'bundler' do
+        watch('Gemfile')
+        watch(/^.+\.gemspec/)
+end
+
+guard 'rspec', :version => 2 do
+        watch(%r{^spec/.+_spec\.rb$})
+        watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+        watch('spec/spec_helper.rb')  { "spec" }
+end

data/Rakefile

@@ -1 +1,10 @@
 require "bundler/gem_tasks"
+
+$:.unshift File.dirname(__FILE__) + 'lib'
+$:.unshift './lib', './spec'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+task :default => :spec
+
+

data/lib/gcd.rb

@@ -0,0 +1,8 @@
+def gcd(u,v)
+  u, v = u.abs, v.abs
+  while v > 0
+    u, v = v, u % v
+  end
+  u
+end
+

data/lib/matriz.rb

@@ -0,0 +1,273 @@
+# coding: utf-8
+
+module Operatoria
+     
+   #Funcion que asigna un valor k a una posicion i,j dentro de la matriz
+   def []=(i, j, k)
+      matriz[i][j] = k
+   end
+  
+    #Sobrecargado el + para poder sumar 2 matrices
+   def +(other)
+      raise ArgumentError, "La longitud de las matrices no coincide." unless @filas == other.filas && @columnas == other.columnas       
+      sum = Matriz.new(matriz)  #inicializas el vector sum con el primer con el primer
+      self.filas.times do |i|   
+         self.columnas.times do |j|
+            sum.matriz[i][j] = self.matriz[i][j] + other.matriz[i][j]             
+         end
+      end
+      return sum #devuelve un tipo array modificando el objeto m1 si se hace m3=m1+m2 -> Se necesita q sea tipo Matriz
+   end
+   
+   #Sobrecargado el - para poder restar 2 matrices
+   def -(other)
+      raise ArgumentError, "La longitud de las matrices no coincide." unless @filas == other.filas && @columnas == other.columnas
+      resta = Matriz.new(matriz)
+      self.filas.times do |i|  
+         self.columnas.times do |j|
+            resta.matriz[i][j] = self.matriz[i][j] - other.matriz[i][j]             
+         end
+      end
+      return resta  #devuelve un tipo matriz modificando el objeto m1 si se hace m3=m1+m2
+   end
+   
+
+   def Producto_escalar (other)
+      mul = Matriz.new(matriz)
+      self.filas.times do |i|  
+         self.columnas.times do |j|
+            mul.matriz[i][j] = self.matriz[i][j] * other
+         end
+      end
+      return mul
+   end
+   
+   #Para comprobar que dos matrices son equivalentes,primero se comprueba sus dimensiones. Si tienen las mismas dimensiones se comprueba que el valor de ambas matrices sean iguales en las mismas posiciones,si esto es así se devuelve true,false en otro caso.
+   def ==(other)
+      dev=true
+      if ((self.filas.size==other.filas.size) && (self.columnas.size==other.columnas.size))
+         self.filas.times do |i| 
+            self.columnas.times do |j|
+               if (self.matriz[i][j] != other.matriz[i][j])
+	          dev=false
+	       else
+	       end
+	    end
+	 end
+      else
+         dev=false
+      end
+      return dev
+   end
+   
+   
+   #Realiza el opuesto de una matriz
+   def -@ 
+   op = Matriz.new(matriz)
+      self.filas.times do |i|   		
+         self.columnas.times do |j|
+            op.matriz[i][j] = -self.matriz[i][j]
+         end
+      end
+      return op
+   
+   end
+   
+   #Dos matrices son multiplicables si el numero de columnas de A coincide con el numero de filas de B
+   def * (other)
+      raise ArgumentError, "La longitud de las matrices no coincide." unless @columnas == other.filas
+      elemento = Array.new
+      acumulado = 0
+      self.filas.times do |i|
+         elemento_fila = Array.new
+         other.columnas.times do |j|
+            acumulado = 0
+            self.columnas.times do |k|
+               suma = @matriz[i][k] * other.matriz[k][j]
+               acumulado = suma + acumulado
+            end
+            elemento_fila << acumulado
+         end
+         elemento << elemento_fila
+      end
+      Matriz.new(elemento)
+   end
+end
+  
+#Clase Base que contiene el metodo initilize y los getters. Además contiene el to_s y el método [] 
+class Matriz
+   require "racional.rb" #definicion de la clase racional
+   
+   include Operatoria
+   attr_accessor :matriz, :filas, :columnas
+   
+   def initialize(matriz)
+      @matriz = Array.new(matriz)
+      @filas = matriz.size
+      @columnas = matriz[0].size
+      @n_elementos= (matriz.size * matriz[0].size)*0.6 
+       n_ceros=0
+      filas.times do |i|
+         columnas.times do |j|
+	    if (matriz[i][j]==0)  
+	       n_ceros=n_ceros+1
+			end
+      end
+      end
+      if n_ceros > @n_elementos
+         raise RuntimeError, 'La Matriz no es densa'
+      end
+     
+   end
+   
+   def comprobar (matriz)
+   
+    n_ceros=0
+      filas.times do |i|
+         columnas.times do |j|
+	    if (matriz[i][j]==0)  
+	       n_ceros=n_ceros+1
+			end
+      end
+      end
+      if n_ceros > @n_elementos
+         raise RuntimeError, 'La Matriz no es densa'
+      end
+   end
+   
+      #Imprime la matrices
+   def to_s
+      filas.times do |i|   
+         columnas.times do |j|
+            print "#{matriz[i][j]}  "
+         end
+				puts
+      end
+      puts 
+   end
+      
+
+   def [](i,j)
+      matriz[i][j]
+   end
+   
+end
+
+#matriz normal
+class MatrizDensa < Matriz
+
+	def +(other) 
+		suma=MatrizDensa.new(Array.new(@filas,1){Array.new(@columnas,1)})
+		filas.times do |i|
+         columnas.times do |j|
+						if (other.hash_no_ceros.key?("#{i}#{j}"))
+							suma.matriz[i][j] = other.hash_no_ceros["#{i}#{j}"] + matriz[i][j]
+						else
+							suma.matriz[i][j] =  matriz[i][j]
+						end
+					end
+       end
+       return suma		
+	end
+  
+end
+
+class MatrizDispersa < Matriz
+    #modificar el initialize,pues no necesito almacenar los '0' guardar los indices donde se encuentran dichos ceros
+    #metodo que dado una fila y columna y un porcentaje de ceros prc,construye una matriz aleatoria
+    attr_accessor :hash_no_ceros, :filas, :columnas
+    
+   def initialize(matriz)
+      @filas = matriz.size
+      @columnas = matriz[0].size
+      @hash_no_ceros={}
+       
+     #comprobamos que la matriz es dispersa o no
+     @n_elementos= (matriz.size * matriz[0].size)*0.6 
+     n_ceros=0
+      filas.times do |i|
+         columnas.times do |j|
+						if (matriz[i][j]==0)  
+							 n_ceros=n_ceros+1
+						else
+							 pos_no_cero="#{i}#{j}"
+							 @hash_no_ceros[pos_no_cero]=matriz[i][j] 
+						end
+					end
+      end
+      
+      if n_ceros < @n_elementos
+         raise RuntimeError, 'La Matriz no es dispersa'
+      else
+      end
+      
+   end
+   
+   
+   def comprobar (hash)
+	if hash.length  > ((@filas * @columnas)*0.4)
+		false
+	else
+		true
+   end
+   end
+    
+    def to_s
+       filas.times do |i|
+         columnas.times do |j|
+	    if (hash_no_ceros.key?("#{i}#{j}"))
+	       print hash_no_ceros["#{i}#{j}"]
+	       print "  "
+	    else
+	       print "0  "
+	    end
+	 end
+	 puts
+       end
+    end #def to_s
+    
+    
+    def +(other)
+      raise TypeError, "La matriz other no es dispersa" unless other.instance_of? MatrizDispersa
+      raise ArgumentError, "La longitud de las matrices no coincide." unless @filas == other.filas && @columnas == other.columnas
+      suma=MatrizDispersa.new(Array.new(@filas,0){Array.new(@columnas,0)})
+      suma.hash_no_ceros = (hash_no_ceros.merge(other.hash_no_ceros){|key,oldval,newval| oldval+newval}).clone
+      if comprobar(suma.hash_no_ceros)
+					return suma
+      else
+					m = Array.new(@filas,0){Array.new(@columnas,0)}
+					suma.hash_no_ceros.each {|key, value| m[(key[0]).to_i][(key[1]).to_i] = value }
+					sum = MatrizDensa.new(m)
+		return sum
+      end
+      
+			
+    end
+    
+     def -(other)
+      raise TypeError, "La matriz other no es dispersa" unless other.instance_of? MatrizDispersa
+      raise ArgumentError, "La longitud de las matrices no coincide." unless @filas == other.filas && @columnas == other.columnas
+      resta=MatrizDispersa.new(Array.new(@filas,0){Array.new(@columnas,0)})
+      resta.hash_no_ceros = (self.hash_no_ceros.merge(other.hash_no_ceros){|key,oldval,newval| oldval-0-newval}).clone      
+      if comprobar(resta.hash_no_ceros)
+					return resta
+      else
+					puts resta.hash_no_ceros
+					m = Array.new(@filas,0){Array.new(@columnas,0)}
+					resta.hash_no_ceros.each {|key, value| m[(key[0]).to_i][(key[1]).to_i] = value }
+					res = MatrizDensa.new(m)
+					return res
+			end
+		end
+    
+   def ==(other)
+			hash_no_ceros == other.hash_no_ceros
+   end
+    
+   
+end
+
+# m1=Matriz.new([[2,0,1],[3,0,0],[5,1,1]])
+# m2=Matriz.new([[1,0,1],[1,2,1],[1,1,0]])
+
+

data/lib/matrizHM/version.rb

@@ -1,3 +1,3 @@
 module MatrizHM
-  VERSION = "0.0.1"
+  VERSION = "1.0.1"
 end

data/lib/matrizHM.rb

@@ -1,5 +1,5 @@
 require "matrizHM/version"
 
 module MatrizHM
-  # Your code goes here...
+   require "matriz.rb"
 end

data/lib/racional.rb

@@ -0,0 +1,102 @@
+require "gcd.rb"  #definicion del mcd
+# Definicion de la clase Fraccion
+class Fraccion
+        attr_reader :numerador, :denominador # Se definen set y get para acceder a las variables de la clase.
+        include Comparable # Se incluye el modulo de nombre "comparable" utilizado para el operador <=>.
+        
+    def initialize(numerador, denominador) # Se define el constructor.
+                mcd = gcd(numerador,denominador)
+                @numerador , @denominador = numerador/mcd, denominador/mcd
+        end
+        
+    def num() # Devuelve el numerador.
+                @numerador
+        end
+        
+    def denom() # Devuelve el denominador.
+                @denominador
+        end
+        
+    def to_s
+        if @denominador == 1 #Si el denominador es 1, solo se imprimer el numerador
+                "#{@numerador}"
+        elsif @denominador == -1 #En el caso de que b=-1 y a>0 ó a=-1
+                if @numerador>0 || @numerador==-1
+                        "#{-@numerador}"
+                else #Si b=-1 y a es menor que cero, imprime el valor de a
+                        "#{@numerador}"
+                end
+        elsif (@numerador>0 && @denominador>0 && @denominador!=1) #Caso nomal, a y b son mayores que cero, imprime a/b
+                "#{@numerador}/#{@denominador}"
+        elsif (@numerador>0 && @denominador<0 && @denominador!=-1) # b es menor que cero, se le cambia el signo a todo para que se imprima: -a/b
+                "#{-@numerador}/#{-@denominador}"
+        elsif (@numerador<0 && @denominador<0 && @denominador!=-1) # a y b son menor que cero, se le cambia el signo a todo para que imprima a/b
+                "#{-@numerador}/#{-@denominador}"
+        elsif (@numerador<0 && @denominador>0 && @denominador!=1) # a es menor que cero, se imprime igual: -a/b
+                "#{@numerador}/#{@denominador}"
+        end        
+    end
+        
+    def to_f() # Imprime el resultado de la Fraccioncioncion como un float.
+                @numerador.to_f/@denominador
+        end
+        
+    def <=>(other) # Se define el operador <=> para el modulo comparable.
+            @numerador.to_f/@denominador <=> other.numerador.to_f/other.denominador
+    end
+    
+    def abs() # Se calcula el valor absoluto de una Fraccioncioncion.
+            if (@numerador > 0 && @denominador > 0)
+                    Fraccioncion.new(@numerador, @denominador).to_s
+            elsif (@numerador > 0 && @denominador < 0)
+                    Fraccion.new(@numerador, -1 * @denominador).to_s
+            elsif (@numerador < 0 && @denominador > 0)
+                    Fraccion.new(-1 * @numerador, @denominador).to_s
+            else (@numerador < 0 && @denominador < 0)
+                    Fraccion.new(-1 * @numerador,-1 * @denominador).to_s
+            end                                                  
+    end
+    
+    def reciprocal() # Calcula el reciproco de una Fraccioncion.
+            Fraccion.new(@denominador, @numerador)
+    end
+
+    def +(other) # Calcula la suma de dos Fraccionciones.
+        if other.class == Fraccion
+            Fraccion.new(@numerador*other.denominador + other.numerador*@denominador , @denominador*other.denominador)
+        elsif other.class == Fixnum
+            Fraccion.new(@numerador + other*@denominador , @denominador)
+        end
+                
+    end
+
+    def -(*other) # Calcula la resta de dos Fraccionciones.
+        if (other[0].class == Fraccion)
+            Fraccion.new(@numerador*other[0].denominador - other[0].numerador*@denominador , @denominador*other[0].denominador)
+        else
+            if (@numerador > 0 && @denominador > 0)
+                Fraccion.new(-1 * @numerador, @denominador)
+            elsif (@numerador > 0 && @denominador < 0)
+                Fraccion.new(@numerador, -1 * @denominador)
+            elsif (@numerador < 0 && @denominador > 0)
+                Fraccion.new(-1 * @numerador, @denominador)
+            else (@numerador < 0 && @denominador < 0)
+                Fraccion.new(@numerador, -1 * @denominador)
+            end                    
+        end
+    end
+
+    def *(other) # Calcula la multiplicacion de dos Fraccionciones.
+        Fraccion.new(@numerador * other.numerador, @denominador * other.denominador)
+    end
+
+    def /(other) # Calcula la division de dos Fraccionciones.
+        Fraccion.new(@numerador * other.denominador, @denominador * other.numerador)
+    end
+
+    def %(other) # Calcula el resto al dividir dos Fraccionciones (modulo)
+        result = self./(other)
+        result = (result.numerador%result.denominador).to_i
+    end
+
+end

data/matrizHM.gemspec

@@ -20,5 +20,8 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
-#   s.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "guard-bundler"
 end

data/spec/matriz_spec.rb

@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+
+require "./lib/matriz.rb"
+
+describe Matriz do
+
+  before :each do
+	cuarto = Fraccion.new(1,4)
+	quinto = Fraccion.new(1,5)
+	
+	medio = Fraccion.new(1, 2)
+	quinto2 = Fraccion.new(2, 5)
+	
+	cero = Fraccion.new(0, 1)
+	siete = Fraccion.new(7,40)
+	nueve = Fraccion.new(9,100)
+  
+	@MatrizA_frac = Matriz.new([[cuarto,cuarto],[quinto,quinto]])
+	@MatrizB_frac = Matriz.new([[cuarto,cuarto],[quinto,quinto]])
+	@Matriz_Resultado_frac = Matriz.new([[medio,medio],[quinto2,quinto2]])
+	@Matriz_Resultado_frac_rest = Matriz.new([[cero,cero],[cero,cero]])
+	@Matriz_Resultado_frac_mul = Matriz.new([[siete,nueve],[siete,nueve]])
+	
+  @MatrizA = Matriz.new([[1,1],[2,2]])
+  @Matrizop = Matriz.new([[-1,-1],[-2,-2]])
+  @MatrizB = Matriz.new([[1,1],[2,2]])
+  @MatrizC = Matriz.new([[1,1],[2,2]])
+	@Matriz_Resultado = Matriz.new([[2,2],[4,4]])
+	@MatrizAmul = Matriz.new([[2,0,1],[3,0,0],[5,1,1]])
+  @MatrizBmul = Matriz.new([[1,0,1],[1,2,1],[1,1,0]])
+  @Matriz_Resultado_mul = Matriz.new([[3,1,2],[3,0,3],[7,3,6]])
+  
+  
+  #matrices dispersas
+  @MaDis =  MatrizDispersa.new([[0,0,0],[1,2,3],[0,0,0]])
+  @MaDis2 = MatrizDispersa.new([[0,0,0],[1,2,3],[0,0,0]])
+  @MaDis3 = MatrizDispersa.new([[0,0,0],[2,4,6],[0,0,0]])
+  @MaDis4 = MatrizDispersa.new([[0,0,0],[1,2,3],[0,0,0]])
+  end
+  
+  describe "Debe existir " do
+		it "filas " do
+			(defined?(@MatrizA.filas)).should be_true
+		end
+		
+		it "columnas " do
+			(defined?(@MatrizA.columnas)).should be_true
+		end
+		
+		it "Tamano de filas " do
+			@MatrizA.filas.should eq 2
+		end
+		
+		it "Tamano de columnas " do
+			@MatrizA.columnas.should eq 2
+		end
+	end
+	
+	describe "Se puede " do
+			it "accerdera un subindice" do 
+				@MatrizA.matriz[0][0].should eq 1
+			end
+			
+			it "modificar un subindice" do 
+				@MatrizC.matriz[0][0] = 2
+				@MatrizA.matriz[0][0].should eq 1
+			end
+			
+			it "sumar dos matrices de enteros" do
+				( @MatrizA + @MatrizB ).should eq @Matriz_Resultado
+			end
+			
+			 it "restar dos matrices de enteros" do
+				(@MatrizA - @MatrizB ).matriz.should eq [[0,0],[0,0]]
+			 end
+			
+			it "multiplicar por un numero" do
+				(@MatrizA.Producto_escalar (2) ).should eq @Matriz_Resultado
+			end
+			
+			it "multiplicar 2 matrices de enteros" do
+				(@MatrizAmul *  @MatrizBmul ).should eq @Matriz_Resultado_mul
+			end
+  end
+  
+  
+  describe "de debe " do 
+			it "poder compara 2 matrices" do
+			(@MatrizA == @MatrizB).should eq true
+			end
+			
+			it "poder hacer el opuesto" do 
+			(-@MatrizA).should eq @Matrizop
+			end
+			
+			it "poder sumar dos matrices de racionales" do
+			(@MatrizA_frac + @MatrizB_frac).should eq @Matriz_Resultado_frac
+			
+		 end
+		 
+			it "poder restar dos matrices de racionales" do
+			(@MatrizA_frac - @MatrizB_frac).should eq @Matriz_Resultado_frac_rest
+		 end
+		 
+			 it "poder multiplicar dos matrices de racionales" do
+			(@MatrizA_frac * @MatrizB_frac).to_s.should eq (@Matriz_Resultado_frac_mul.to_s)
+		 end
+ end
+ 
+ describe "se poder comprobar si la " do
+		it " matriz es dispersa" do
+			MatrizDispersa.new([[0,0,0],[1,2,3],[0,0,0]])
+		end
+		it "matriz densa" do
+			MatrizDensa.new([[0,0,0],[1,2,3],[1,1,0]])
+		end
+	
+ end
+ 
+ describe "Se puede " do
+	it "sumar 2 matrices dispersas" do
+
+		(@MaDis +  @MaDis2).should eq @MaDis3
+		
+	end
+	
+	it "restar 2 matrices dispersas"do
+		(@MaDis3 -  @MaDis2).should eq @MaDis4
+	end
+	
+	it "sumar 2 matrices dispersas y den resultado una densa" do
+		@MaDis11 =  MatrizDispersa.new([[0,0,0],[1,2,3],[0,0,0]])
+		@MaDis22 = MatrizDispersa.new([[1,2,3],[0,0,0],[0,0,0]])
+		@MaDenResul = MatrizDensa.new([[1,2,3],[1,2,3],[0,0,0]])
+		
+		(@MaDis11 +  @MaDis22).should eq @MaDenResul
+		
+	end 
+ end
+ 
+ describe "Se puede sumar una matriz densa" do
+	it " con una dispersa y den resultado una densa" do
+		@MaDispersa1 =  MatrizDispersa.new([[0,0,0],[1,2,3],[0,0,0]])
+		@MaDensa1 = MatrizDensa.new([[1,2,3],[1,2,3],[0,0,0]])
+		@MaDensaResul1 = MatrizDensa.new([[1,2,3],[2,4,6],[0,0,0]])
+
+		(@MaDensa1 +  @MaDispersa1).should eq @MaDensaResul1
+		
+	end
+	
+ end
+ 
+ it "Se puede restar una matriz dipersa con una dispersa y dar una densa " do
+			@MaDis11 =  MatrizDispersa.new([[0,0,0],[1,2,3],[0,0,0]])
+			@MaDis22 = MatrizDispersa.new([[1,2,3],[0,0,0],[0,0,0]])
+			@MaDenResul = MatrizDensa.new([[-1,-2,-3],[1,2,3],[0,0,0]])
+			#(@MaDis11 -  @MaDis22).should eq @MaDenResul
+ end
+ 
+ 
+  
+ 
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: matrizHM
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-11 00:00:00.000000000 Z
+date: 2013-11-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &73342270 !ruby/object:Gem::Requirement
+  requirement: &79770600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '1.3'
   type: :development
   prerelease: false
-  version_requirements: *73342270
+  version_requirements: *79770600
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &73341940 !ruby/object:Gem::Requirement
+  requirement: &79770380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,51 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *73341940
+  version_requirements: *79770380
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &79770110 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *79770110
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: &79769850 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *79769850
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &79769620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *79769620
+- !ruby/object:Gem::Dependency
+  name: guard-bundler
+  requirement: &79769390 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *79769390
 description: Construcción de una gema ruby para la creación de matrices dispersas
   y densas,que heredan de la clase base Matriz hecha en prácticas anteriores
 email:
@@ -43,15 +87,18 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - Gemfile
+- Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- lib/gcd.rb
+- lib/matriz.rb
 - lib/matrizHM.rb
-- lib/matrizHM.rb~
 - lib/matrizHM/version.rb
-- lib/matrizHM/version.rb~
+- lib/racional.rb
 - matrizHM.gemspec
-- matrizHM.gemspec~
+- spec/matrizHM_spec.rb
+- spec/matriz_spec.rb
 homepage: https://github.com/alu0100545630/gemaHM.git
 licenses:
 - MIT
@@ -78,4 +125,6 @@ signing_key:
 specification_version: 3
 summary: Se trata de contruir otra estructura para las matrices dispersas y realizar
   la operatoria necesaria para realizar los mismos algoritmos que las matrices densas
-test_files: []
+test_files:
+- spec/matrizHM_spec.rb
+- spec/matriz_spec.rb

data/lib/matrizHM/version.rb~

@@ -1,3 +0,0 @@
-module MatrizHM
-  VERSION = "0.0.1"
-end

data/lib/matrizHM.rb~

@@ -1,5 +0,0 @@
-require "matrizHM/version"
-
-module MatrizHM
-  # Your code goes here...
-end

data/matrizHM.gemspec~

@@ -1,24 +0,0 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'matrizHM/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = "matrizHM"
-  spec.version       = MatrizHM::VERSION
-  spec.authors       = ["Hamilton Steven Cubillos & Marcos Díaz García"]
-  spec.email         = ["hamiltonetsii@gmail.com"]
-  spec.description   = %q{Construcción de una gema ruby para la creación de matrices dispersas y densas,que heredan de la clase base Matriz hecha en prácticas anteriores}
-  spec.summary       = %q{Se trata de contruir otra estructura para las matrices dispersas y realizar la operatoria necesaria para realizar los mismos algoritmos que las matrices densas}
-  spec.homepage      = "https://github.com/alu0100545630/gemaHM.git"
-  spec.license       = "MIT"
-
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
-
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-#   s.add_development_dependency "rspec"
-end