modai_prct10 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 05739c7ea7b0173c50241ff8657ac2ada85f4159
+  data.tar.gz: cbbc2e606c2bbac433c21c43cf674719a622fd74
+SHA512:
+  metadata.gz: 35a2dfed99c627420196974c5199b0cf84fafcba3923f9e9ba2f9160098c52bbf0a7ac64909d86442acf97b53da1c2341e0f524a90e9c485a25ac25ba7a5fa0b
+  data.tar.gz: bab5d437aebbe4ae9b747953c6dcbe0e19e98c6038b7b48c3e225a2e966d2c0f21546889afd0f5bfcce2898903a42c5208e7c75a06e06709b98c2a8be0487362

data/.gitignore

@@ -0,0 +1,17 @@
+*.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,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+#  - 1.9.2
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx-19mode

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,38 @@
+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
+
+guard :bundler do
+  watch('Gemfile')
+  # Uncomment next line if your Gemfile contains the `gemspec' command.
+  # watch(/^.+\.gemspec/)
+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/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Dailos Herrera Bencomo
+
+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,22 @@
+Práctica        : Práctica de Laboratorio #10 - EQUIPO.
+======================================================
+Grupo           : LPP-T-45.
+Alumnos         : DAILOS HERRERA BENCOMO.
+                  MOHAMMED MAHRACH.
+Asignatura      : LPP.
+
+-------------------------------------------------
+
+Considere la Gema para Matrices que empezó a desarrollar en la práctica anterior. El objetivo de esta práctica es terminar su creación.
+
+1.- Desarrollar métodos para calcular el máximos y el mínimo de los elementos de una matriz.
+
+2.- Construir la gema
+
+gem build
+
+3.- Considerar su publicacion
+
+gem push
+
+4. Indique la URL del repositorio que ha desarrollado.

data/Rakefile

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

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/modai_prct10/version.rb

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

data/lib/modai_prct10.rb

@@ -0,0 +1,391 @@
+require "modai_prct10/version"
+require "racional"
+
+module ModaiPrct10
+
+$tope = 9999999999.9
+  
+# Clase abstracta para herencia común de matrices densa y dispersa
+class MatrizAbstracta
+
+end
+
+# Clase de Matriz densa
+class MatrizDensa < MatrizAbstracta
+
+	# Inicialización
+	def initialize(matriz)
+
+		@matriz = matriz
+		@filas = matriz[0].size
+		@columnas = matriz[0].size
+
+	end
+
+	attr_reader :matriz, :filas, :columnas
+
+	# Convertimos a string
+	def to_s
+
+		fil = 0
+		print "["
+		while fil < filas
+
+			col = 0					
+			while col < columnas
+
+				print "#{matriz[fil][col].to_s}"
+				if (col + 1) < columnas then print ", " end
+				col += 1
+
+			end
+
+			if (fil + 1) < filas then print ", " end
+			fil += 1
+
+		end
+		print "]"
+
+	end
+
+	#  Matriz en punto flotante
+	def to_f
+
+                flotante = Array.new(matriz.size - 1)
+                for i in 0...matriz.size
+                        flotante[i] = Array.new(matriz[i].size - 1)
+                        for j in 0...matriz[i].size
+                                flotante[i][j] = (matriz[i][j]).to_f
+                        end
+                end
+                MatrizDensa.new(flotante)
+
+	end
+
+	# Suma de matrices
+	def +(o)
+
+		suma = Array.new(matriz.size - 1)
+		for i in 0...matriz.size
+		   	suma[i] = Array.new(matriz[i].size - 1)
+			for j in 0...matriz[i].size
+				suma[i][j] = matriz[i][j] + o.matriz[i][j]
+			end
+		end
+		MatrizDensa.new(suma)
+
+	end
+
+	# Resta de matrices
+	def -(o)
+
+                resta = Array.new(matriz.size - 1)
+                for i in 0...matriz.size
+			resta[i] = Array.new(matriz[i].size - 1)
+			for j in 0...matriz[i].size
+				resta[i][j] = matriz[i][j] - o.matriz[i][j]
+			end
+                end
+                MatrizDensa.new(resta)
+
+	end
+
+	# Multiplicación de matrices
+	def *(o)
+
+		prod = Array.new(matriz.size - 1,0)
+		for i in 0...matriz[0].size 
+			prod[i] = Array.new(o.matriz.size,0)
+			for j in 0...o.matriz.size
+				for pos in 0...matriz.size
+					prod[i][j] = prod[i][j] + (matriz[i][pos] * o.matriz[pos][j])
+				end
+			end
+		end
+		MatrizDensa.new(prod)
+
+	end
+
+	# Máximo de matriz
+	def max
+
+		maximo = 0.to_f
+		for i in 0...matriz.size
+			for j in 0...matriz[i].size
+				if matriz[i][j].to_f > maximo
+					maximo = matriz[i][j].to_f
+				end
+			end
+		end
+		maximo
+
+	end
+
+	# Minimo de matriz
+	def min
+
+		minimo = $tope
+		for i in 0...matriz.size
+			for j in 0...matriz[i].size
+				if matriz[i][j].to_f < minimo
+					minimo = matriz[i][j].to_f
+				end
+			end
+		end
+		minimo
+
+	end
+
+end
+
+# Clase de Matriz dispersa
+class MatrizDispersa < MatrizAbstracta
+
+	# Inicialización
+        def initialize(matriz)
+
+                @matriz = matriz
+                @filas = matriz.size
+                @columnas = matriz.size
+
+	end
+
+	attr_reader :matriz, :filas, :columnas
+
+	# Convertimos a string
+	def to_s
+
+                fil = 0
+                print "["
+                while fil < filas
+
+			col = 0
+			while col < columnas
+
+                       		# Hay datos en la fila
+                       		if matriz[fil] != nil
+
+					if matriz[fil].has_key?(col)
+						print "#{matriz[fil][col].to_s}"
+                                        else
+                                        	print "0"
+					end 
+				else
+                                        print "0"
+				end
+
+	                       	if (col + 1) < columnas then print ", " end
+        	                col += 1
+
+			end
+
+
+                        if (fil + 1) < filas then print ", " end
+                        fil += 1
+
+                end
+                print "]"
+
+	end
+
+	#  Matriz en punto flotante
+	def to_f
+
+                flotante = Array.new(matriz.size - 1)
+                for i in 0...matriz.size
+			# Hay datos en la fila
+                        if matriz[i] != nil
+				
+                        	flotante[i] = Hash.new()
+                                matriz[i].each do |key, value|
+					flotante[i][key] = matriz[i][key].to_f
+                                end
+			
+			end
+
+                end
+                MatrizDispersa.new(flotante)
+
+	end
+
+	# Suma de matrices
+	def +(o)
+
+                suma = Array.new(matriz.size - 1)
+                for i in 0...matriz.size
+                      
+			# creamos el hash
+			if (matriz[i] != nil or o.matriz[i] != nil)
+
+				suma[i] = Hash.new()
+		
+				case true
+
+					# Los dos tienen hash
+					when (matriz[i] != nil and o.matriz[i] != nil)
+				
+						# cogemos matriz como base para la suma
+						suma[i] = matriz[i]
+
+						o.matriz[i].each do |key, value|
+				
+							if suma[i].has_key?(key)
+		                                        	suma[i][key] = suma[i][key] + o.matriz[i][key]
+                		                        else
+                                		                suma[i][key] = o.matriz[i][key]
+		                                        end
+
+                                		end
+
+					# matriz tiene hash
+					when matriz[i] != nil
+						suma[i] = matriz[i]						
+	
+					# o hash
+					when o.matriz[i] != nil
+						suma[i] = o.matriz[i]
+
+
+				end
+			
+			end
+
+                end
+                MatrizDispersa.new(suma)
+
+	end
+
+	# Resta de matrices
+	def -(o)
+
+                resta = Array.new(matriz.size - 1)
+                for i in 0...matriz.size
+
+                        # creamos el hash
+                        if (matriz[i] != nil or o.matriz[i] != nil)
+
+                                resta[i] = Hash.new()
+                                        
+                                case true
+
+                                        # Los dos tienen hash
+                                        when (matriz[i] != nil and o.matriz[i] != nil)
+                                
+                                                # cogemos matriz como base para la resta
+                                                resta[i] = matriz[i]
+
+                                                o.matriz[i].each do |key, value|
+                                
+                                                        if resta[i].has_key?(key)
+                                                                resta[i][key] = resta[i][key] - o.matriz[i][key]
+                                                        else
+                                                                resta[i][key] = o.matriz[i][key] * -1
+                                                        end
+
+                                                end
+
+                                        # matriz tiene hash
+                                        when matriz[i] != nil
+                                                resta[i] = matriz[i]                                             
+        
+                                        # o hash
+                                        when o.matriz[i] != nil
+						resta[i] = o.matriz[i]
+						resta[i].each do |key, value|
+							resta[i][key] =  resta[i][key] * -1
+                                                end
+
+                                end
+                        
+                        end
+
+                end
+                MatrizDispersa.new(resta)
+
+	end
+
+=begin
+	# Multiplicación de matrices
+	def *(o)
+
+                prod = Array.new(matriz.size - 1,0)
+                for i in 0...matriz.size
+
+			if (o.matriz[i] != nil)
+
+				aux = 0
+				for j in 0...o.matriz.size
+
+					if (matriz[j] != nil)
+
+						if matriz[j].has_key?(i)
+
+							# No existe hash en la fila
+							if prod[j] != nil
+								prod[j] = Hash.new()
+							end
+
+							aux = aux + (o.matriz[i][j] * matriz[j][i])	
+
+						end
+
+					end
+				
+				end
+				if aux <> 0
+					prod.merge!({"#{}" => "#{aux}"})	
+				end
+
+			end
+
+#                                        prod[i][j] = prod[i][j] + (matriz[i][pos] * o.matriz[pos][j])
+ 
+
+				
+                end
+                MatrizDispersa.new(prod)
+
+	end
+
+=end
+
+	# Máximo de matriz
+	def max
+
+                maximo = 0.to_f
+                for i in 0...matriz.size
+                        # Hay datos en la fila
+                        if matriz[i] != nil
+                                matriz[i].each do |key, value|
+                                        if matriz[i][key].to_f > maximo
+                                                maximo = matriz[i][key].to_f
+                                	end
+				end                        
+                        end
+                end
+                maximo
+
+	end
+
+	# Minimo de matriz
+	def min
+
+	        minimo = 0.to_f
+                for i in 0...matriz.size			
+			# Hay datos en la fila
+			if matriz[i] != nil					
+				matriz[i].each do |key, value|
+                	               	if matriz[i][key].to_f < minimo
+                        	               	minimo = matriz[i][key].to_f
+                               		end
+				end
+                        end				
+                end
+                minimo
+
+	end
+
+end
+
+end
+

data/lib/racional.rb

@@ -0,0 +1,89 @@
+# racional.rb
+require "gcd"
+
+class Racional
+        
+  include Comparable
+        
+  # Se inicializa la fracción en su forma reducida haciendo uso de gcd
+  def initialize(num, denom)
+
+    raise TypeError, "El denominador debe ser mayor que cero" unless (denom != 0)
+
+    div = gcd(num, denom)
+    @num = num/div
+    @denom = denom/div
+
+  end
+
+  # Gets y Sets de @num y @denom
+  attr_reader :num, :denom
+
+  #mostar por la consola la fraccion de la forma: a/b
+  def to_s
+    "#{num}/#{denom}"
+  end
+
+  #comparar que dos fracciones son iguales
+  def ==(o)
+    if o.instance_of? Racional
+        @num == o.num && @denom == o.denom
+    else
+        false
+    end
+  end
+
+  # Mostar la fraccion en formato flotante
+  def to_f
+    num.to_f/denom
+  end
+
+  # Calcular el valor absoluto de una fraccion con el metodo abs
+  def abs
+    Racional.new(num.abs, denom.abs)
+  end
+
+  # calcular el reciproco de una fraccion con el metodo reciprocal
+  def reciprocal
+    Racional.new(denom, num)
+  end
+
+  # Calcular el opuesto de una fraccion con -
+  def -@
+    Racional.new(-denom, num)        
+  end
+
+  # suma dos fracciones con + y dar el resultado de forma reducida
+  def +(o)
+    Racional.new(num*o.denom + o.num*denom, denom*o.denom)
+  end
+
+  # resta dos fracciones con - y dar el resultado de forma reducida
+  def -(o)
+    Racional.new(num*o.denom - o.num*denom, denom*o.denom)
+  end
+
+  #multiplica dos fracciones con * y dar el resultado de forma reducida
+  def *(o)
+    Racional.new(num*o.num,denom*o.denom)
+  end
+
+  # divide dos fracciones con / y dar el resultado de forma reducida
+  def /(o)
+    Racional.new(num*o.denom,denom*o.num)
+  end
+
+  # calcula el resto dos fracciones con % y dar el resultado de forma reducida
+  def %(o)
+    Racional.new(num%denom, o.num%o.denom)
+  end
+
+  # Comparación de mayor, mayor igual, menor, menor igual
+  def <=>(o)
+    return nil unless o.instance_of? Racional
+    (num.to_f / denom) <=> (o.num.to_f / o.denom)
+  end
+
+end
+
+

data/modai_prct10.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'modai_prct10/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "modai_prct10"
+  spec.version       = ModaiPrct10::VERSION
+  spec.authors       = ["Dailos Herrera Bencomo y Mohammed Mahrach"]
+  spec.email         = ["alu0100036862@etsii.ull.es"]
+  spec.description   = %q{Simply generates modai_prct10 ipsum text.}
+  spec.summary       = %q{modai_prct10 ipsum generator}
+  spec.homepage      = ""
+  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"
+end

data/spec/modai_prct10_spec.rb

@@ -0,0 +1,218 @@
+require 'spec_helper'
+require 'modai_prct10'
+include ModaiPrct10
+
+describe ModaiPrct10 do
+
+        before :each do
+
+		# Matrices DENSAS
+                matA = [[1,2],[3,4]]
+                matB = [[221,2],[3,4]]
+
+                matA_R = [[Racional.new(1,1),Racional.new(4,2)],[Racional.new(9,3),Racional.new(16,4)]]
+                matB_R = [[Racional.new(442,2),Racional.new(4,2)],[Racional.new(9,3),Racional.new(16,4)]]
+
+                @matrizA = MatrizDensa.new(matA)
+                @matrizB = MatrizDensa.new(matB)
+
+                @matrizA_R = MatrizDensa.new(matA_R)
+                @matrizB_R = MatrizDensa.new(matB_R)
+				
+		# Matrices DISPERSAS
+                matC = [nil, {1 => 4}] # [[0,0],[0,4]]
+                matD = [{0 => 5}, nil] # [[5,0],[0,0]]
+
+                matC_R = [nil, {1 => Racional.new(4,1)}] # [[Racional.new(0,1),Racional.new(0,1)],[Racional.new(0,1),Racional.new(4,1)]]
+                matD_R = [{0 => Racional.new(5,1)}, nil] # [[Racional.new(5,1),Racional.new(0,1)],[Racional.new(0,1),Racional.new(0,1)]]
+
+                @matrizC = MatrizDispersa.new(matC)
+                @matrizC = MatrizDispersa.new(matD)
+
+                @matrizC_R = MatrizDispersa.new(matC_R)
+                @matrizC_R = MatrizDispersa.new(matD_R)				
+
+        end
+
+        context 'comprobar los accessors (DENSA)' do
+
+                it "Se debe invocar al metodo matriz() para obtener la matriz (DENSA)" do
+                        @matrizA.respond_to?("matriz").should == true
+                end
+                
+                it "Se debe invocar al metodo filas() para obtener el numero de filas (DENSA)" do
+                        @matrizA.respond_to?("filas").should == true
+                end
+
+                it "Se debe invocar al metodo columnas() para obtener el numero de columnas (DENSA)" do
+                        @matrizA.respond_to?("columnas").should == true
+                end
+
+                it "Se debe invocar al metodo matriz() para obtener la matriz de racionales (DENSA)" do
+                        @matrizA_R.respond_to?("matriz").should == true
+                end
+                
+                it "Se debe invocar al metodo filas() para obtener el numero de filas de matriz de racionales (DENSA)" do
+                        @matrizA_R.respond_to?("filas").should == true
+                end
+
+                it "Se debe invocar al metodo columnas() para obtener el numero de columnas de matriz de racionales (DENSA)" do
+                        @matrizA_R.respond_to?("columnas").should == true
+                end
+
+        end
+
+        context 'Comprobar metodos de conversion (DENSA)' do
+
+                it "Se debe mostrar la matriz (DENSA)" do
+                        @matrizA.to_s.should == MatrizDensa.new([[1,2],[3,4]]).to_s
+                end
+
+                it "Se debe convertir a punto flotantes (DENSA)" do
+                        @matrizA.to_f.to_s.should == MatrizDensa.new([[1.0,2.0],[3.0,4.0]]).to_s
+                end
+
+                it "Se debe mostrar la matriz de racionales (DENSA)" do
+                        @matrizA_R.to_s.should == MatrizDensa.new([[Racional.new(1,1),Racional.new(4,2)],[Racional.new(9,3),Racional.new(16,4)]]).to_s
+                end
+
+        end
+
+        context 'Comprobar las operaciones entre matrices (DENSA)' do
+
+                it "Se debe poder sumar dos matrices (DENSA)" do
+                        (@matrizA + @matrizB).to_s.should == MatrizDensa.new([[222,4], [6,8]]).to_s
+                end
+          
+                it "Se debe poder restar dos matrices (DENSA)" do
+                        (@matrizA - @matrizB).to_s.should == MatrizDensa.new([[-220,0], [0,0]]).to_s
+                end
+                
+                it "Se debe poder multiplicar dos matrices (DENSA)" do
+                        (@matrizA * @matrizB).to_s.should == MatrizDensa.new([[227,10], [675,22]]).to_s
+                end
+          
+                it "Se debe poder sumar dos matrices de racionales (DENSA)" do
+                        (@matrizA_R + @matrizB_R).to_s.should == MatrizDensa.new([[Racional.new(222,1),Racional.new(4,1)],[Racional.new(6,1),Racional.new(8,1)]]).to_s
+                end
+
+                it "Se debe poder restar dos matrices de racionales (DENSA)" do
+                        (@matrizA_R - @matrizB_R).to_s.should == MatrizDensa.new([[Racional.new(-220,1),Racional.new(0,1)],[Racional.new(0,1),Racional.new(0,1)]]).to_s
+                end
+
+        end
+        
+        context 'Comprobar las operaciones de la propia matriz (DENSA)' do
+
+                it "Se debe mostrar el max de la matriz (DENSA)" do
+                        @matrizA.max == 4.0
+                end
+          
+                it "Se debe mostrar el min de la matriz (DENSA)" do
+                        @matrizA.min == 1.0
+                end
+                
+                it "Se debe mostrar el max de la matriz de racionales (DENSA)" do
+                        @matrizA_R.max == Racional.new(1,1)
+                end
+          
+                it "Se debe mostrar el min de la matriz de racionales (DENSA)" do
+                        @matrizA_R.min == Racional.new(16,4)
+                end
+
+        end
+	
+        context 'comprobar los accessors (DISPERSA)' do
+
+                it "Se debe invocar al metodo matriz() para obtener la matriz (DISPERSA)" do
+                        @matrizC.respond_to?("matriz").should == true
+                end
+                
+                it "Se debe invocar al metodo filas() para obtener el numero de filas (DISPERSA)" do
+                        @matrizC.respond_to?("filas").should == true
+                end
+
+                it "Se debe invocar al metodo columnas() para obtener el numero de columnas (DISPERSA)" do
+                        @matrizC.respond_to?("columnas").should == true
+                end
+
+                it "Se debe invocar al metodo matriz() para obtener la matriz de racionales (DISPERSA)" do
+                        @matrizC_R.respond_to?("matriz").should == true
+                end
+                
+                it "Se debe invocar al metodo filas() para obtener el numero de filas de matriz de racionales (DISPERSA)" do
+                        @matrizC_R.respond_to?("filas").should == true
+                end
+
+                it "Se debe invocar al metodo columnas() para obtener el numero de columnas de matriz de racionales (DISPERSA)" do
+                        @matrizC_R.respond_to?("columnas").should == true
+                end
+
+        end
+
+        context 'Comprobar metodos de conversion (DISPERSA)' do
+
+                it "Se debe mostrar la matriz (DISPERSA)" do
+                        @matrizC.to_s.should == MatrizDispersa.new([nil, {1 => 4}]).to_s
+                end
+
+                it "Se debe convertir a punto flotantes (DISPERSA)" do
+                        @matrizC.to_f.to_s.should == MatrizDispersa.new([nil, {1 => 4.0}]).to_s
+                end
+
+                it "Se debe mostrar la matriz de racionales (DISPERSA)" do
+                        @matrizC_R.to_s.should == MatrizDispersa.new([nil, {1 => Racional.new(4,1)}]).to_s
+                end
+
+        end
+
+        context 'Comprobar las operaciones entre matrices (DISPERSA)' do
+
+
+                it "Se debe poder sumar dos matrices (DISPERSA)" do
+                        (@matrizC + @matrizC).to_s.should == MatrizDispersa.new([{0 => 5}, {1 => 4}]).to_s
+                end
+          
+                it "Se debe poder restar dos matrices (DISPERSA)" do
+                        (@matrizC - @matrizC).to_s.should == MatrizDispersa.new([{0 => -5}, {1 => 4}]).to_s
+                end
+
+=begin                
+                it "Se debe poder multiplicar dos matrices (DISPERSA)" do
+                        (@matrizC * @matrizC).to_s.should == MatrizDispersa.new([[227,10], [675,22]]).to_s
+                end
+
+=end         
+                it "Se debe poder sumar dos matrices de racionales (DISPERSA)" do
+                        (@matrizC_R + @matrizC_R).to_s.should == MatrizDispersa.new([{0 => Racional.new(5,1)}, {1 => Racional.new(4,1)}]).to_s
+                end
+
+                it "Se debe poder restar dos matrices de racionales (DISPERSA)" do
+                        (@matrizC_R - @matrizC_R).to_s.should == MatrizDispersa.new([{0 => Racional.new(-5,1)}, {1 => Racional.new(4,1)}]).to_s
+                end
+   
+        end
+        
+        context 'Comprobar las operaciones de la propia matriz (DISPERSA)' do
+
+                it "Se debe mostrar el max de la matriz (DISPERSA)" do
+                        @matrizC.max == 4
+                end
+          
+                it "Se debe mostrar el min de la matriz (DISPERSA)" do
+                        @matrizC.min == 0
+                end
+                
+                it "Se debe mostrar el max de la matriz de racionales (DISPERSA)" do
+                        @matrizC_R.max == Racional.new(4,1)
+                end
+          
+                it "Se debe mostrar el min de la matriz de racionales (DISPERSA)" do
+                        @matrizC_R.min == Racional.new(0,1)
+                end
+
+        end
+
+end
+
+

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+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
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: modai_prct10
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Dailos Herrera Bencomo y Mohammed Mahrach
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-22 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'
+description: Simply generates modai_prct10 ipsum text.
+email:
+- alu0100036862@etsii.ull.es
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/gcd.rb
+- lib/modai_prct10.rb
+- lib/modai_prct10/version.rb
+- lib/racional.rb
+- modai_prct10.gemspec
+- spec/modai_prct10_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+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: modai_prct10 ipsum generator
+test_files:
+- spec/modai_prct10_spec.rb
+- spec/spec_helper.rb
+has_rdoc: