lpp_t_04_matrix 0.0.1

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/.rspec

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

data/.travis.yml

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

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,33 @@
+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 :test do
+  watch('tc_lpp_t_04_matrix.rb')
+  watch(%r{^test/.+_test\.rb$})
+  watch('test/test_helper.rb')  { 'test' }
+
+  # Non-rails
+  watch(%r{^lib/(.+)\.rb$}) { |m| "test/#{m[1]}_test.rb" }
+
+  # Rails 4
+  # watch(%r{^app/(.+)\.rb})                               { |m| "test/#{m[1]}_test.rb" }
+  # watch(%r{^app/controllers/application_controller\.rb}) { 'test/controllers' }
+  # watch(%r{^app/controllers/(.+)_controller\.rb})        { |m| "test/integration/#{m[1]}_test.rb" }
+  # watch(%r{^app/views/(.+)_mailer/.+})                   { |m| "test/mailers/#{m[1]}_mailer_test.rb" }
+  # watch(%r{^lib/(.+)\.rb})                               { |m| "test/lib/#{m[1]}_test.rb" }
+
+  # Rails < 4
+  # watch(%r{^app/models/(.+)\.rb$})                   { |m| "test/unit/#{m[1]}_test.rb" }
+  # watch(%r{^app/controllers/(.+)\.rb$})              { |m| "test/functional/#{m[1]}_test.rb" }
+  # watch(%r{^app/views/(.+)/.+\.erb$})                { |m| "test/functional/#{m[1]}_controller_test.rb" }
+  # watch(%r{^app/views/.+$})                          { 'test/integration' }
+  # watch('app/controllers/application_controller.rb') { ['test/functional', 'test/integration'] }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 EliezerCruzSuarez
+
+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,83 @@
+# LppT04Matrix
+
+:~/LPP/prct09/tree  
+.  
+├── Gemfile  
+├── Gemfile.lock  
+├── Guardfile  
+├── lib  
+│   ├── lpp_t_04_matrix  
+│   │   └── version.rb  
+│   └── lpp_t_04_matrix.rb  
+├── LICENSE.txt  
+├── lpp_t_04_matrix.gemspec  
+├── Rakefile  
+├── README.md  
+└── spec  
+    ├── lpp_t_04_matrix_spec.rb  
+    └── spec_helper.rb    
+
+## Descripción de los objetivos de la práctica
+
+Para realización de esta práctica se ha creado una jerarquía de clases.Teniendo en cuenta que tenemos una clase abstracta de nombre Matriz, y de la cual han heredado las otras dos clases que definen el tipo de objetos que tenemos, MatrizDensa y MatrizDispersa, se han implementado los métodos para operar con ambos tipos de matrices sin importar que objeto sea. Además se ha incluido el tratamiento de fracciones desarrollado en la práctica anterior con la idea de que la matriz sea capaz de operar con elementos del tipo Franction. Los métodos implemnetados son:  
+    Suma, Resta, Multiplicación y Traspuesta.    
+***
+
+
+## Jerarquía de clases para la creación las matrices:
+
+class Matriz<pre>
+    @filas
+    @columnas
+</pre>
+end  
+
+Class MatrizDensa < Matriz
+<pre>   #Se definen los métodos que trabajan con matrices densas
+</pre>
+end  
+
+Class MatrizDispersa < Matriz
+<pre>    #Se definen los métodos que trabajan con matrices dispersas
+</pre>
+end  
+  
+##  Trabajo con matrices  
+
+Un ejemplo de como construiremos una matriz densa es:    
+m3 = MatrizDensa.new(2,2,[[7,10],[15,22]])  
+Deberemos llamar a la clase MatrizDensa.  
+Los dos primero parametros son el número de filas y el número de columnas.  
+A continuación se le pasa un arrary que contiene todos los elementos de la matriz.  
+
+Un ejemplo de como construiremos una matriz dispersa es:    
+m2 = MatrizDispersa.new(2, 2, {0 => {0 => 1, 1 => 2}, 1 => {0 => 3, 1 => 4}})  
+Se llama a la clase MatrizDispersa.  
+Los dos primero parametros son el número de filas y el número de columnas.  
+A continuación se le pasa un hash que contiene los elementos no nulos de la matriz del tipo:  
+[FILA] => {[COLUMNA] => [VALOR], [COLUMNA] => [VALOR], ...}, ...  
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'lpp_t_04_matrix'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install lpp_t_04_matrix
+
+## Usage
+
+
+## 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,4 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+task :default => :spec

data/lib/lpp_t_04_matrix/version.rb

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

data/lib/lpp_t_04_matrix.rb

@@ -0,0 +1,375 @@
+require "lpp_t_04_matrix/version"
+
+module LppT04Matrix
+	class Matriz
+	  	attr_accessor :filas, :columnas
+	  	def initialize (filas, columnas)
+	  		@filas = filas
+	  		@columnas = columnas
+	  	end
+	end
+
+	class MatrizDensa < Matriz
+		attr_accessor :elemento
+		def initialize (filas, columnas, elemento)
+			super(filas, columnas)
+			@elemento = elemento
+		end
+
+		def [](i)
+			@elemento[i]
+ 		end
+
+ 		def indice(i,j)
+ 			@elemento[i][j]
+ 		end
+
+		def to_s
+			imprimir = ""
+			@filas.times do |i|
+				@columnas.times do |j|
+					imprimir << "#{elemento[i][j]} "
+				end
+				imprimir << "\n"
+			end
+			imprimir
+		end
+
+		def +(other)
+			raise ArgumentError, "La longitud de las matrices no coincide." unless @filas == other.filas && @columnas == other.columnas
+			elemento = Array.new
+			@filas.times do |i|
+				elemento_fila = Array.new
+				@columnas.times do |j|
+					elemento_fila << @elemento[i][j].+(other.elemento[i][j])
+				end
+				elemento << elemento_fila
+			end
+			MatrizDensa.new(@filas, @columnas,elemento)
+		end
+
+		def -(other)
+			raise ArgumentError, "La longitud de las matrices no coincide." unless @filas == other.filas && @columnas == other.columnas
+			elemento = Array.new
+			@filas.times do |i|
+				elemento_fila = Array.new
+				@columnas.times do |j|
+					elemento_fila << @elemento[i][j] - other.elemento[i][j]
+				end
+				elemento << elemento_fila
+			end
+			MatrizDensa.new(@filas, @columnas,elemento)
+		end
+
+		def *(other)
+			raise ArgumentError, "La longitud de las matrices no coincide." unless @columnas == other.filas
+			elemento = Array.new
+			acumulado = 0
+			@filas.times do |i|
+				elemento_fila = Array.new
+				other.columnas.times do |j|
+					acumulado = 0
+					@columnas.times do |k|
+						suma =  @elemento[i][k] * other.indice(k,j)
+						acumulado = suma + acumulado
+					end
+					elemento_fila << acumulado
+				end
+				elemento << elemento_fila
+			end
+			MatrizDensa.new(@filas, other.columnas, elemento)
+		end
+
+		def traspuesta
+			elemento = Array.new
+			@columnas.times do |i|
+				elemento_fila = Array.new
+				@filas.times do |j|
+					elemento_fila << @elemento[j][i]
+				end
+				elemento << elemento_fila
+			end
+			MatrizDensa.new(@columnas, @filas, elemento)
+		end
+		def maximo
+			aux = @elemento[0][0]
+			@columnas.times do |i|
+				@filas.times do |j|
+					aux = @elemento[i][j] if @elemento[i][j] > aux
+				end
+			end
+			aux
+		end
+		def minimo
+			aux = @elemento[0][0]
+			@columnas.times do |i|
+				@filas.times do |j|
+					aux = @elemento[i][j] if @elemento[i][j] < aux
+				end
+			end
+			aux
+		end
+	end
+
+
+	class MatrizDispersa < Matriz
+		attr_accessor :elemento
+		def initialize (filas, columnas, elemento)
+			super(filas, columnas)
+    		@elemento = elemento
+		end
+
+		def [](i)
+			@elemento[i]
+ 		end
+ 		def indice(i,j)
+ 			elemento = @elemento.fetch(i,0)
+ 			if elemento!= 0
+ 				elemento.fetch(j,0)
+ 			else
+ 				0
+ 			end
+ 		end
+
+		def to_s
+			@elemento
+		end
+		
+		def +(other)
+			raise ArgumentError, "La longitud de las matrices no coincide." unless @filas == other.filas && @columnas == other.columnas
+			case other
+			when MatrizDensa
+				other.+(self)
+			when MatrizDispersa
+				elemento = @elemento.merge(other.elemento){|key, oldval, newval| oldval.merge(newval){|key2, oldval2, newval2|oldval2 + newval2}}
+				MatrizDispersa.new(@filas, other.columnas, elemento)
+			else
+				raise TypeError.new("Cannot coerce #{other.inspect} to a Matriz")
+			end
+		end
+
+		def -(other)
+			raise ArgumentError, "La longitud de las matrices no coincide." unless @filas == other.filas && @columnas == other.columnas
+			case other
+			when MatrizDensa
+				other.-(self)
+			when MatrizDispersa
+				elemento = @elemento.merge(other.elemento){|key, oldval, newval| oldval.merge(newval){|key2, oldval2, newval2|oldval2 - newval2}}
+				MatrizDispersa.new(@filas, other.columnas, elemento)
+			else
+				raise TypeError.new("Cannot coerce #{other.inspect} to a Matriz")
+			end
+		end
+
+		def *(other)
+			raise ArgumentError, "La longitud de las matrices no coincide." unless @columnas == other.filas
+			case other
+			when MatrizDensa
+				other.*(self)
+			when MatrizDispersa
+				other = other.traspuesta
+				elemento = Hash.new(Hash.new())
+				@elemento.each {
+					|key, value|
+					other.elemento.each {
+						|key1, value1|
+						acumulado = 0
+							value.each {							
+								|key2, value2|
+								if(value1[key2] != nil)
+									acumulado +=  value2 * value1[key2]
+								end
+							}
+						if(acumulado != 0)
+							hash = { key1 => acumulado}
+							hash2 = {key => hash}
+							elemento.merge!(hash2){|key3, oldval, newval| oldval.merge!(newval)}				
+						end
+					}
+				}
+				elemento
+				MatrizDispersa.new(@filas, other.columnas, elemento)
+			else
+				raise TypeError.new("Cannot coerce #{other.inspect} to a Matriz")
+			end		
+		end
+
+		def traspuesta
+			elemento = Hash.new(Hash.new())
+			@elemento.each {
+				|key, value| value.each {
+					|key2, value2|  hash = { key => value2}
+					hash2 = {key2 => hash}
+					elemento.merge!(hash2){|key3, oldval, newval| oldval.merge!(newval)}
+				}
+			}
+			elemento
+			MatrizDispersa.new(@filas, @columnas, elemento)
+		end
+		def maximo
+			aux = @elemento.keys
+			aux1 = aux[0]
+			aux2 = @elemento[aux1].values
+			mayor = aux2[0]
+			@elemento.each {
+				|key, value| value.each {
+					|key2, value2|
+					mayor = indice(key,key2) if indice(key,key2) > mayor
+				}
+			}
+			mayor
+		end
+		def minimo
+			aux = @elemento.keys
+			aux1 = aux[0]
+			aux2 = @elemento[aux1].values
+			mayor = aux2[0]
+			@elemento.each {
+				|key, value| value.each {
+					|key2, value2|
+					mayor = indice(key,key2) if indice(key,key2) < mayor
+				}
+			}
+			mayor
+		end
+	end
+end
+
+class Frac
+	attr_reader :numerador, :denominador # Se definen set y get para acceder a las variables de la clase.
+	include Comparable # Se incluye el modulo de nombre "comparable" utilizado para el operador <=>.
+	
+    def initialize(numerador, denominador) # Se define el constructor.
+		mcd = gcd(numerador,denominador)
+		@numerador , @denominador = numerador/mcd, denominador/mcd
+	end
+	
+    def num() # Devuelve el numerador.
+		@numerador
+	end
+	
+    def denom() # Devuelve el denominador.
+		@denominador
+	end
+	
+    def to_s
+        if @denominador == 1 #Si el denominador es 1, solo se imprimer el numerador
+                "#{@numerador}"
+        elsif @denominador == -1 #En el caso de que b=-1 y a>0 ó a=-1
+                if @numerador>0 || @numerador==-1
+                        "#{-@numerador}"
+                else #Si b=-1 y a es menor que cero, imprime el valor de a
+                        "#{@numerador}"
+                end
+        elsif (@numerador>0 && @denominador>0 && @denominador!=1) #Caso nomal, a y b son mayores que cero, imprime a/b
+                "#{@numerador}/#{@denominador}"
+        elsif (@numerador>0 && @denominador<0 && @denominador!=-1) # b es menor que cero, se le cambia el signo a todo para que se imprima: -a/b
+                "#{-@numerador}/#{-@denominador}"
+        elsif (@numerador<0 && @denominador<0 && @denominador!=-1) # a y b son menor que cero, se le cambia el signo a todo para que imprima a/b
+                "#{-@numerador}/#{-@denominador}"
+        elsif (@numerador<0 && @denominador>0 && @denominador!=1) # a es menor que cero, se imprime igual: -a/b
+                "#{@numerador}/#{@denominador}"
+        end        
+    end
+	
+    def to_f() # Imprime el resultado de la fraccion como un float.
+		@numerador.to_f/@denominador
+	end
+	
+    def <=>(other) # Se define el operador <=> para el modulo comparable.
+    	@numerador.to_f/@denominador <=> other.numerador.to_f/other.denominador
+    end
+    
+    def abs() # Se calcula el valor absoluto de una fraccion.
+    	if (@numerador > 0 && @denominador > 0)
+    		Frac.new(@numerador, @denominador).to_s
+    	elsif (@numerador > 0 && @denominador < 0)
+    		Frac.new(@numerador, -1 * @denominador).to_s
+    	elsif (@numerador < 0 && @denominador > 0)
+    		Frac.new(-1 * @numerador, @denominador).to_s
+    	else (@numerador < 0 && @denominador < 0)
+    		Frac.new(-1 * @numerador,-1 * @denominador).to_s
+    	end  						
+    end
+    
+    def reciprocal() # Calcula el reciproco de una fraccion.
+    	Frac.new(@denominador, @numerador)
+    end
+
+    def +(other) # Calcula la suma de dos fracciones.
+        if other.class == Frac
+            Frac.new(@numerador*other.denominador + other.numerador*@denominador , @denominador*other.denominador)
+        elsif other.class == Fixnum
+            Frac.new(@numerador + other*@denominador , @denominador)
+        end
+                
+    end
+
+    def -(other) # Calcula la resta de dos fracciones.
+        if (other.class == Frac)
+            Frac.new(@numerador*other.denominador - other.numerador*@denominador , @denominador*other.denominador)
+        else
+        	Frac.new(@numerador - other*@denominador , @denominador)
+        end
+    end
+
+    def *(other) # Calcula la multiplicacion de dos fracciones.
+    	if other.class == Frac
+            Frac.new(@numerador * other.numerador, @denominador * other.denominador)
+        elsif other.class == Fixnum
+            Frac.new(@numerador * other, @denominador)
+        end
+    end
+
+    def /(other) # Calcula la division de dos fracciones.
+        Frac.new(@numerador * other.denominador, @denominador * other.numerador)
+    end
+
+    def %(other) # Calcula el resto al dividir dos fracciones (modulo)
+        result = self./(other)
+        result = (result.numerador%result.denominador).to_i
+    end
+
+    def coerce(other)
+    	[self,other]
+    end
+end
+
+def gcd(u, v)
+  u, v = u.abs, v.abs
+  while v != 0
+    u, v = v, u % v
+  end
+  u
+end
+
+if __FILE__ == $0
+# Trabajo con la clase:
+include LppT04Matrix
+
+m1 = MatrizDensa.new(2,2,[[1,2],[3,4]])
+m2 = MatrizDispersa.new(2, 2, {0 => {0 => 1, 1 => 2}, 1 => {0 => 3, 1 => 4}})
+m3 = MatrizDensa.new(2,2,[[7,10],[15,22]])
+m4 = MatrizDispersa.new(2, 2, {0 => {0 => Frac.new(1,2), 1 => Frac.new(1,2)}, 1 => {0 => Frac.new(1,2), 1 => Frac.new(1,2)}})
+a = Frac.new(1,2)
+b = Frac.new(2,2)
+c = Frac.new(3,2)
+d = Frac.new(4,2)
+e = Frac.new(3,2)
+f = Frac.new(9,2)
+g = Frac.new(3,1)
+h = Frac.new(6,1)
+m9 = MatrizDensa.new(2,2,[[a,b],[c,d]])
+m10 = MatrizDensa.new(2,2,[[e,3],[f,6]])
+puts m9-(m1)
+puts
+puts m1-(m9)
+puts 
+puts m4.to_s
+puts m4*m1
+puts m1*m4
+puts m1*m1
+puts (m2*m4).to_s
+puts (m4*m2).to_s
+puts m1
+end

data/lpp_t_04_matrix.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lpp_t_04_matrix/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "lpp_t_04_matrix"
+  spec.version       = LppT04Matrix::VERSION
+  spec.authors       = ["EliezerCruzSuarez"]
+  spec.email         = ["alu0100611298@ull.edu.es"]
+  spec.description   = %q{Para realizacion de esta practica se ha creado una jerarquia de clases. 
+    Teniendo en cuenta que tenemos una clase abstracta de nombre Matriz, y de la cual han heredado las
+    otras dos clases que definen el tipo de objetos que tenemos, MatrizDensa y MatrizDispersa, se han
+    implementado los metodos para operar con ambos tipos de matrices, sin importar que objeto sea.
+    Además se ha incluido el tratamiento de fracciones desarrollado en la practica anterior con la idea
+    de que la matriz sea capaz de operar con elementos del tipo Franction. Los metodos implemnetados son: 
+    suma, resta, multiplicacion y traspuesta.}
+  spec.summary       = %q{Operacion con matrices densas y dispersas}
+  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"
+  spec.add_development_dependency 'rspec', '~> 2.9'
+end

data/spec/lpp_t_04_matrix_spec.rb

@@ -0,0 +1,256 @@
+require 'spec_helper'
+include  LppT04Matrix
+
+describe LppT04Matrix do
+
+	describe Matriz do
+		before :all do
+			@m1 = Matriz.new(2,2)
+		end
+		describe "Se comprueba el numero de:" do
+			it "filas de la matriz" do
+				@m1.filas.should eq(2)  
+			end
+			it "columnas de la matriz" do
+				@m1.columnas.should eq(2)  
+			end
+		end
+	end
+
+	describe MatrizDensa do
+		before :all do
+			@m1 = MatrizDensa.new(2,2,[[1,2],[3,4]])
+			@m2 = MatrizDensa.new(2,2,[[2,4],[6,8]])
+			@m3 = MatrizDensa.new(2,2,[[7,10],[15,22]])
+			@m4 = MatrizDensa.new(2,2,[[1,3],[2,4]])
+			a = Frac.new(1,2)
+			b = Frac.new(2,2)
+			c = Frac.new(3,2)
+			d = Frac.new(4,2)
+			@m9 = MatrizDensa.new(2,2,[[a,b],[c,d]])
+			@m10 = MatrizDensa.new(2,2,[[0,0],[0,0]])
+			@m11 = MatrizDensa.new(2,2,[[a,c],[b,d]])
+			e = Frac.new(7,4)
+			f = Frac.new(10,4)
+			g = Frac.new(15,4)
+			h = Frac.new(22,4)
+			@m12 = MatrizDensa.new(2,2,[[e,f],[g,h]])
+			i = Frac.new(3,2)
+			j = Frac.new(9,2)
+			k = Frac.new(-1,2)
+			l = Frac.new(-3,2)
+			@m13 = MatrizDensa.new(2,2,[[i,3],[j,6]])
+			@m14 = MatrizDensa.new(2,2,[[k,-1],[l,-2]])
+
+			@m15 = MatrizDensa.new(2,2,[[Frac.new(7,2),5],[Frac.new(15,2),11]])
+
+		end
+		describe "Acceder al subindice;" do
+			it "Para acceder al [0,0]" do
+				@m1.elemento[0][0].should eq(1)
+			end
+			it "Para acceder al [0,0]" do
+				@m1.elemento[0][1].should eq(2)
+			end
+			it "Para acceder al [0,0]" do
+				@m1.elemento[1][0].should eq(3)
+			end
+			it "Para acceder al [0,0]" do
+				@m1.elemento[1][1].should eq(4)
+			end
+		end
+
+		describe "Imprimir la matriz" do
+			it "del orden 2x2" do
+				@m1.to_s.should eq("1 2 \n3 4 \n")
+			end
+		end
+		describe "Suma de dos matrices" do
+			it "del orden mxn" do
+				@m1.+(@m1).to_s.should eq(@m2.to_s)
+			end
+		end
+		describe "Suma de matrices de fracciones y enteros" do
+			it "del orden mxn" do
+				@m9.+(@m1).to_s.should eq(@m13.to_s)
+			end
+		end
+		describe "Suma de matrices de enteros y fracciones" do
+			it "del orden mxn" do
+				@m1.+(@m9).to_s.should eq(@m13.to_s)
+			end
+		end
+		describe "Resta de dos matrices" do
+			it "del orden mxn" do
+				@m2.-(@m1).to_s.should eq(@m1.to_s)
+			end
+		end
+		describe "Resta de matrices de fracciones y enteros" do
+			it "del orden mxn" do
+				@m9.-(@m1).to_s.should eq(@m14.to_s)
+			end
+		end
+		describe "Resta de matrices de enteros y fracciones" do
+			it "del orden mxn" do
+				@m1.-(@m9).to_s.should eq(@m14.to_s)
+			end
+		end
+		describe "Matriz traspuesta " do
+			it "del orden nxn." do
+				@m1.traspuesta.to_s.should eq(@m4.to_s)
+			end
+		end
+
+		describe "Multiplicacion de matrices del orden axn x nxb" do
+			it "del orden 2x2 x 2x2" do
+				@m1.*(@m1).to_s.should eq(@m3.to_s)
+			end
+		end
+		describe "Multiplicacion de matrices de fracciones y enteros" do
+			it "del orden mxn" do
+				@m9.*(@m1).to_s.should eq(@m15.to_s)
+			end
+		end
+		describe "Multiplicacion de matrices de enteros y fracciones" do
+			it "del orden mxn" do
+				@m1.*(@m9).to_s.should eq(@m15.to_s)
+			end
+		end
+		describe "Trabajo con fracciones" do
+			it "suma" do
+				@m9.+(@m9).to_s.should eq (@m1.to_s)
+			end
+			it "resta" do
+				@m9.-(@m9).to_s.should eq (@m10.to_s)
+			end
+			it "Multiplicacion" do
+				@m9.*(@m9).to_s.should eq (@m12.to_s)
+			end
+			it "traspuesta" do
+				@m9.traspuesta.to_s.should eq (@m11.to_s)
+			end
+		end
+		describe "Calculo de maximo y minimo" do
+			it "Maximo" do
+				@m1.maximo.should eq (4)
+			end
+			it "Minimo" do
+				@m1.minimo.should eq (1)
+			end
+		end
+	end
+
+	describe MatrizDispersa do
+		before :all do
+			@m1 = MatrizDispersa.new(250, 250, {100 => {10 => 1, 50 => 200}, 200 => {10 => 1, 50 => 200}})
+			@m2 = MatrizDispersa.new(250, 250, {100 => {10 => 2, 50 => 400}, 200 => {10 => 2, 50 => 400}})
+			@m3 = MatrizDispersa.new(2, 2, {1 => {1 => 1, 2 => 2}, 2 => {1 => 3, 2 => 4}})
+			@m4 = MatrizDispersa.new(2, 2, {1 => {1 => 7, 2 => 10}, 2 => {1 => 15, 2 => 22}})
+			@m5 = MatrizDispersa.new(2, 2, {1 => {1 => 1, 2 => 3}, 2 => {1 => 2, 2 => 4}})
+			@m6 = MatrizDispersa.new(3, 2, {2 => {1 => 1}, 3 => { 2 => 4}})
+			@m7 = MatrizDispersa.new(2, 3, {1 => {2 => 6}, 2 => {1 => 7}})
+			@m8 = MatrizDispersa.new(3, 3, {2=>{2=>6}, 3=>{1=>28}})
+			
+		end
+		describe "Acceder al subindice;" do
+			it "Para acceder al [0,0]" do
+				@m1.elemento[100][10].should eq(1)
+			end
+			it "Para acceder al [0,0]" do
+				@m1.elemento[100][50].should eq(200)
+			end
+			it "Para acceder al [0,0]" do
+				@m1.elemento[200][10].should eq(1)
+			end
+			it "Para acceder al [0,0]" do
+				@m1.elemento[200][50].should eq(200)
+			end
+		end
+
+		describe "Imprimir la matriz" do
+			it "del orden 250x250" do
+				@m1.to_s.should eq({100=>{10=>1, 50=>200}, 200=>{10=>1, 50=>200}})
+			end
+		end
+
+		describe "Suma de dos matrices" do
+			it "del orden mxn" do
+				@m1.+(@m1).to_s.should eq(@m2.to_s)
+			end
+		end	
+
+		describe "Resta de dos matrices" do
+			it "del orden mxn" do
+				@m2.-(@m1).to_s.should eq(@m1.to_s)
+			end
+		end	
+
+		describe "Multiplicacion de matrices del orden axn x nxb" do
+			it "del orden 2x2 x 2x2" do
+				@m3.*(@m3).to_s.should eq(@m4.to_s)
+			end
+			it "del orden 3x2 x 2x3" do
+				@m6.*(@m7).to_s.should eq(@m8.to_s)
+			end
+		end
+
+		describe "Matriz traspuesta " do
+			it "del orden nxn." do
+				@m3.traspuesta.to_s.should eq(@m5.to_s)
+			end
+		end
+		describe "Calculo de maximo y minimo" do
+			it "Maximo" do
+				@m1.maximo.should eq (200)
+			end
+			it "Minimo" do
+				@m1.minimo.should eq (1)
+			end
+		end
+	end
+
+	before :all do
+		@m1 = MatrizDensa.new(2,2,[[1,2],[3,4]])
+		@m2 = MatrizDispersa.new(2, 2, {0 => {0 => 1, 1 => 2}, 1 => {0 => 3, 1 => 4}})
+		@m3 = MatrizDensa.new(2,2,[[7,10],[15,22]])
+		@m4 = MatrizDensa.new(2,2,[[2,4],[6,8]])
+		@m5 = MatrizDensa.new(2,2,[[0,0],[0,0]])
+		@m6 = MatrizDispersa.new(2, 2, {0 => {0 => Frac.new(1,2), 1 => Frac.new(1,2)}, 1 => {0 => Frac.new(1,2), 1 => Frac.new(1,2)}})
+		@m7 = MatrizDensa.new(2,2,[[Frac.new(3,2),Frac.new(3,2)],[Frac.new(7,2),Frac.new(7,2)]])
+	end
+
+	describe "Trabajo con  matrices de diferente tipo" do
+		describe "Matriz Densa -> Matriz Dispersa" do
+			it "Suma de dos matrices del orden mxn" do
+				@m1.+(@m2).to_s.should eq(@m4.to_s)
+			end
+			it "Resta de dos matrices del orden mxn" do
+				@m1.-(@m2).to_s.should eq(@m5.to_s)
+			end
+			it "Multiplicacion del orden 2x2 x 2x2" do
+				@m1.*(@m2).to_s.should eq(@m3.to_s)
+			end
+			it "Multiplicacion del orden 2x2 x 2x2 con fracciones y enteros" do
+				@m1.*(@m6).to_s.should eq(@m7.to_s)
+			end
+		end
+	end
+
+	describe "Trabajo con  matrices de diferente tipo" do
+		describe "Matriz Dispersa -> Matriz Densa" do
+			it "Suma de dos matrices del orden mxn" do
+				@m2.+(@m1).to_s.should eq(@m4.to_s)
+			end
+			it "Resta de dos matrices del orden mxn" do
+				@m2.-(@m1).to_s.should eq(@m5.to_s)
+			end
+			it "Multiplicacion del orden 2x2 x 2x2" do
+				@m2.*(@m1).to_s.should eq(@m3.to_s)
+			end
+			it "Multiplicacion del orden 2x2 x 2x2 con fracciones y enteros" do
+				@m6.*(@m1).to_s.should eq(@m7.to_s)
+			end
+		end
+	end
+end
+

data/spec/spec_helper.rb

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

data/test/tc_lpp_t_04_matrix.rb

@@ -0,0 +1,57 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'lpp_t_04_matrix'
+require "test/unit"
+include LppT04Matrix
+
+class Test_Matriz < Test::Unit::TestCase
+        
+        def setup 
+                @m1 = MatrizDensa.new(2,2,[[1,2],[3,4]])
+                @m2 = MatrizDispersa.new(250, 250, {100 => {10 => 1, 50 => 200}, 200 => {10 => 1, 50 => 200}})
+                @m3 = MatrizDensa.new(2,2,[[2,4],[6,8]])
+                @m4 = MatrizDispersa.new(250, 250, {100 => {10 => 2, 50 => 400}, 200 => {10 => 2, 50 => 400}})
+                @m5 = MatrizDispersa.new(2, 2, {1 => {1 => 1, 2 => 2}, 2 => {1 => 3, 2 => 4}})
+                @m6 = MatrizDispersa.new(2, 2, {1 => {1 => 7, 2 => 10}, 2 => {1 => 15, 2 => 22}})
+                @m7 = MatrizDensa.new(2,2,[[7,10],[15,22]])
+                @m8 = MatrizDispersa.new(2, 2, {0 => {0 => 1, 1 => 2}, 1 => {0 => 3, 1 => 4}})
+                @m9 = MatrizDensa.new(2,2,[[7,10],[15,22]])
+                @m10 = MatrizDispersa.new(2, 2, {0 => {0 => Frac.new(1,2), 1 => Frac.new(1,2)}, 1 => {0 => Frac.new(1,2), 1 => Frac.new(1,2)}})
+                @m11 = MatrizDensa.new(2,2,[[Frac.new(3,2),Frac.new(3,2)],[Frac.new(7,2),Frac.new(7,2)]])
+
+        end
+        def test_MatrizDensa
+                assert_equal("1", @m1.elemento[0][0].to_s)
+                assert_equal("2", @m1.elemento[0][1].to_s)
+                assert_equal("3", @m1.elemento[1][0].to_s)
+                assert_equal("4", @m1.elemento[1][1].to_s)
+                assert_equal(@m3.to_s, @m1.+(@m1).to_s)
+                assert_equal(@m1.to_s, @m3.-(@m1).to_s)
+                assert_equal(@m7.to_s, @m1.*(@m1).to_s)
+        end
+
+        def test_MatrizDispersa
+                assert_equal("1", @m2.elemento[100][10].to_s)
+                assert_equal("200", @m2.elemento[100][50].to_s)
+                assert_equal("1", @m2.elemento[200][10].to_s)
+                assert_equal("200", @m2.elemento[200][50].to_s)
+                assert_equal(@m4.to_s, @m2.+(@m2).to_s)
+                assert_equal(@m2.to_s, @m4.-(@m2).to_s)
+                assert_equal(@m6.to_s, @m5.*(@m5).to_s)
+        end
+
+        def test_DensaDispersa
+                assert_equal(@m3.to_s, @m1.+(@m8).to_s)
+                assert_equal(@m1.to_s, @m3.-(@m8).to_s)
+                assert_equal(@m9.to_s, @m1.*(@m8).to_s)
+        end
+
+        def test_DispersaDensa
+                assert_equal(@m3.to_s, @m8.+(@m1).to_s)
+                assert_equal(@m1.to_s, @m8.-(@m3).to_s)
+                assert_equal(@m9.to_s, @m8.*(@m1).to_s)
+        end
+
+        def test_Fracciones
+                assert_equal(@m11.to_s, @m1.*(@m10).to_s)
+        end
+end

data/test/tc_lpp_t_04_matrix_test.rb

@@ -0,0 +1 @@
+require "tc_lpp_t_04_matrix.rb"

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: lpp_t_04_matrix
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- EliezerCruzSuarez
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.9'
+description: ! "Para realizacion de esta practica se ha creado una jerarquia de clases.
+  \n    Teniendo en cuenta que tenemos una clase abstracta de nombre Matriz, y de
+  la cual han heredado las\n    otras dos clases que definen el tipo de objetos que
+  tenemos, MatrizDensa y MatrizDispersa, se han\n    implementado los metodos para
+  operar con ambos tipos de matrices, sin importar que objeto sea.\n    Además se
+  ha incluido el tratamiento de fracciones desarrollado en la practica anterior con
+  la idea\n    de que la matriz sea capaz de operar con elementos del tipo Franction.
+  Los metodos implemnetados son: \n    suma, resta, multiplicacion y traspuesta."
+email:
+- alu0100611298@ull.edu.es
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/lpp_t_04_matrix.rb
+- lib/lpp_t_04_matrix/version.rb
+- lpp_t_04_matrix.gemspec
+- spec/lpp_t_04_matrix_spec.rb
+- spec/spec_helper.rb
+- test/tc_lpp_t_04_matrix.rb
+- test/tc_lpp_t_04_matrix_test.rb
+homepage: ''
+licenses:
+- MIT
+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: Operacion con matrices densas y dispersas
+test_files:
+- spec/lpp_t_04_matrix_spec.rb
+- spec/spec_helper.rb
+- test/tc_lpp_t_04_matrix.rb
+- test/tc_lpp_t_04_matrix_test.rb