modai_prct12 0.0.22

data/lib/modai_prct12/matrizDispersa.rb

@@ -0,0 +1,280 @@
+#= La clase de Matriz dispersa,
+#== Una matriz se considerará dispersa si tiene más de un 60% de ceros.
+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)
+
+		i = 0
+                (matriz.size - 1).times do
+                      
+			#=== 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
+
+			i += 1
+
+                end
+                MatrizDispersa.new(suma)
+
+	end
+
+	#== Resta de matrices
+	def -(o)
+
+                resta = Array.new(matriz.size - 1)
+
+		i = 0
+                (matriz.size - 1).times do
+
+                        #=== 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
+
+			i += 1
+
+                end
+                MatrizDispersa.new(resta)
+
+	end
+
+
+	#== Producto de matrices
+	def *(o)
+
+                prod = Array.new(matriz.size - 1)
+
+		i = 0
+                (0...(matriz.size)).inject {
+                      
+			#=== creamos el hash si hay filas en el multiplicador
+			if (o.matriz[i] != nil)
+				
+				prod[i] = Hash.new()
+				#=== cogemos o como base para el producto
+				prod[i] = o.matriz[i]
+
+				for j in 0...matriz.size
+
+					if o.matriz[i].has_key?(j) 
+
+						if matriz[j].has_key?(i)
+							prod[i][j] = prod[i][j] + (prod[i][j] * matriz[j][i])
+						else
+							prod[i].delete(j)
+						end
+
+					else
+						prod[i].delete(j)
+					end
+				
+				end
+
+			end
+
+			i += 1
+
+		}
+                MatrizDispersa.new(prod)
+
+	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
+
+	#== Pasamos de Dispersa a Densa
+	def to_densa
+
+		densa = Array.new(matriz.size - 1)
+                for i in 0...matriz.size
+                        densa[i] = Array.new(matriz[i].size - 1)
+			for j in 0...matriz[i].size
+				densa[i][j] = 0.to_f
+				if matriz[i] != nil
+                                	matriz[i].each do |key, value|
+                                        	if key = j
+                                               		densa[i][j] = matriz[i][key].to_f
+                                        	end
+					end
+                                end
+                        end
+		end
+
+                MatrizDensa.new(densa)
+
+	end
+
+	#== El metodo coerce para onvierte el valor especificado en el tipo especificado.
+	def coerce(other)
+		return self, other.to_densa
+ 	end
+
+end

data/lib/modai_prct12/racional.rb

@@ -0,0 +1,121 @@
+# racional.rb
+require "./lib/modai_prct12/gcd.rb"
+
+#=Implemente una clase Ruby para representar los números racionales.
+#===Un número racional es un número con un numerador y un denominador de la forma. a/b
+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)
+    
+    if o.is_a? Integer
+      o = Racional.new(o,1)
+    end
+    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)
+
+    if o.is_a? Integer
+      o = Racional.new(o,1)
+    end
+    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)
+
+    if o.is_a? Integer
+      o = Racional.new(o,1)
+    end
+    Racional.new(num*o.num,denom*o.denom)
+
+  end
+
+  #== Divide dos fracciones con / y dar el resultado de forma reducida
+  def /(o)
+
+    if o.is_a? Integer
+      o = Racional.new(o,1)
+    end
+    Racional.new(num*o.denom,denom*o.num)
+
+  end
+
+  #== Calcula el resto dos fracciones con % y dar el resultado de forma reducida
+  def %(o)
+
+    if o.is_a? Integer
+      o = Racional.new(o,1)
+    end
+    Racional.new(num%denom, o.num%o.denom)
+
+  end
+
+  #== GERRA DE LAS GALAXIAS : un metodo que proporciona la 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
+
+  #== El metodo coerce para onvierte el valor especificado en el tipo especificado.
+  def coerce(other)
+    return Racional.new(other,1), self
+  end
+
+end
+
+

data/lib/modai_prct12/version.rb

@@ -0,0 +1,3 @@
+module ModaiPrct12
+  VERSION = "0.0.22"
+end

data/modai_prct12.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_prct12/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "modai_prct12"
+  spec.version       = ModaiPrct12::VERSION
+  spec.authors       = ["Dailos Herrera Bencomo y Mohammed Mahrach"]
+  spec.email         = ["alu0100036862@etsii.ull.es"]
+  spec.description   = %q{Simply generates modai_prct12 ipsum text.}
+  spec.summary       = %q{modai_prct12 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_prct12_spec.rb

@@ -0,0 +1,251 @@
+require 'spec_helper'
+require 'modai_prct12'
+include ModaiPrct12
+
+describe ModaiPrct12 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]]
+                matE = [{0 => 1}, {1 => 2}, {2 => 3}, {3 => 4}] # [[1,0,0,0],[0,2,0,0],[0,0,3,0],[0,0,0,4]]
+                matF = [{1 => 5, 3 => 4}, {1 => 2}, {0 => 3}, {2 => 1}] # [[0,5,0,4],[0,2,0,0],[3,0,0,0],[0,0,1,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)
+                @matrizD = MatrizDispersa.new(matD)
+                @matrizE = MatrizDispersa.new(matE)
+                @matrizF = MatrizDispersa.new(matF)
+
+                @matrizC_R = MatrizDispersa.new(matC_R)
+                @matrizD_R = MatrizDispersa.new(matD_R)
+
+                #== Matrices creadas en horas de practicas
+                matA_P_DEN = [[3.4],[5.6]]
+                matB_P_DIS = [nil,{1 => 1}]
+                matB_R_DIS = [nil,{1 => Racional.new(1,2)}]
+
+                @matrizA_P_DEN = MatrizDensa.new(matA_P_DEN)
+                @matrizB_P_DIS = MatrizDispersa.new(matB_P_DIS)
+                @matrizB_R_DIS = MatrizDispersa.new(matB_R_DIS)
+
+		#== Matriz creada en hora de practica PRACT11
+                matPRACT = [[1,2,9],[7,8,4]]
+		@matrizPRACT = MatrizDensa.new(matPRACT)
+
+        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
+          
+                it "Se debe poder multiplicar dos matrices (DISPERSA)" do
+                        (@matrizE * @matrizF).to_s.should == MatrizDispersa.new([{1 => 5, 3 => 4}, {1 => 4}, {0 => 9}, {2 => 4}]).to_s
+                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
+
+        context 'Comprobar modificacion en la hora de practica' do
+
+                it "Se debe sumar matriz DENSA con DISPERSA" do
+                        (@matrizA_P_DEN + @matrizB_P_DIS).to_s.should == MatrizDensa.new([[3,4], [5,7]]).to_s
+                end
+
+                it "Se debe sumar matriz DENSA con DISPERSA con racionales" do
+                        (@matrizA_P_DEN / @matrizB_R_DIS).to_s.should == MatrizDensa.new([[3,4], [5,Racional.new(13,2)]]).to_s
+                end
+
+        end
+
+        context 'Comprobar modificacion en la hora de practica PRACT11' do
+
+                it "Se debe devolver la posicion i,j del primer elemento que sea su cuadrado > 6" do
+                        (@matrizPRACT).encontrar{ |e| ( e * e) > 6 }.should == "[[0,2][1,0][1,1][1,2]]"
+                end
+
+	end
+
+end