matrices_p9 0.0.1

data/.gitignore

@@ -0,0 +1,27 @@
+
+
+
+
+
+
+
+*.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/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - jruby-18mode # JRuby in 1.8 mode
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx-18mode
+  - rbx-19mode
+  - 1.8.7

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in matrices_p9.gemspec
+gemspec
+gem 'guard'
+gem 'guard-rspec'
+gem 'guard-bundler'
+gem 'rb-fsevent', '~> 0.9.1'

data/Guardfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Luis Orta
+
+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,12 @@
+# MatricesP9
+
+La clase matriz se implementará mediante una clase abstracta, que contendrá los métodos básicos como el numero de filas y columnas de la matriz. Esta será la clase padre.
+
+De esta clase derivarán las clases Matriz_Densa y Matriz_Dispersa.
+
+La clase Matriz_Densa será la desarrollada en la práctica anterior.
+
+La clase Matriz_Dispersa será una nueva clase desarrollada para aquellas matrices con más de un 60 % de ceros y se tratarán de manera distinta que las densas. Su estructura no será una matriz de elementos (dos arrays anidados con todas las posiciones ocupadas) sino la mezcla de un array de posiciones y un array de elementos, lo que reducirá la cantidad de memoria utilizada para almacenar los elementos distintos de cero. Tendrá su propio metodo de suma, resta y multiplicación, además de ser comparable (Modulo comparable).
+
+
+

data/README.md~

@@ -0,0 +1,29 @@
+# MatricesP9
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'matrices_p9'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install matrices_p9
+
+## 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

data/Rakefile

@@ -0,0 +1,17 @@
+$:.unshift File.dirname(__FILE__) + 'lib'
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+task :default => :spec
+
+desc "Run spec"
+task :spec do
+  sh "cd spec \n rspec -I. matrices_spec.rb"
+end
+
+desc "Run UnitTest"
+task :test do
+  sh "ruby -Ilib -Itest test/tc_MatrizDispersa.rb \n ruby -Ilib -Itest test/tc_MatrizDensa.rb" 
+end
+

data/lib/fraccion.rb

@@ -0,0 +1,227 @@
+
+#require "./gcd.rb"
+#Programa que trabaja con fracciones
+#Adriana Rolo Inchausti, Luis Antonio Orta Mendes 
+
+class Fraccion
+attr_reader :denominador, :numerador
+
+	def initialize(num, denomin)
+		#atributo
+		mcd=gcd(num,denomin)
+
+			@numerador=num/mcd
+			@denominador=denomin/mcd
+	end
+	
+	#Maximo comun divisor, funcion usada para simplificar las matrices.
+	def gcd(u, v)
+  		u, v = u.abs, v.abs
+  		while v != 0
+    			u, v = v, u % v
+  		end
+  		u
+	end
+	
+
+# Metodos getter de Numerador y denominador
+
+	def num
+		return @numerador
+	end
+
+
+	def denom
+		return @denominador
+	end 
+
+#Metodo que devuelve la fraccion en forma de string de la manera a/b
+	def to_s
+                "#{@numerador}/#{@denominador}"
+        end
+        
+#Metodo que devuelve el numero decimal que representa la matriz 
+	def to_f 
+		a=@numerador.to_f
+		b=@denominador.to_f
+		a/b
+	end
+#Sobrecarga del operador de comparacion, devuelve true si son iguale  y false en caso contrario
+	def == (otro)
+		if (@numerador==otro.numerador) && (@denominador == otro.denominador)
+			return true
+		else 
+			return false
+		end
+	end 
+
+#Metodo para calcular el valor absoluto de la fraccion (numerador y denominador positivo) 
+	def abs
+		if @numerador < 0
+			@numerador = @numerador*-1
+		end
+		if @denominador < 0
+			@denominador = @denominador*-1
+		end
+		return self
+	end
+
+#Metodo que devuelve la matriz invertida de la forma que si al comienzo era a/b, devolveria b/a
+	def reciprocal
+		aux= @numerador 
+		@numerador =  @denominador
+		@denominador = aux
+	end
+
+#Metodo que devuelve la fraccion con el signo contrario al que tenia incialmente
+	def opuesto
+		@numerador = -1*@numerador
+		return self
+	end
+
+#Calcula el Minimo comun multiplo, se usa para realizar la suma y la resta 
+	def mcm(a,b)
+		(a*b)/gcd(a,b)
+    	end
+#Sobrecarga del operador de suma, recibe como parametros dos fracciones y devuelve una fraccion con el resultado de la suma
+	def +(other)
+		if(other.instance_of?Fixnum)
+			temp=other
+			other=Fraccion.new(temp,1)
+		end
+		if (@denominador ==  other.denominador)
+			nume=@numerador + other.numerador
+			deno=@denominador
+			mcd=gcd(nume,deno)
+		else
+			aux= @denominador * other.denominador
+			nume = ((aux / @denominador) * @numerador) + ((aux / other.denominador) * other.numerador)
+			deno = @denominador*other.denominador
+			mcd=gcd(nume,deno)
+		end
+		
+		temp = Fraccion.new(nume/mcd, deno/mcd)
+	end
+
+
+#Sobrecarga del operador de resta, recibe como parametros dos francciones y devuelve una fraccion con el resultado de la resta
+	def -(other)
+		if(other.instance_of?Fixnum)
+			temp=other
+			other=Fraccion.new(temp,1)
+		end
+		if (@denominador ==  other.denominador )
+			nume=@numerador - other.numerador
+			deno=@denominador
+			mcd=gcd(nume,deno)
+		
+		else
+			aux= @denominador * other.denominador
+			nume = ((aux / @denominador) * @numerador) - ((aux / other.denominador ) * other.numerador)
+			deno=@denominador*other.denominador
+			mcd=gcd(nume,deno)
+		
+		end
+		
+		
+		temp = Fraccion.new(nume/mcd, deno/mcd)
+	end
+
+#Sobrecarga del operador de multiplicación, recibe como parametros dos francciones y devuelve una fraccion con el resultado de la multiplicación
+	def * (other) 
+		nume = @numerador * other.numerador
+		deno = @denominador * other.denominador
+		mcd=gcd(nume,deno)
+		temp = Fraccion.new(nume / mcd ,deno / mcd )
+	
+	end	
+
+#Sobrecarga del operador de division, recibe como parametros dos francciones y devuelve una fraccion con el resultado de la division
+	def / (other)
+	
+		nume = @numerador *other.denominador
+		deno = @denominador * other.numerador
+		mcd= gcd(nume,deno)
+		temp = Fraccion.new(nume/mcd, deno/mcd )
+	
+	end
+
+#Sobrecarga del operador de modulo, recibe como parametros dos francciones y devuelve el resto de la division de las mismas 
+	def % (other)
+		aux=Fraccion.new(1,1)
+        	aux=self/other
+		aux.numerador%aux.denominador
+	end
+
+
+#Sobrecarga de operadores de comparación devuelve true en caso de que sea cierto y falso en caso contrario 
+#Mayor que 
+	def > (otro)
+		if (@numerador/@denominador > otro.numerador/otro.denominador)
+			return true
+		else
+			return false
+		end
+		
+	end
+	
+#menor que 	
+	def < (otro)
+		if (@numerador/@denominador < otro.numerador/otro.denominador)
+			return true
+		else
+			return false
+		end
+		
+	end
+#mayor igual que 
+	def >= (otro)
+		if (@numerador/@denominador >= otro.numerador/otro.denominador)
+			return true
+		else
+			return false
+		end
+		
+	end
+#menos igual que 
+	def <= (otro)
+		if (@numerador/@denominador <= otro.numerador/otro.denominador)
+			return true
+		else
+			return false
+		end
+		
+	end
+#Coerce
+	def coerce(other)
+		[self, other]
+	end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

data/lib/matrices_p9/version.rb

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

data/lib/matrices_p9.rb

@@ -0,0 +1,359 @@
+require "fraccion.rb"
+
+class Matriz
+attr_accessor :fil, :col
+include Comparable
+
+	def initialize(f, c)
+		#atributo
+	    	@fil=f.to_i; #Numero de filas
+	    	@col=c.to_i; #Numero de columnas
+	end
+
+
+	#Sobrecarga del operador de suma, recibe como parametros dos matrices y devuelve una matriz con el resultado de la suma de 		forma A+B= (Aij+Bij)
+	def +(other)	             
+		if(self.fil == other.fil and self.col == other.col)
+			# SELF Matrices densas
+			if self.instance_of?MatrizDensa
+				temp = MatrizDensa.new(self.fil, self.col, nil)
+				if other.instance_of?MatrizDensa
+					
+					for i in (0...@fil.to_i)
+						for j in (0...@col.to_i)
+							temp.mat[i][j] = (self.mat[i][j]) + (other.mat[i][j])
+						end
+					end
+				end
+
+				if other.instance_of?MatrizDispersa
+					for i in (0...@fil.to_i)
+						for j in (0...@col.to_i)
+							encontrado = 0
+							for k in (0...other.posx.size)
+								if (i==other.posx[k] and j==other.posy[k] and encontrado==0)
+									temp.mat[i][j] = (self.mat[i][j]) + (other.valor[k])
+									encontrado = 1	
+								end
+							end
+							if (encontrado == 0)
+								temp.mat[i][j] = self.mat[i][j]
+							end
+						end
+					end
+				end
+			end
+
+			# SELF Matriz Dispersa
+			if self.instance_of?MatrizDispersa
+				if other.instance_of?MatrizDensa
+					temp = MatrizDensa.new(self.fil, self.col, nil)
+					for i in (0...@fil.to_i)
+						for j in (0...@col.to_i)
+							encontrado = 0
+							for k in (0...self.posx.size.to_i)
+								if (i==self.posx[k] and j==self.posy[k] and encontrado==0)
+									temp.mat[i][j] = (other.mat[i][j]) + (self.valor[k])
+									encontrado = 1	
+								end
+							end
+							if (encontrado == 0)
+								temp.mat[i][j] = other.mat[i][j]
+							end
+						end
+					end
+				end
+		
+
+				if other.instance_of?MatrizDispersa
+					temp = MatrizDispersa.new(self.fil,self.col,[],[],[])
+					temp.valor = self.valor
+					temp.posx = self.posx
+					temp.posy = self.posy
+
+					for j in (0...other.posx.size.to_i)
+						encontrado = false
+						for k in (0...self.posx.size.to_i)
+							if(other.posx[j] == temp.posx[k] and other.posy[j] == temp.posy[k])
+								temp.valor[k] = temp.valor[k] + other.valor[j]
+								encontrado = true
+							end
+							
+						end
+						if (encontrado == false)
+							temp.posx << other.posx[j]
+							temp.posy << other.posy[j]
+							temp.valor << other.valor[j]
+						end
+					end
+				end
+			end
+		
+			return temp
+		else 
+			return nil
+		end
+	end
+
+	def -(other)	             
+		if(self.fil == other.fil and self.col == other.col)
+			# SELF Matrices densas
+			if self.instance_of?MatrizDensa
+				temp = MatrizDensa.new(self.fil, self.col, nil)
+				if other.instance_of?MatrizDensa		
+					for i in (0...@fil.to_i)
+						for j in (0...@col.to_i)
+							temp.mat[i][j] = (self.mat[i][j]) - (other.mat[i][j])
+						end
+					end
+				end
+
+				if other.instance_of?MatrizDispersa
+					for i in (0...@fil.to_i)
+						for j in (0...@col.to_i)
+							encontrado = 0
+							for k in (0...other.posx.size)
+								if (i==other.posx[k] and j==other.posy[k] and encontrado==0)
+									temp.mat[i][j] = (self.mat[i][j]) - (other.valor[k])
+									encontrado = 1	
+								end
+							end
+							if (encontrado == 0)
+								temp.mat[i][j] = self.mat[i][j]
+							end
+						end
+					end
+				end
+			end
+
+			# SELF Matriz Dispersa
+			if self.instance_of?MatrizDispersa
+				if other.instance_of?MatrizDensa
+					temp = MatrizDensa.new(self.fil, self.col, nil)
+					for i in (0...@fil.to_i)
+						for j in (0...@col.to_i)
+							encontrado = 0
+							for k in (0...self.posx.size.to_i)
+								if (i==self.posx[k] and j==self.posy[k] and encontrado==0)
+									temp.mat[i][j] = (other.mat[i][j]) - (self.valor[k])
+									encontrado = 1	
+								end
+							end
+							if (encontrado == 0)
+								temp.mat[i][j] = other.mat[i][j]
+							end
+						end
+					end
+				end
+		
+
+				if other.instance_of?MatrizDispersa
+					temp = MatrizDispersa.new(self.fil,self.col,[],[],[])
+					temp.valor = self.valor
+					temp.posx = self.posx
+					temp.posy = self.posy
+
+					for j in (0...other.posx.size.to_i)
+						encontrado = false
+						for k in (0...self.posx.size.to_i)
+							if(other.posx[j] == temp.posx[k] and other.posy[j] == temp.posy[k])
+								temp.valor[k] = temp.valor[k] - other.valor[j]
+								encontrado = true
+							end
+							
+						end
+						if (encontrado == false)
+							temp.posx << other.posx[j]
+							temp.posy << other.posy[j]
+							temp.valor << other.valor[j]
+						end
+					end
+				end
+			end
+		
+			return temp
+		else 
+			return nil
+		end
+	end
+	    
+end
+
+
+class MatrizDensa < Matriz
+attr_accessor :mat
+	def initialize(f,c,e)
+		super(f,c)
+		@mat = Array.new(@fil.to_i){Array.new(@col.to_i)}
+
+	    	if (e != nil)
+			#Rellenamos la matriz con lo valores recibidos 
+	    		for i in (0...@fil.to_i)
+				for j in (0...@col.to_i)
+					@mat[i][j]=e[i*@col.to_i+j];
+				end
+	    		end
+	    	end
+	end
+	# Metodos getter devuelve el valor de una posicion determinada
+
+	def pos(a,b)
+		@mat[a][b]
+	end
+	
+	#Metodo que devuelve la matriz en forma de string                       
+	def to_s    
+		"#{@mat}"
+	end
+
+	def max
+		m = self.mat[0][0]
+		for i in (0...@fil.to_i)
+			for j in (0...@col.to_i)
+				if (self.mat[i][j] > m)
+					m = self.mat[i][j]
+				end
+			end
+		end
+		return m
+	end
+
+	def min
+		m = self.mat[0][0]
+		for i in (0...@fil.to_i)
+			for j in (0...@col.to_i)
+				if (self.mat[i][j] < m)
+					m = self.mat[i][j]
+				end
+			end
+		end
+		return m
+	end
+	                             
+#Operador de comparacion (Modulo comparable). se comparan por la suma de sus componentes ¡¡¡¡¡¡PONERLO EN LA CLASE MADRE!!!!!!
+
+	def <=> (other)
+		return nil unless other.is_a?MatrizDensa
+		c1=0
+		c2=0
+		for i in (0...@fil.to_i)
+			for j in (0...@col.to_i)
+				if(self.mat[i][j] > other.mat[i][j])
+					c1+=1
+				elsif(self.mat[i][j] < other.mat[i][j])
+					c2+=1
+				end
+			end
+		end
+		(c1)<=>(c2)
+	end
+
+end
+		
+
+
+
+class MatrizDispersa < Matriz
+attr_accessor :posx, :posy, :valor
+	def initialize(f,c,posx, posy, valor)
+		super(f,c)
+		@posx = posx
+		@posy = posy
+		@valor = valor
+
+	end
+
+	def to_s
+		s=String.new
+		s << "["
+		for i in (0...@fil.to_i)
+			s << "[#{posx[i]},#{posy[i]},#{valor[i]}]"
+		end
+		s << "]"
+	end
+
+	def max
+		m = self.valor[0]
+		for i in (0...self.valor.size.to_i)
+				if (self.valor[i]> m)
+					m = self.valor[i]
+				end
+		end
+		return m
+	end
+
+	def min
+		m = self.valor[0]
+		for i in (0...self.valor.size.to_i)
+				if (self.valor[i]< m)
+					m = self.valor[i]
+				end
+		end
+		return m
+	end
+
+	def pos(a,b)
+		for i in (0...self.posx.size)
+			if(posx[i]==a and posy[i]==b)
+				return valor[i]
+			end
+		end
+		return nil
+	end
+
+end
+
+
+
+
+
+
+
+
+
+
+
+
+=begin
+a=MatrizDensa.new(3,3,[1,2,3,4,5,6,7,8,9])
+b=MatrizDensa.new(3,3,[1,2,3,4,5,6,7,8,9])
+puts "#{(a+b).to_s}"
+puts "#{(a-b).to_s}"
+
+
+a=MatrizDensa.new(3,3,[1,2,3,4,5,6,7,8,9])
+b=MatrizDispersa.new(3,3,[0,1,2],[0,1,2],[1,2,3])
+b=(b+b)
+puts "#{(b.valor).to_s}"
+
+
+a=MatrizDensa.new(3,3,[1,2,3,34,5,6,7,8,9])
+b=MatrizDispersa.new(3,3,[0,1,2],[0,1,2],[1,0,3])
+puts "#{a.max}"
+puts "#{b.max}"
+puts "#{a.min}"
+puts "#{b.min}"
+
+b=MatrizDispersa.new(3,3,[0,1,2],[0,1,2],[1,2,3])
+c=MatrizDispersa.new(3,3,[0,1,2],[0,2,2],[1,2,3])
+b=(b+c)
+puts "#{b.valor.to_s}"
+
+a=MatrizDensa.new(3,3,[1,2,3,4,5,6,7,8,9])
+b=MatrizDensa.new(3,3,[1,2,3,4,5,6,7,8,9])
+if(a==b)
+	puts "igual"
+end
+if (a>=b)
+	puts "mayor"
+end
+
+b=MatrizDispersa.new(3,3,[0,1,2],[0,1,2],[1,2,3])
+c=MatrizDispersa.new(3,3,[0,1,2],[0,2,2],[1,2,3])
+b=(b+c)
+puts "#{b.to_s}"
+
+
+=end
+
+

data/matrices_p9.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'matrices_p9/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "matrices_p9"
+  gem.version       = MatricesP9::VERSION
+  gem.authors       = ["Luis Orta, Adriana Rolo"]
+  gem.email         = ["alu0100611526@ull.edu.es, alu0100658712@ull.edu.es"]
+  gem.description   = %q{Gema para realizar suma entre matrices densas y matrices dispersas}
+  gem.summary       = %q{matrices densas y dispersas}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+ gem.add_development_dependency 'rspec', '~>2.11'
+end

data/spec/matrices_p9_spec.rb

@@ -0,0 +1,123 @@
+require 'matrices_p9' 
+
+describe Matriz do
+	before :each do	
+		#Matrices densas
+		@m1 = MatrizDensa.new(3,3,[1,2,3,4,5,6,7,8,9])
+		@m2 = MatrizDensa.new(3,3,[1,2,3,4,5,6,7,8,9])
+		
+		#Matrices dispersas
+		@m3 = MatrizDispersa.new(3,3,[0,1,2],[0,1,2],[1,2,3])
+		@m4 = MatrizDispersa.new(3,3,[0,1,2],[0,1,2],[1,2,3])
+		
+		#Matrices densas con fracciones
+		@m5 = MatrizDensa.new(2,2,[Fraccion.new(1,2),Fraccion.new(1,3),Fraccion.new(1,4),Fraccion.new(1,5)])
+		@m6 = MatrizDensa.new(2,2,[Fraccion.new(1,2),Fraccion.new(2,3),Fraccion.new(3,4),Fraccion.new(4,5)])
+	end
+
+#Initialize
+	describe "#Inicializar la matriz" do
+		it "Se usa pos para acceder a los elementos" do
+			@m1.pos(0,2).should eq(3)
+			@m1.pos(2,2).should eq(9)
+			@m2.pos(2,1).should eq(8) 
+		end
+	end
+=begin
+#Operaciones básicas	
+	describe "#Operaciones elementales" do
+
+		it "Se invoca a to_s" do 
+			@m1.to_s.should eq("[[1, 2, 3], [4, 5, 6], [7, 8, 9]]")
+		end
+
+		it "Se invoca a suma" do 
+			
+			(@m1+@m2).to_s().should eq("[[2, 4, 6], [8, 10, 12], [14, 16, 18]]")
+		end
+		
+		it "Se invoca a resta" do 
+			(@m1-@m2).to_s().should eq("[[0, 0, 0], [0, 0, 0], [0, 0, 0]]")
+		end
+
+		it "Se invoca a multiplicacion" do 
+			(@m1*@m2).to_s().should eq("[[30, 36, 42], [66, 81, 96], [102, 126, 150]]")
+		end
+
+		it "Suma de elementos" do 
+			@m1.suma().should eq(45)
+		end
+		
+	end
+
+#Comparaciones
+	describe "#Operadores de comparacion" do
+		it "Mayor que" do
+			(@m1>@m2).should eq(false)
+		end
+
+		it "Menor que" do
+			(@m1<@m2).should eq(false)
+		end
+
+		it "Mayor igual que" do
+			(@m1>=@m2).should eq(true)
+		end
+		
+		it "Menor igual que" do
+			(@m1<=@m2).should eq(true)
+		end
+
+		it "Igual que" do
+			(@m1==@m2).should eq(true)
+		end
+
+		it "Distinto de" do
+			(@m1!=@m2).should eq(false)
+		end
+	end
+=end
+#Modificacion
+	describe "#Operadores de comparacion" do
+		it "Suma fracciones" do
+			(@m5+@m6).to_s.should eq("[[1/1, 1/1], [1/1, 1/1]]")
+		end
+
+=begin		it "Multiplicacion de fracciones" do
+			(@m5*@m6).to_s.should eq("[[1/2, 3/5], [11/40, 49/150]]")
+		end
+=end
+	end
+
+#creacion de matrices dispersas
+	describe "#creando una matriz dispersa" do
+		it "Comprobando que se creo correctamente." do
+			@m3.pos(0,0).should eq(1)
+			@m3.pos(1,1).should eq(2)
+			@m3.pos(2,2).should eq(3)
+		end
+	end
+
+
+
+#Prueba de matrices densas y dispersas. 
+	describe "#Operaciones de suma entre matrices densas y dispersas." do
+		it "Suma de matrices dispersas" do
+			(@m3+@m4).to_s().should eq("[[0,0,2][1,1,4][2,2,6]]")
+		end		
+		
+		it "Suma de matrices densas y dispersas" do
+			(@m1+@m3).to_s().should eq("[[2, 2, 3], [4, 7, 6], [7, 8, 12]]")
+		end
+		
+		it "Suma de matrices dispersas y densas " do
+			(@m3+@m1).to_s().should eq("[[2, 2, 3], [4, 7, 6], [7, 8, 12]]")
+		end
+		
+	end
+	
+	
+	
+	
+	
+end

data/test/tc_MatrizDensa.rb

@@ -0,0 +1,26 @@
+# Pruebas unitarias de la clase matriz densa
+
+require 'fraccion'
+require 'matrices_p9'
+require "test/unit"
+
+
+class Test_MatrizDensa < Test::Unit::TestCase
+	
+	def test_1
+	
+		assert_equal "[[2, 4, 6], [8, 10, 12], [14, 16, 18]]", (MatrizDensa.new(3,3,[1,2,3,4,5,6,7,8,9]) + MatrizDensa.new(3,3,[1,2,3,4,5,6,7,8,9])).to_s	
+		#assert_equal "[[0, 0, 0], [0, 0, 0], [0, 0, 0]]", (MatrizDensa.new(3,3,[1,2,3,4,5,6,7,8,9]) - MatrizDensa.new(3,3,[1,2,3,4,5,6,7,8,9])).to_s
+		#assert_equal "[[30, 36, 42], [66, 81, 96], [102, 126, 150]]", (MatrizDensa.new(3,3,[1,2,3,4,5,6,7,8,9])* MatrizDensa.new(3,3,[1,2,3,4,5,6,7,8,9])).to_s
+		
+	end
+	
+	#pruebas con matrices de fracciones
+	def test2
+		assert_equal "[[1/1, 1/1], [1/1, 1/1]]", (MatrizDensa.new(2,2,[Fraccion.new(1,2),Fraccion.new(1,3),Fraccion.new(1,4),Fraccion.new(1,5)]) + MatrizDensa.new(2,2,[Fraccion.new(1,2),Fraccion.new(2,3),Fraccion.new(3,4),Fraccion.new(4,5)])).to_s	
+		#assert_equal "[[1/2, 3/5], [11/40, 49/150]]", (MatrizDensa.new(2,2,[Fraccion.new(1,2),Fraccion.new(1,3),Fraccion.new(1,4),Fraccion.new(1,5)]) * MatrizDensa.new(2,2,[Fraccion.new(1,2),Fraccion.new(2,3),Fraccion.new(3,4),Fraccion.new(4,5)])).to_s	
+		
+	end
+	
+
+end

data/test/tc_MatrizDispersa.rb

@@ -0,0 +1,16 @@
+# Pruebas unitarias de la clase matriz dispersa
+require "fraccion"
+require "matrices_p9"
+require "test/unit"
+
+
+class Test_MatrizDispersa < Test::Unit::TestCase
+	
+	def test_1
+	
+		assert_equal "[[0,0,2][1,1,4][2,2,6]]", (MatrizDispersa.new(3,3,[0,1,2],[0,1,2],[1,2,3]) + MatrizDispersa.new(3,3,[0,1,2],[0,1,2],[1,2,3])).to_s	
+		
+	end
+
+end
+

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: matrices_p9
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Luis Orta, Adriana Rolo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+description: Gema para realizar suma entre matrices densas y matrices dispersas
+email:
+- alu0100611526@ull.edu.es, alu0100658712@ull.edu.es
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- README.md~
+- Rakefile
+- lib/fraccion.rb
+- lib/matrices_p9.rb
+- lib/matrices_p9/version.rb
+- matrices_p9.gemspec
+- spec/matrices_p9_spec.rb
+- test/tc_MatrizDensa.rb
+- test/tc_MatrizDispersa.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: matrices densas y dispersas
+test_files:
+- spec/matrices_p9_spec.rb
+- test/tc_MatrizDensa.rb
+- test/tc_MatrizDispersa.rb