p10lppt13 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8436d25fe500897f8296082a082742d4c4c11540
+  data.tar.gz: 1a08d13f564ab578c876318ee537270ec64c8fd9
+SHA512:
+  metadata.gz: 96eae38e7cfd7f988edfb41b821d83bdcbe85f8df50751734b430cb774241b69bb0c68e323ee955c315551d841d4a00e8ff8274a2937ffe8a3b295210831e97b
+  data.tar.gz: 7dfa726681d6ce045daf61c0ce78ee3d2583e8dade0c2ef055e589c65c4dbb1126f6b822cbc2b3a2a363372d888d7cbe08fa9d554e6dde70dc78032a8a0fb472

data/.gitignore

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

data/.travis.yml

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

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in p10lppt13.gemspec
+gemspec
+
+gem 'rake'
+gem 'rspec'
+gem 'guard'
+gem 'guard-rspec'

data/Gemfile.lock

@@ -0,0 +1,58 @@
+PATH
+  remote: .
+  specs:
+    p10lppt13 (0.1.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    celluloid (0.15.2)
+      timers (~> 1.1.0)
+    coderay (1.0.9)
+    diff-lcs (1.2.4)
+    ffi (1.9.3)
+    formatador (0.2.4)
+    guard (2.2.3)
+      formatador (>= 0.2.4)
+      listen (~> 2.1)
+      lumberjack (~> 1.0)
+      pry (>= 0.9.12)
+      thor (>= 0.18.1)
+    guard-rspec (4.0.3)
+      guard (>= 2.1.1)
+      rspec (~> 2.14)
+    listen (2.2.0)
+      celluloid (>= 0.15.2)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+    lumberjack (1.0.4)
+    method_source (0.8.2)
+    pry (0.9.12.2)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    rake (10.1.0)
+    rb-fsevent (0.9.3)
+    rb-inotify (0.9.2)
+      ffi (>= 0.5.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.3)
+      diff-lcs (< 2.0, >= 1.1.3)
+    rspec-mocks (2.14.4)
+    slop (3.4.6)
+    thor (0.18.1)
+    timers (1.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  guard
+  guard-rspec
+  p10lppt13!
+  rake
+  rspec

data/Guardfile

@@ -0,0 +1,52 @@
+guard 'bundler' do
+  watch('Gemfile')
+end
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/p10lppt13_spec.rb" }
+end
+
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml|\.slim)$})          { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+
+  # Capybara features specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml|slim)$})     { |m| "spec/features/#{m[1]}_spec.rb" }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end
+
+
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml|\.slim)$})          { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+
+  # Capybara features specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml|slim)$})     { |m| "spec/features/#{m[1]}_spec.rb" }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end
+

data/README.md

@@ -0,0 +1,58 @@
+[Práctica 10 de LPP](http://campusvirtual.ull.es/1314/mod/assign/view.php?id=95635)
+=================
+
+Alumnos:
+  - [José Alexander Delgado Hernández](http://campusvirtual.ull.es/1314/user/view.php?id=5990&course=1102) ([alu0100596403@ull.edu.es](mailto:alu0100596403@ull.edu.es))
+  - [Sem Ramos Herrera](http://campusvirtual.ull.es/1314/user/view.php?id=2455&course=1102) ([alu0100603194@ull.edu.es](mailto:alu0100603194@ull.edu.es))
+
+=================
+
+##Jerarquía de la práctica
+    .
+    ├── bin
+    │   └── P10lppt13
+    ├── Gemfile
+    ├── .git
+    ├── .gitignore
+    ├── lib
+    │   ├── P10lppt13
+    │   │   └── version.rb
+    │   └── P10lppt13.rb
+    ├── LICENSE.txt
+    ├── P10lppt13.gemspec
+    ├── Rakefile
+    ├── README.md
+    ├── .README.md.kate-swp
+    └── .travis.yml
+
+##Clases que contendrá la práctica
+
+    En primer lugar, existirá una clase base "Matriz" abstracta, de la que heredarán "Dispera" y "Densa", 
+    y en la que se encontrarán los métodos comunes a ambas subclases, que según el porcentaje de
+    elementos que sean igual a cero, se tratará de un tipo de matriz u otro.
+    
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'Practica9'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install Practica9
+
+## 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,27 @@
+$:.unshift File.dirname(__FILE__) + 'lib'
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+task :default => :spec
+
+desc "Ejecutando las pruebas para el codigo de Matrices"
+task :speclocal do
+  sh "rspec -I. spec/p10lppt13_spec.rb"
+end
+
+desc "Ejecutando las pruebas para el codigo de Matrices con documentacion"
+task :run do
+  sh "rspec -I. spec/p10lppt13_spec.rb --format documentation"
+end
+
+desc "Ejecutando las pruebas para el codigo de Matrices con documentacion"
+task :thtml do
+  sh "rspec -I. spec/p10lppt13_spec.rb --format html"
+end
+
+desc "Ejecutando las pruebas unitarias para el codigo de Matrices"
+task :test do
+  sh "ruby -Ilib -Itest test/tc_p10lppt13.rb"
+end

data/lib/fraccion.rb

@@ -0,0 +1,143 @@
+require "gcd.rb"
+
+#############################################################
+# Clase Fraccion de la practica #7 de LPP                   #
+#############################################################
+
+class Fraccion 
+  
+    attr_reader :numer, :denomin
+    
+    # Incluimos el módulo Comparable
+    include Comparable
+  
+    def initialize(n,d) 
+      @numer, @denomin = n, d
+    end
+	
+	#############################################################
+    #  Funciones basicas de la clase                            #
+    #############################################################
+    
+	# Getter del num
+    def num()
+      return @numer
+    end
+
+	# Getter del denom
+    def denom()
+      return @denomin
+    end
+  
+	# Funcion para simplificar y mostrar la fraccion en formato reducido
+    def simplificar
+      aux = gcd(self.numer, self.denomin)                        # MCD entre num y denom
+      Fraccion.new(self.numer/aux, self.denomin/aux)			 # Simplificamos la fraccion que le pasemos
+    end 
+    
+    #Mostramos los atributos en un string
+    def to_s
+      "#{@numer}/#{@denomin}"
+    end
+   
+	#Mostramos los atributos en float
+    def to_f
+      @numer/@denomin.to_f
+    end
+   
+    #############################################################
+    #  Funciones de igualdad, absoluto, reciproco y opuesto     #
+    #############################################################
+    
+    # Funcion de comparar igualdad: Comparamos la fraccion implicita, con la que le pasamos como parametro
+    def ==(other)
+		if other.class.to_s != "Fraccion"
+			other = Fraccion.new(other,1)
+		end
+		if ((@numer == other.numer) and (@denomin == other.denomin))
+			true		# Si el numerador y el denominador de la implicita coinciden con los 
+						# de la pasada por parametro, entonces las fracciones son iguales (true)
+		else
+			false		# Si no, son distintas (false)
+		end  
+    end
+  
+	# Funcion que devuelve la funcion en valor absoluto
+	def absoluto
+		@numer = @numer.abs
+		@denomin = @denomin.abs
+		Fraccion.new(@numer,@denomin)
+	end
+  
+	#Obtiene la fraccion reciproca a la implicita
+	def reciprocal
+		Fraccion.new(@denomin,@numer)
+	end
+  
+	# Funcion que calcula la fraccion opuesta
+	def opuesto
+		Fraccion.new(-@numer,@denomin)
+	end
+  
+	#############################################################
+    #  Funciones de suma, resta, multiplicacion y division      #
+    #############################################################
+	
+	# Necesitamos hallar el minimo comun multiplo para la suma y la resta
+	def mcm(n, m)
+		aux=gcd(n,m)
+		(n/aux)*m 
+	end
+	
+	# Realizamos la division de la fraccion implicita con recibida como parametro
+	def /(other)
+		temp = Fraccion.new(@numer*other.denomin, @denomin*other.numer)
+		temp.simplificar
+	end
+	
+	# Realizamos la suma de la fraccion implicita con recibida como parametro
+	def +(other)             
+		if(other.instance_of?Fixnum)
+                        temp=other
+                        other=Fraccion.new(temp,1)
+                end
+		
+		aux = mcm(@denomin, other.denomin)                                                    
+		temp = Fraccion.new(((aux/@denomin)*@numer)+((aux/other.denomin)*other.numer),aux)               
+		temp.simplificar
+	end
+    
+    # Realizamos la resta de la fraccion implicita con recibida como parametro
+	def -(other)
+		aux = mcm(@denomin, other.denomin)
+		temp = Fraccion.new(((aux/@denomin)*@numer)-((aux/other.denomin)*other.numer),aux)
+		temp.simplificar                                 
+	end
+   
+	# Realizamos la multiplicacion de la fraccion implicita con recibida como parametro
+	def *(other)
+		temp=Fraccion.new(@numer*other.numer, @denomin*other.denomin) 
+		temp.simplificar                                                
+	end
+	
+	#############################################################
+    #  Funciones de modulo y comparacionales (menor, mayor,     #
+    #  menor o igual y mayor o igual)
+    #############################################################
+  
+	def %(other)										#Obtenemos el resto de la division de dos fracciones								
+		aux1 = self.numer * other.denomin				#Multiplicamos el numerador de la primera entre el denominador de la segunda
+		aux2 = self.denomin * other.numer				#Multiplicamos el denominador de la primera entre el numerador de la segunda
+		resto = aux1%aux2								#Obtenemos el Resto de la fraccion resultante
+	end
+	
+	def <=>(other)
+		self.to_f <=> other.to_f
+	end
+	
+	def coerce(other)
+		#aux = Fraccion.new(other,1)
+		[self,other]
+	end
+
+end

data/lib/gcd.rb

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

data/lib/p10lppt13/version.rb

@@ -0,0 +1,3 @@
+module P10lppt13
+  VERSION = "1.0.0"
+end

data/lib/p10lppt13.rb

@@ -0,0 +1,277 @@
+require "fraccion.rb"
+
+class Matriz
+
+	attr_reader :nfil, :ncol
+	# Metodo initilize de la clase base
+	$acum
+	def initialize(nfil, ncol)
+		@nfil = nfil
+		@ncol = ncol
+	end
+	
+	# Getter de nfil
+	def filas
+		@nfil
+	end
+	
+	# Getter de ncol
+	def colum
+		@ncol
+	end
+	
+	# Metodo para convertir la matriz a string
+	def to_s
+		aux = ""
+		@nfil.times do |i|
+			@ncol.times do |j|
+				aux << "#{pos[i][j]}\t"
+			end
+			aux << "\n"
+		end
+		aux
+	end
+	
+	# Metodo para sumar dos matrices
+	def +(other)
+		if ((@nfil != other.nfil) || (@ncol != other.ncol))
+			puts "No se pueden sumar las matrices"
+		else 
+		  elemento = Array.new(0)
+			for i in 0...filas
+				fila = Array.new(0)
+				for j in 0...colum
+					if self.pos[i][j] == nil && other.pos[i][j] != nil
+						fila << other.pos[i][j]
+					elsif self.pos[i][j] != nil && other.pos[i][j] == nil
+						fila << pos[i][j]
+					elsif self.pos[i][j] == nil && other.pos[i][j] == nil
+						fila << 0
+					else
+						fila << pos[i][j] + other.pos[i][j]
+					end     			   
+				end
+				elemento << fila
+			end
+		Densa.new(@nfil, @ncol, elemento)
+		end
+	end	
+	
+	# Metodo para restar dos matrices
+	def -(other)
+		if ((@nfil != other.nfil) || (@ncol != other.ncol))
+			puts "No se pueden restar las matrices"
+		else 
+		  elemento = Array.new(0)
+			for i in 0...filas
+				fila = Array.new(0)
+				for j in 0...colum
+					if self.pos[i][j] == nil && other.pos[i][j] != nil
+						fila << -other.pos[i][j]
+					elsif self.pos[i][j] != nil && other.pos[i][j] == nil
+						fila << pos[i][j]
+					elsif self.pos[i][j] == nil && other.pos[i][j] == nil
+						fila << 0
+					else
+						fila << pos[i][j] - other.pos[i][j]
+					end     			   
+				end
+				elemento << fila
+			end
+		Densa.new(@nfil, @ncol, elemento)
+		end
+	end
+	
+	def primervalor
+		for i in 0...@nfil
+			for j in 0...@nncol
+				if (self.pos[i][j] != nil) 
+				    return self.pos[i][j]
+				end
+			end
+		end
+	end
+	
+	# Metodo para hallar el maximo de una matriz
+	def max
+		acum = pos[0][0]
+		for i in 0...filas
+			for j in 0...colum
+				if self.pos[i][j] != nil
+					if pos[i][j] > acum
+						acum = pos[i][j]
+					end
+				end     			   
+			end
+		end
+		acum
+	end
+	
+	# Metodo para hallar el minimo de una matriz
+	def min
+		acum = pos[0][0]
+		for i in 0...filas
+			for j in 0...colum
+				if self.pos[i][j] != nil
+					if pos[i][j] < acum
+						acum = pos[i][j]
+					end
+				end     			   
+			end
+		end
+		acum
+	end
+	
+	# Metodo para multiplicacion dos matrices
+	def por(other)
+		if ((@nfil != other.ncol) || (@ncol != other.nfil))
+			puts "No se pueden multiplicarr las matrices"
+		else
+			elemento = Array.new(0)
+			for i in 0...nfil
+				fila = Array.new(0)
+				for j in 0...other.ncol
+					aux = 0
+					for k in 0...ncol
+						aux += pos[i][k] * other.pos[k][j]
+					end
+					fila << aux
+				end
+				elemento << fila
+			end
+		end
+		Matriz.new(@nfil, other.ncol, elemento)
+	end
+	
+	# Metodo para multiplicacion dos matrices
+	def porf(other)
+		if ((@nfil != other.ncol) || (@ncol != other.nfil))
+			puts "No se pueden multiplicarr las matrices"
+		else
+			elemento = Array.new(0)
+			for i in 0...nfil
+				fila = Array.new(0)
+				for j in 0...other.ncol
+					aux = Fraccion.new(1,1)
+					aux = aux - aux
+					for k in 0...ncol
+						aux += pos[i][k] * other.pos[k][j]
+					end
+					fila << aux
+				end
+				elemento << fila
+			end
+		end
+		Densa.new(@nfil, other.ncol, elemento)
+	end
+	
+	# Metodo para multiplicar una matriz por un escalar
+	def *(other)
+		elemento = Array.new(0)
+		for i in 0...filas
+			fila = Array.new(0)
+			for j in 0...colum
+				fila << pos[i][j]*other
+			end
+			elemento << fila
+		end
+		Matriz.new(@nfil, @ncol, elemento)
+	end
+	
+	# Metodo para hallar la traspuesta de una matriz
+	def trasponer
+		elemento = Array.new(0)
+		for i in 0...colum
+			fila = Array.new(0)
+			for j in 0...filas
+				fila << pos[j][i]
+			end
+			elemento << fila
+		end
+		Densa.new(@ncol, @nfil, elemento)
+	end
+	
+	
+	# Metodo para convertir la matriz en un vector
+	def vectorizar
+		aux = Array.new(0)
+		for i in 0...colum
+			for j in 0...filas
+				aux << pos[i][j]
+			end
+		end
+		Array.new(aux)
+	end
+	
+end
+
+# Clase de Matrices Densas
+class Densa < Matriz
+	
+	attr_reader :pos
+	
+
+	def initialize(nfil, ncol, pos)
+		super(nfil, ncol)
+		@pos = Array.new(pos)
+	end
+	
+	def [](i)
+		@data[i]
+	end
+
+	def []=(i,value)
+		@data[i] = value
+	end
+	
+end
+
+# Clase de Vectores dispersos
+class VectorDisperso
+	attr_reader :vector
+	
+	def initialize(h = {})
+		@vector = Hash.new(0)
+		@vector = @vector.merge!(h)
+	end
+
+	def [](i)
+		@vector[i] 
+	end
+
+	def to_s
+		@vector.to_s
+	end
+end
+
+# Clase de Matrices Dispersas
+class Dispersa < Matriz
+	attr_reader :pos
+	
+	def initialize(nfil, ncol, h = {})
+		super(nfil, ncol)
+		@pos = Hash.new({})
+		for k in h.keys do 
+		@pos[k] = if h[k].is_a? VectorDisperso
+						h[k]
+					 else 
+						@pos[k] = VectorDisperso.new(h[k])
+                     end
+		end
+	end
+=begin
+for i in self.pos.keys do
+=end
+	def [](i)
+		@pos[i]
+	end
+
+	def col(j)
+		c = {}
+		for r in @pos.keys do
+			c[r] = @pos[r].vector[j] if @pos[r].vector.keys.include? j
+		end
+		VectorDisperso.new c
+	end
+	
+end

data/p10lppt13.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "p10lppt13/version"
+
+Gem::Specification.new do |s|
+  s.name        = "p10lppt13"
+  s.version     = P10lppt13::VERSION
+  s.authors     = ["José Alexander Delgado Hernández, Sem Ramos Herrera"]
+  s.email       = ["alu0100603194@ull.edu.es"]
+  s.homepage    = ""
+  s.summary     = %q{Gema de matrices densas y dispersas}
+  s.description = %q{Implementación de varias clases con matrices densas y dispersas}
+
+  s.rubyforge_project = "p10lppt13"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/p10lppt13_spec.rb

@@ -0,0 +1,134 @@
+require "p10lppt13.rb"
+
+describe Matriz do
+        before :each do
+                @m1 = Densa.new(2,2,[[1,2],[3,4]])
+                @m2 = Densa.new(3,3,[[1,2,4],[6,5,8],[2,5,3]])
+                @m3 = Dispersa.new(3,3, 0 => { 0 => 2, 2 => 1 })
+                @m4 = Densa.new(3,3,[[-1,-2,-4],[-3,-5,-1],[-2,-5,-3]])
+                @f1 = Fraccion.new(1,2)
+                @f2 = Fraccion.new(3,2)
+                @f3 = Fraccion.new(5,2)
+                @mf1 = Densa.new(2,2,[[@f1,@f2],[@f3,@f1]])
+                @mf2 = Densa.new(2,2,[[@f1,@f2],[@f1,@f2]])
+		@disper = Dispersa.new(2,2, 0 => { 0 => @f1 })
+        end
+
+        # Comprobacion de que se crea bien la matriz
+        describe "Comprobamos el numero de...\n" do
+                it " - Filas para una matriz densa 3x3\n" do
+                        @m2.nfil.should eq(3)
+                end
+                it " - Columnas de una matriz densa 3x3\n" do
+                        @m2.ncol.should eq(3)
+                end
+                it "Acceso al elemento [0][0]" do
+                        @m1.pos[0][0].should eq(1)
+                end
+                it "Acceso al elemento [0][1]" do
+                        @m1.pos[0][1].should eq(2)
+                end
+                it "Acceso al elemento [1][0]" do
+                        @m1.pos[1][0].should eq(3)
+                end
+                it "Acceso al elemento [1][1]" do
+                        @m1.pos[1][1].should eq(4)
+                end
+                it " - Filas para una matriz dispersa 3x3\n" do
+                        @m3.nfil.should eq(3)
+                end
+                it " - Columnas de una matriz dispersa 3x3\n" do
+                        @m3.ncol.should eq(3)
+                end
+                it "Acceso al elemento [0][2]" do
+                        @m3[0][2].should eq(1)
+                end
+        end
+	
+	 describe "Operaciones aritmeticas" do
+            it "Suma de dos matrices densas" do
+				@aux= @m1+@m1
+				@aux.to_s.should eq("2\t4\t\n6\t8\t\n")
+            end
+		
+			it "Suma de matriz densa y matriz dispersa" do
+				@aux=@m2+@m3
+				@aux.to_s.should eq("3\t2\t5\t\n6\t5\t8\t\n2\t5\t3\t\n")
+            end
+		
+			it "Suma de dos matrices dispersas" do
+				@aux=@m3+@m3
+				@aux.to_s.should eq("4\t0\t2\t\n0\t0\t0\t\n0\t0\t0\t\n")
+            end      
+            it "Resta de dos matrices densas" do
+				@aux= @m1+@m1
+				@aux2 = @aux-@m1
+				@aux2.to_s.should eq(@m1.to_s)
+            end
+		
+			it "Resta de matriz densa y matriz dispersa" do
+				@aux=@m2-@m3
+				@aux.to_s.should eq("-1\t2\t3\t\n6\t5\t8\t\n2\t5\t3\t\n")
+            end
+		
+			it "Resta de dos matrices dispersas" do
+				@aux=@m3+@m3
+				@aux2=@aux-@m3
+				@aux2.to_s.should eq("2\t0\t1\t\n0\t0\t0\t\n0\t0\t0\t\n")
+            end  
+        end
+        
+        describe "Maximo y minimo" do
+            it "Maximo dispersa" do
+				@m3.max.to_s.should eq("2")
+            end  
+            it "Minimo dispersa" do
+				@m3.min.to_s.should eq("0")
+            end  
+             it "Maximo densa" do
+				@m1.max.to_s.should eq("4")
+            end  
+            it "Minimo densa" do
+				@m1.min.to_s.should eq("1")
+            end
+            it "Maximo densa con valores negativos" do
+				@m4.max.should eq(-1)
+            end  
+            it "Minimo densa con valores negativos" do
+				@m4.min.should eq(-5)
+            end 
+        end
+        
+        describe "Operaciones con matrices con fracciones" do
+			it "Comprobamos que realiza bien la traspuesta" do
+				@aux = Densa.new(2,2,[[@f1,@f3],[@f2,@f1]])
+				@mf1.trasponer.to_s.should eq(@aux.to_s)
+			end
+			it "Comprobamos la suma" do
+				@aux = Densa.new(2,2,[[1,2],[3,4]])
+				@af1 = Fraccion.new(3,2)
+				@af2 = Fraccion.new(7,2)
+				@af3 = Fraccion.new(11,2)
+				@af4 = Fraccion.new(9,2)
+				@aux3 = Densa.new(2,2,[[@af1,@af2],[@af3,@af4]])
+				@aux2 = @aux+@mf1
+				@aux2.to_s.should eq(@aux3.to_s)
+			end
+			it "Comprobamos la multiplicacion" do
+				@aux = Densa.new(2,2,[[@f1,@f1],[@f1,@f1]])
+				@aux2 = @aux.porf(@aux)
+				@aux3 = Densa.new(2,2,[[@f1,@f1],[@f1,@f1]])
+				@aux2.to_s.should eq(@aux3.to_s)
+			end
+			it "Comprobamos el maximo" do
+				@aux = Densa.new(2,2,[[@f1,1],[@f3,@f1]])
+				@aux.max.should eq(@f3)
+			end
+			it "Comprobamos el minimo" do
+				@aux = Densa.new(2,2,[[1,@f2],[@f3,@f1]])
+				@aux.min.should eq(@f1)
+			end
+
+        end
+        
+end

data/test/tc_p10lppt13.rb

@@ -0,0 +1,21 @@
+
+require "p10lppt13.rb"
+
+require "test/unit"
+
+class TestP10lppt13 < Test::Unit::TestCase
+
+  def test_prueba
+    
+    @m1 = Densa.new(2,2,[[1,2],[3,4]])
+	@m2 = Densa.new(3,3,[[1,2,4],[6,5,8],[2,5,3]])
+	@m3 = Dispersa.new(3,3, 0 => { 0 => 2, 2 => 1 })
+                          
+    assert_equal "1\t2\t\n3\t4\t\n", @m1.to_s
+	assert_not_equal "4\t2\t\n3\t4\t\n", @m1.to_s
+	assert_not_nil @m3.pos[0][0]
+	assert_not_same @m3.pos[0][0], @m1.pos[0][2]
+    
+  end
+  
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: p10lppt13
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- José Alexander Delgado Hernández, Sem Ramos Herrera
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-22 00:00:00.000000000 Z
+dependencies: []
+description: Implementación de varias clases con matrices densas y dispersas
+email:
+- alu0100603194@ull.edu.es
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- README.md
+- Rakefile
+- lib/fraccion.rb
+- lib/gcd.rb
+- lib/p10lppt13.rb
+- lib/p10lppt13/version.rb
+- p10lppt13.gemspec
+- spec/p10lppt13_spec.rb
+- test/tc_p10lppt13.rb
+homepage: ''
+licenses: []
+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: p10lppt13
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Gema de matrices densas y dispersas
+test_files: []
+has_rdoc: