GemaMatriz 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: be96d0f8fe867db9ee84ce472b3211f1adbc5c50
+  data.tar.gz: 711a49deebe6ff6fdd11f41c32220f0a566fef54
+SHA512:
+  metadata.gz: 6f8f1f93777ccfa708711252bcf636f919f9a2e509de653fc109846e93925b1f316740b48bf4742fc5592db0f7fd7060aa6c3b6d1c4234b940b4b6ef51041840
+  data.tar.gz: 66c441c6fc929a5c10a5d3e04bb0a53ed67410cb5dd418ac600eeab485e75333cd6cce918ba89db3492e4288afd6c928deb6bffa21d1ce5550717a8f0616994e

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*~

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,6 @@
+rvm:
+  - 1.9.3
+  - 1.9.2
+  - jruby
+
+script: "bundle exec rake"

data/GemaMatriz.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'GemaMatriz/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "GemaMatriz"
+  spec.version       = GemaMatriz::VERSION
+  spec.authors       = ["Rushil Lakhani Lakhani & Waldo Nazco Torres"]
+  spec.email         = ["alu0100537031@ull.edu.es"]
+  spec.description   = %q{Construcción de una gema ruby para la creación de matrices dispersas y densas}
+  spec.summary       = %q{Practica 9 }
+  spec.homepage      = "https://github.com/alu0100537031/prct09"
+  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"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "guard-bundler"
+end

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in GemaMatriz.gemspec
+gemspec
+

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/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Rushil Lakhani Lakhani
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,72 @@
+Práctica de Laboratorio #9. Creacion De Una Gema
+================
+
+## Componentes Del Grupo:
+
+- RUSHIL LAKHANI LAKHANI
+- WALDO NAZCO TORRES
+
+
+## GemaMatriz
+
+Construcción de una gema ruby para la creación de matrices dispersas y densas,que heredan de la clase base Matriz 
+
+##Descripción de la práctica.
+
+La práctica consiste en crear una clase abstracta llamada Matriz, donde pondremos los distintos métodos abstractos de la clase  
+Para ello partimos de la clase base Matriz cuya funcion va a ser que sea heredada por las clases hijas ,y creamos dos clases 
+hijas que van a ser: clase Matriz Densa  ya implementada de la práctica anterior con las operaciones basicas 
+correspondientes (+-*/)  y clase Matriz Dispersa cuya madre va a ser la clase base Matriz y donde se van a redifinir los metodos de 
+la clase madre.
+
+class  Matriz
+
+  metodos abstractos
+  
+end
+
+class MatrizDensa < Matriz
+
+  metodos
+
+end
+
+class MatrizDispersa < Matriz
+
+metodos
+
+end
+
+En dichas clases hijas se redefiniran los metodos para trabajar con el tipo de matrices indicado.
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'GemaMatriz'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install GemaMatriz
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+---
+
+Universidad de La Laguna  
+Escuela Técnica Superior de Ingeniería Informática  
+Lenguajes y Paradigmas de la Programación 2013-14
+

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+task :default => :spec

data/lib/GemaMatriz/version.rb

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

data/lib/GemaMatriz.rb

@@ -0,0 +1,5 @@
+require "GemaMatriz/version"
+
+module GemaMatriz
+  require "matriz.rb"
+end

data/lib/gcd.rb

@@ -0,0 +1,9 @@
+def gcd(u, v) # Calcula el mcd entre dos numeros
+  u, v = u.abs, v.abs # Convierte los numeros a valor aboluto
+  while v != 0
+    u, v = v, u % v
+  end
+  u #r eturn(u) , el ultimo valor que se indica es el que devuelve
+end
+
+

data/lib/matriz.rb

@@ -0,0 +1,293 @@
+# Clase Base Matriz
+class Matriz
+  require "./lib/racional.rb"
+
+  attr_reader :nfil, :ncol, :mat # metodos de acceso (getter)
+  
+  # metodo que inicializa la matriz 
+  
+  def initialize(nfil,ncol)  
+    @nfil = nfil # inicializo numero de filas
+    @ncol = ncol # inicializo numero de columnas 
+  end
+end
+
+
+
+class MatrizDensa < Matriz
+  
+  attr_reader :mat # metodos de acceso (getter)
+  
+  def initialize(nfil,ncol,mat)
+     super(nfil, ncol)
+     @mat = Array.new(mat) #inicializo la matriz pasando como parametro un objeto de tipo matriz 
+  end
+
+#Funcion que devuelve una posicion i dentro de la matriz  
+  
+  def [](i)
+    return mat[i]
+  end
+
+   
+#Funcion que asigna un valor k a una posicion i,j dentro de la matriz
+   
+   def []=(i, j, k)
+      return mat[i][j] = k
+   end
+  
+
+  def to_s
+     cad = " "
+    for i in 0...nfil
+      cad << " [ "
+      for j in 0...ncol
+	cad <<  "#{mat[i][j]} "
+      end
+      cad << "]"
+      cad << "\n "
+    end
+    return cad
+  end 
+
+  # metodo que suma dos matrices (Sobrecarga del operador +)
+  
+   def +(other)
+      raise ArgumentError, "Las matrices no son cuadradas." unless @nfil == other.nfil && @ncol == other.ncol
+      m = Array.new(@nfil){Array.new(@ncol){0}}
+      for i in 0...nfil 
+         for j in 0...ncol
+             m[i][j] = self.mat[i][j]+ other.mat[i][j]
+         end
+      end
+      return MatrizDensa.new(other.nfil,other.ncol,m) 
+   end
+   
+    # metodo que resta dos matrices (Sobrecarga del operador -)
+  
+   def -(other)
+      raise ArgumentError, "Las matrices no son cuadradas." unless @nfil == other.nfil && @ncol == other.ncol
+      m = Array.new(@nfil){Array.new(@ncol){0}}
+      for i in 0...nfil 
+         for j in 0...ncol
+	     m[i][j] = mat[i][j]- other.mat[i][j]
+         end
+      end
+      return MatrizDensa.new(other.nfil,other.ncol,m) 
+   end
+
+   # metodo que multiplica dos matrices (Sobrecarga del operador *)
+   
+   
+  def *(other)
+    m = Array.new(@nfil){Array.new(@ncol){0}}
+    for i in 0...nfil do
+      for j in 0...other.ncol do  
+        for k in 0...ncol do
+          m[i][j] = m[i][j] + self.mat[i][k] * other.mat[k][j]
+         end
+      end
+    end
+    return MatrizDensa.new(self.nfil,other.ncol,m)  
+  end
+  
+  def max
+    max=0	
+      for i in 0...nfil do   
+         for j in 0...ncol do
+            if mat[i][j] > max
+               max=mat[i][j]
+            end
+          end
+      end			  	
+    return max  
+  end
+  
+  def min
+      min=9999;
+      for i in 0...nfil do   
+         for j in 0...ncol do
+            if mat[i][j] < min
+               min=mat[i][j]
+            end
+          end
+      end			  	 
+      return min  
+  end
+end	  
+   
+      
+
+
+class MatrizDispersa < Matriz
+  
+  attr_reader:hash , :mat
+  
+  def initialize (nfil, ncol, mat)
+    super(nfil, ncol)
+    @mat = Array.new(mat)	
+    nceros = 0 # numero de elementos nulos de la matriz (0)
+    nelementos= (nfil * ncol)*0.6 # elementos de la matriz aplicado el 60 % 
+    psincero = 0 # posiciones de los elementos de la matriz cuyo valor no es nulo (0)
+    @hash = Hash.new(0)
+    for i in 0...nfil do
+       for j in 0...ncol do
+           if (mat[i][j]==0)  
+               nceros=nceros+1
+            else
+               psincero="[#{i}][#{j}]"
+	       if (mat[i][j].is_a?Fraccion)
+		 a = mat[i][j].num
+		 b = mat[i][j].denom
+	        @hash[psincero] = Rational(a,b)
+		#cad = " " 
+		#cad << "#{a}"
+		#cad << "/"
+		#cad << "#{b}" 
+		#@hash[psincero] = cad		
+	       else 
+		@hash[psincero] = mat[i][j]
+	       end
+            end
+       end
+    end
+      if nceros >= nelementos # compruebo que la matriz sea dispersa 
+	 #puts "La matriz es dispersa" 
+      else
+	 raise ArgumentError, 'La Matriz no es dispersa'
+      end
+ end
+ 
+  def to_s
+    if (hash.values != nil)
+      cad = ""
+      cad << "#{hash}"
+      return cad 
+    else
+      return 0
+    end 
+    #return hash
+  end 
+
+  def +(other)
+      
+      case other
+          when MatrizDensa
+              other.+(self)
+          when MatrizDispersa
+	      raise ArgumentError, "Las matrices no son cuadradas." unless @nfil == other.nfil && @ncol == other.ncol 
+	      suma = MatrizDispersa.new(nfil,ncol,0)
+	      suma = hash.merge(other.hash){|key,oldval,newval| oldval+newval }
+	      return suma # devuelve un objeto de tipo Matriz Dispersa
+	   else
+	      raise TypeError, "La matriz no es dispersa ni densa" unless other.instance_of? MatrizDispersa
+       end
+      
+      
+  end
+  
+   def -(other)
+       case other
+          when MatrizDensa
+              other.-(self)
+          when MatrizDispersa
+	      raise ArgumentError, "Las matrices no son cuadradas." unless @nfil == other.nfil && @ncol == other.ncol
+	      resta = MatrizDispersa.new(nfil,ncol,0)
+	      resta = hash.merge(other.hash){|key,oldval,newval| oldval-newval}
+	      return resta # devuelve un objeto de tipo Matriz Dispersa
+	   else
+	       raise TypeError, "La matriz no es dispersa ni densa " unless other.instance_of? MatrizDispersa
+       end
+      
+  end
+  
+  def max
+    max = 0
+    hash.each do |clave,valor|
+	  if (valor > max)
+	    max=valor 
+          end
+    end
+   return max 
+   end
+  
+  def min
+    min = 9999	
+    hash.each do |clave,valor|
+	  if (valor < min)
+	    min=valor 
+          end
+    end
+   return min
+  end
+end
+
+frac1 = Fraccion.new(5,3)
+frac2 = Fraccion.new(4,9)
+m1 = MatrizDensa.new(3,3,[[1,2,0],[3,4,0],[0,2,3]])
+m2 = MatrizDensa.new(3,3,[[7,10,5],[15,22,3],[2,3,4]])
+m3 = MatrizDensa.new(3,3,[[frac1,frac2,frac1],[frac1,frac2,frac1],[frac2,frac2,frac1]])
+m4 = MatrizDispersa.new(3,3,[[0,0,10],[5,0,0],[0,0,40]])
+m5 = MatrizDispersa.new(3,3,[[0,0,4],[3,0,0],[0,0,2]])
+m6 = MatrizDispersa.new(3,3,[[0,0,frac1],[frac2,0,0],[0,0,frac1]])
+#puts 4-frac2 # Tiene que estar implementado el coerce para que funcione
+#puts frac2-4
+#puts 1+frac2
+#puts m1.to_s
+#puts m3.to_s
+#puts m4.to_s
+#puts m5.to_s
+#puts m6.to_s
+#print 
+=begin
+puts " Matrices Densas "
+puts "     M1   "
+puts m1.to_s
+puts "     M2   "
+puts m2.to_s
+puts "     M3   "
+puts m3.to_s
+puts " (M1+M3)"
+puts m1+m3
+puts " (M1-M3)"
+puts m1-m3
+puts " (M1*M3)"
+puts m1*m3
+puts " Matrices Dispersas "
+puts "     M4   "
+m4.to_s
+puts "     M5   "
+m5.to_s
+puts
+puts " (M4+M5)"
+puts m4+m5 # Matriz Dispersa - Matriz Dispersa = Matriz Dispersa
+puts
+puts " (M4-M5)"
+puts m4-m5 # Matriz Dispersa + Matriz Dispersa = Matriz Dispersa
+puts " El valor maximo de la matriz M2(densa) es  #{m2.max}"
+puts " El valor minimo de la matriz M2(densa) es  #{m2.min}"
+puts " El valor maximo de la matriz M4(dispersa) es  #{m4.max}"
+puts " El valor minimo de la matriz M4(dispersa) es  #{m4.min}"
+=end
+
+
+
+
+  
+
+
+  
+ 
+
+  
+
+    
+  
+
+  
+  
+ 
+  
+
+  
+ 

data/lib/racional.rb

@@ -0,0 +1,116 @@
+require "./lib/gcd.rb"
+class Fraccion
+  
+   include Comparable # Se incluye el modulo de nombre "comparable" utilizado para el operador <=>.
+  
+  attr_reader :num, :denom # metodos de acceso (getter)
+  
+  def initialize(num,denom)
+   
+    # Se encarga de comprobar que los datos sean numericos, si no lo son lanza una excepcion y sale del programa  
+    
+    raise ArgumentError, 'El argumento no es numerico' unless num.is_a? Numeric 
+    raise ArgumentError, 'El argumento no es numerico' unless denom.is_a? Numeric 
+    if (denom == 0)
+	raise ArgumentError, 'El argumento no puede valer 0' unless (denom !=0)
+    end 
+    aux = gcd(num,denom) 
+    @num = num/aux # numerador en su forma simplificada
+    @denom= denom/aux # denominador en su forma simplificada 
+  end
+  
+
+  
+  # metodo que muestra la fraccion con formato de salida: a/b
+  
+   def to_s 
+	"#{@num}/#{@denom}"
+    end
+
+
+  # metodo que calcula la suma de dos fracciones
+  
+  def +(other)
+    if other.is_a? Fraccion     
+      if (@denom == other.denom)   #si los denominadores son iguales
+         Fraccion.new(@num + other.num, @denom)
+      else  #si los denominadores son distintos
+        aux3 = ((@denom/gcd(@denom,other.denom)) * other.denom) # Calculo del mcm usando la propiedad (a*b/mcd(a,b))
+	aux = ((aux3/@denom) * @num) # calculo del numerador de la primera fraccion
+	aux2 = ((aux3/other.denom) * other.num) # calculo del denominador de la segunda fraccion        
+	Fraccion.new((aux+aux2),aux3)
+      end
+    else
+      tmp = Fraccion.new(other,1)
+      if (@denom == tmp.denom)   #si los denominadores son iguales
+         Fraccion.new(@num + other.num, @denom)
+      else  #si los denominadores son distintos
+        aux3 = ((@denom/gcd(@denom,tmp.denom)) * tmp.denom) # Calculo del mcm usando la propiedad (a*b/mcd(a,b))
+	aux = ((aux3/@denom) * @num) # calculo del numerador de la primera fraccion
+	aux2 = ((aux3/tmp.denom) * tmp.num) # calculo del denominador de la segunda fraccion        
+	Fraccion.new((aux+aux2),aux3)
+      end
+    end
+  end  
+   
+   # metodo que calcula la resta de dos fracciones
+   
+    def -(other)
+    if other.is_a? Fraccion     
+      if (@denom == other.denom)   #si los denominadores son iguales
+         Fraccion.new(@num - other.num, @denom)
+      else  # si los denominadores son distintos
+        aux3 = ((@denom/gcd(@denom,other.denom)) * other.denom) # Calculo del mcm usando la propiedad (a*b/mcd(a,b))
+	aux = ((aux3/@denom) * @num) # calculo del numerador de la primera fraccion
+	aux2 = ((aux3/other.denom) * other.num) # calculo del denominador de la segunda fraccion        
+	Fraccion.new((aux-aux2),aux3)
+      end
+    else
+      tmp = Fraccion.new(other,1)
+      if (@denom == tmp.denom)   #si los denominadores son iguales
+         Fraccion.new(@num + other.num, @denom)
+      else  #si los denominadores son distintos
+        aux3 = ((@denom/gcd(@denom,tmp.denom)) * tmp.denom) # Calculo del mcm usando la propiedad (a*b/mcd(a,b))
+	aux = ((aux3/@denom) * @num) # calculo del numerador de la primera fraccion
+	aux2 = ((aux3/tmp.denom) * tmp.num) # calculo del denominador de la segunda fraccion        
+	Fraccion.new((aux-aux2),aux3)
+      end
+    end  
+   end
+   
+   # metodo que calcula el producto de dos fracciones
+   
+   def *(other)
+	Fraccion.new(@num*other.num,@denom*other.denom)
+   end
+   
+    # metodo que calcula la division de dos fracciones
+   
+   def /(other)
+	Fraccion.new(@num*other.denom,@denom*other.num)
+   end
+   
+   # método que contempla el uso del modulo comparable <, >, <= y >=
+  
+  def <=>(other)
+     return nil unless other.instance_of? Fraccion
+     # self.to_f <=> other.to_f
+     @num.to_f/@denom <=> other.num.to_f/other.denom
+  end
+ 
+  def coerce(other)
+       [Fraccion.new(other,1),self]
+  end
+  
+end
+
+=begin  
+   def coerce(other)
+       return [self,other]
+  end
+=end
+
+
+   
+
+

data/spec/matriz_spec.rb

@@ -0,0 +1,160 @@
+require "./lib/matriz.rb"
+#require "matriz.rb"	
+
+        describe Matriz do
+                before :each do
+                        @m1 = Matriz.new(3,3)
+			 @m1densa =  MatrizDensa.new(3,3,[[1,2,0],[3,4,0],[0,2,3]])
+                        @m2densa =  MatrizDensa.new(3,3,[[7,10,5],[15,22,3],[2,3,4]])
+			 frac1 = Fraccion.new(1,3)
+			 frac2 = Fraccion.new(1,4)
+                        @m3densa = MatrizDensa.new(3,3,[[frac1,frac2,frac1],[frac1,frac2,frac1],[frac2,frac2,frac1]])
+			 @m4dispersa = MatrizDispersa.new(3,3,[[0,0,3],[5,0,0],[0,0,2]])
+			 @m5dispersa = MatrizDispersa.new(3,3,[[0,0,4],[3,0,0],[0,0,2]])
+			 @m6dispersa = MatrizDispersa.new(3,3,[[0,0,frac1],[frac2,0,0],[0,0,frac1]])
+                end
+               
+		describe "Se comprueba el numero de:" do
+                        it "filas de la matriz" do
+                                @m1.nfil.should eq(3)  
+                        end
+                        it "columnas de la matriz" do
+                                @m1.ncol.should eq(3)  
+                        end
+                end
+                                    
+       
+		
+		describe "se debe comprobar si la " do
+                  it " matriz es densa" do
+                        (@m1densa.instance_of? MatrizDensa).should be_true 
+                  end
+		   it "matriz dispersa" do
+                        (@m6dispersa.instance_of? MatrizDispersa).should be_true
+		   end
+		end   
+        
+  
+		
+                describe "se debe comprobar si la matriz ;" do
+                        it " densa accede al subindice [0,0]" do
+                                @m1densa.mat[0][0].should eq(1)
+                        end
+                        it "densa accede al subindice [0,1]" do
+                                @m1densa.mat[0][1].should eq(2)
+                        end
+                        it "dispersa accede al subindice[1,0]" do
+                                @m4dispersa.mat[1][0].should eq(5)
+                        end
+                        it "dispersa accede al subindice[2,2]" do
+                                @m4dispersa.mat[2][2].should eq(2)
+                        end
+                end
+		
+		describe "se debe mostrar la " do
+		  
+		   it " matriz densa con enteros" do
+                        @m2densa.to_s.should eq("  [ 7 10 5 ]\n  [ 15 22 3 ]\n  [ 2 3 4 ]\n ")
+                  end
+                  it " matriz densa con racionales" do
+                        @m3densa.to_s.should eq("  [ 1/3 1/4 1/3 ]\n  [ 1/3 1/4 1/3 ]\n  [ 1/4 1/4 1/3 ]\n ")
+                  end
+		   it "matriz dispersa con enteros" do
+                        @m4dispersa.to_s.should eq ("{\"[0][2]\"=>3, \"[1][0]\"=>5, \"[2][2]\"=>2}")
+		   end
+		   
+		   it "matriz dispersa con racionales" do
+                        @m6dispersa.to_s.should eq ("{\"[0][2]\"=>(1/3), \"[1][0]\"=>(1/4), \"[2][2]\"=>(1/3)}")
+		   end
+		   
+		end  
+		
+		describe "se debe " do
+		  
+		   it " sumar dos matrices densas con enteros" do
+		        sum = @m1densa+@m2densa
+                        sum.to_s.should eq("  [ 8 12 5 ]\n  [ 18 26 3 ]\n  [ 2 5 7 ]\n ")
+                  end
+                  it " restar una matriz densa de enteros con otra matriz densa de racionales" do
+		        res = @m1densa-@m3densa
+                        res.to_s.should eq("  [ 2/3 7/4 -1/3 ]\n  [ 8/3 15/4 -1/3 ]\n  [ -1/4 7/4 8/3 ]\n ")
+                  end
+		  
+		  it " multiplicar una matriz densa con otra matriz densa" do
+		         mul = @m1densa*@m2densa
+                        mul.to_s.should eq("  [ 37 54 11 ]\n  [ 81 118 27 ]\n  [ 36 53 18 ]\n ")
+                  end
+		  
+		   it "calcular el maximo de una matriz Densa " do
+			max = @m2densa.max
+			max.should eq 22
+		  end
+   
+		  it "calcular el minimo de una matriz Densa" do
+			min = @m2densa.min
+			min.should eq 2
+		  end
+		  
+		 
+	      end
+		  
+
+		 
+		
+		describe "se debe " do
+		  
+		   it " sumar dos matrices dispersas con enteros " do
+		        sum = @m4dispersa+@m5dispersa
+                        sum.to_s.should eq("{\"[0][2]\"=>7, \"[1][0]\"=>8, \"[2][2]\"=>4}")
+
+                  end
+		  
+                  it " restar dos matrices dispersas con enteros " do
+		        res = @m4dispersa-@m5dispersa
+                        res.to_s.should eq("{\"[0][2]\"=>-1, \"[1][0]\"=>2, \"[2][2]\"=>0}")
+                  end
+		  
+		   it " sumar una matriz dispersa de enteros con otra matriz dispersa de racionales" do
+		        sum = @m4dispersa+@m6dispersa
+                        sum.to_s.should eq("{\"[0][2]\"=>(10/3), \"[1][0]\"=>(21/4), \"[2][2]\"=>(7/3)}")
+                  end
+		  
+		    it " restar una matriz dispersa de enteros con otra matriz dispersa de racionales" do
+		        res = @m4dispersa-@m6dispersa
+                        res.to_s.should eq("{\"[0][2]\"=>(8/3), \"[1][0]\"=>(19/4), \"[2][2]\"=>(5/3)}")
+			
+                  end
+		  
+		   it "calcular el maximo de una matriz Dispersa " do
+		      max = @m4dispersa.max
+		      max.should eq 5
+		  end
+   
+		  it "calcular el minimo de una matriz Dispersa" do
+		      min = @m4dispersa.min
+		      min.should eq 2
+		  end
+		  
+		
+		  
+		end  
+		
+		describe "se debe  " do
+		  
+		   it " sumar una matriz densa con una dispersa " do
+		        sum = @m1densa+@m5dispersa
+                        sum.to_s.should eq("  [ 1 2 4 ]\n  [ 6 4 0 ]\n  [ 0 2 5 ]\n ")
+
+
+                  end
+                  it " restar una matriz dispersa con una densa" do
+		        res = @m5dispersa-@m1densa
+                        res.to_s.should eq("  [ 1 2 -4 ]\n  [ 0 4 0 ]\n  [ 0 2 1 ]\n ")
+                  end
+		  
+		end 
+				
+       end
+
+
+             

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'GemaMatriz'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: GemaMatriz
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Rushil Lakhani Lakhani & Waldo Nazco Torres
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Construcción de una gema ruby para la creación de matrices dispersas
+  y densas
+email:
+- alu0100537031@ull.edu.es
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- GemaMatriz.gemspec
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/GemaMatriz.rb
+- lib/GemaMatriz/version.rb
+- lib/gcd.rb
+- lib/matriz.rb
+- lib/racional.rb
+- spec/matriz_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/alu0100537031/prct09
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Practica 9
+test_files:
+- spec/matriz_spec.rb
+- spec/spec_helper.rb