prac09 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.rb~

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 1.9.3
+  - jruby-19mode
+  - rbx-19mode

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in prac09.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,12 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'bundler' do
+  watch('Gemfile')
+end
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Leonor Priego, Carlos Martin
+
+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,47 @@
+==============================================================
+Prac09
+Estado actual de TRAVIS [![Build Status](https://travis-ci.org/alu0100699906/pract09.png?branch=master)](https://travis-ci.org/alu0100699906/pract09)
+==============================================================
+
+
+La Gema Prac09 consta de clases que nos permiten crear, gestionar y trabajar, de manera distinta, con matrices densas y matrices dispersas. 
+
+Como dato, cabe añadir que una matriz se considerará dispersa si tiene más de un 60% de ceros.
+
+## Instalación
+
+Añade esta línea al Gemfile de tu aplicación:
+
+    gem 'prac09'
+
+Luego ejecuta:
+
+    $ bundle
+
+O instálalo tú mismo de esta forma:
+
+    $ gem install prac09
+
+## Uso
+
+Si quieres usar esta gema en tu aplicación Ruby, incluye el fichero "pract09"
+
+## Contribución
+
+1. Haz un fork
+2. Crea tu rama de características (`git checkout -b my-new-feature`)
+3. Haz un commit de tus cambios (`git commit -am 'Add some feature'`)
+4. Empuja los cambios a la rama(`git push origin my-new-feature`)
+5. Crea un nuevo Pull Request.
+
+## Documentación
+
+### Herencia de clases
+
+                clase Matriz            //clase base
+            .________|______.   
+            ↓               ↓   
+    clase Mdispersa     clase Mdensa    //clases derivadas
+        
+La clase Matriz contendrá la implementacion de unos métodos generales para las operaciones +, -, *, to_s, == (método que pasa a una cadena de caracteres). Las clases derivadas implementarán para cada una los métodos de comparación y de acceso ([]=, []) ya que éstos tienen funcionamientos distintos debido a cómo almacena la información cada una de las clases.
+                    

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+
+RSpec::Core::RakeTask.new
+task :default => :spec
+
+desc "Ejecutamos las pruebas unitarias"
+task :test do
+  sh "ruby -Ilib test/tc_matrices.rb"
+end

data/lib/prac09.rb

@@ -0,0 +1,9 @@
+require "prac09/version"
+
+
+module Prac09
+require "prac09/fraccion"
+require "prac09/matriz"
+require "prac09/matrizdispersa"
+require "prac09/matrizdensa"
+end

data/lib/prac09/fraccion.rb

@@ -0,0 +1,149 @@
+class Fraccion 
+
+    #el modulo comparable contiene todos los metodos que permiten hacer comparaciones
+    include Comparable
+    #metodo que permite acceder a los atributos de la clase
+    attr_reader :numerador, :denominador
+
+    def initialize(n,d)
+        simp=gcd(n,d) #guarda el maximo comun divisor
+
+        if d!=0
+            @numerador=n
+            @denominador=d
+        end
+
+     #utiliza el maximo comun divisor para simplificar la  fraccion
+     @numerador, @denominador = n/simp, d/simp 
+     end
+    
+    #metodo que devuelve el numerador
+    def num()
+        @numerador
+    end
+
+    #metodo que devuelve el denominador
+    def denom()
+        @denominador
+    end
+    
+    #metodo para mostrar por la consola la fraccion
+    def to_s
+        "#{@numerador}/#{@denominador}"
+    end
+    
+    #metodo para mostrar por la consola la fraccion en punto flotante
+    def to_float
+        (@numerador.to_f()/@denominador.to_f)
+    end
+
+    #metodo para calcular el valor absoluto de una fraccion
+    def abs ()
+	Fraccion.new(@numerador.abs,@denominador.abs)
+    end
+    
+    ##metodo para calcular el reciproco de una fraccion
+    def reciprocal ()
+	Fraccion.new(@denominador,@numerador)
+    end
+
+      #metodo para calcular el opuesto de una fraccion
+    def -@ ()
+        if(@numerador>0 && @denominador<0)
+              @numerador = @numerador.abs
+              @denominador = @denominador.abs
+        
+        elsif(@numerador<0 && @denominador>0)
+              @numerador = @numerador.abs
+              @denominador = @denominador.abs
+        
+        else 
+              @numerador = -(@numerador.abs)
+              @denominador = @denominador.abs
+        end
+         Fraccion.new(@numerador,@denominador)
+    end
+    
+    #metodo para calcular la suma de dos fracciones
+    def +(object)
+		if (object.instance_of?(Fraccion)==true)
+		
+			aux=mcm(@denominador,object.denominador)
+			return Fraccion.new((((aux*@numerador)/@denominador)+(aux*object.numerador)/object.denominador),aux)
+			
+		end	
+		if (object.instance_of?( Fixnum )==true)
+			aux=Fraccion.new(object, 1)
+			m=mcm(@denominador,aux.denominador)
+			return Fraccion.new((((m*@numerador)/@denominador) + (m*aux.numerador)/aux.denominador),m)
+		end
+    end
+ 
+    #metodo para calcular la resta de dos fracciones
+    def -(object)
+        aux=mcm(@denominador,object.denominador)
+        Fraccion.new((((aux*@numerador)/@denominador)-(aux*object.numerador)/object.denominador),aux)
+    end   
+    
+    #metodo para calcular la multiplicacion de dos fracciones
+    def *(object)
+        if(object.is_a?(Numeric))
+		object = Fraccion.new(object,1)
+	end
+	Fraccion.new(@numerador*object.numerador,@denominador*object.denominador)
+    end 
+
+    #metodo para calcular la division de dos fracciones
+    def /(object)
+        #multiplica numerador con numerador y denominador con denominador
+			Fraccion.new(@numerador*object.denominador,@denominador*object.numerador)
+			
+        
+    end 
+     
+     #metodo para calcular el resto de la division de dos fracciones
+     def % (object)
+         #guarda la division de las fracciones
+         division=self.abs/object.abs
+         #calcula el resto
+	 resto=object.abs * (division - Fraccion.new(division.to_float.to_i,1))
+	 if (object.numerador < 0)
+                #si el numerador es negativo imprime el opuesto del resto
+		return -resto
+	 end
+         #lo imprime
+	 resto  
+     end
+     
+	
+     #Utilizamos el metodo del modulo Comparable para realizar operaciones comparacionales de fracciones
+     def <=> (object)
+          self.to_float<=>object.to_float    
+     end
+
+     def gcd(n, d)
+         n1,n2 = n.abs,d.abs
+         gcd = 1
+         k = 1
+         while (k <= n1 and k <= n2)
+              if (n1 % k == 0 and n2 % k == 0)
+                  gcd = k
+              end
+              k += 1
+         end
+         return gcd
+     end
+
+
+     #metodo para hallar el minimo comun multiplo de los dos numeros pasados como parametros
+     def mcm(a,b)
+        #mediante el metodo de euclides, resolvemos el minimo comun multiplo mediante el
+        #maximo comun divisor
+        aux=gcd(a,b)
+        (a/aux)*b
+     end
+
+  	def coerce(object)
+    		[self,object]
+  	end
+end

data/lib/prac09/matriz.rb

@@ -0,0 +1,190 @@
+
+class Matriz
+
+	def initialize(filas, columnas)
+    		@filas, @columnas = filas , columnas
+  	end
+
+	#get filas
+	def filas()
+		@filas
+	end
+	
+	#get columnas
+	def columnas()
+		@columnas
+	end
+
+       
+  	def Matriz.constructor(filas, columnas, velementos)
+
+      		longitud=filas*columnas
+     		 if (((velementos.count(0)*100)/(longitud)) >= 60)
+
+        		MatrizDispersa.new(filas,columnas,velementos)
+      		else 
+
+        		MatrizDensa.new(filas,columnas,velementos)
+      		end
+  	end
+
+
+	def +(object)
+    		
+		if ( (@filas == object.filas) && (@columnas == object.columnas))
+      
+			matrizresultado=Array.new
+			i = 0
+			while (i < @filas) do
+        	
+				j=0
+				while (j < @columnas) do
+          		
+					matrizresultado << (self[i,j] + object[i,j])
+            				j=j+1
+        			end
+         			i=i+1
+      			end
+      			Matriz.constructor(@filas, @columnas, matrizresultado)
+    		end
+  	end
+  
+
+	def -(object)
+    		
+		if ( (@filas == object.filas) && (@columnas == object.columnas))
+      
+			matrizresultado=Array.new
+			i = 0
+			while (i < @filas) do
+        	
+				j=0
+				while (j < @columnas) do
+          		
+					matrizresultado << (self[i,j] - object[i,j])
+            				j=j+1
+        			end
+         			i=i+1
+      			end
+      			Matriz.constructor(@filas, @columnas, matrizresultado)
+    		end
+  	end
+
+ 
+
+	def ==(object)
+		if ((@filas == object.filas) && (@columnas == object.columnas))
+			i = 0
+			while (i < @filas) do
+
+				j = 0
+				while (j < @columnas) do
+
+					if (self[i,j] == object[i,j]) #comparamos elemento a elemento
+						es_igual = true
+					else 
+						return es_igual = false #si solo uno es distinto la funcion devuelve falso
+					end
+					j = j + 1
+				end
+				i = i + 1
+			end
+		end
+		return es_igual #si compara todos los elementos y son iguales devuelve verdadero
+	end 
+
+	def *(object)
+
+		if(object.is_a? Numeric)
+      			matrizresultado=Array.new
+      			i=0
+			while (i<@filas)
+				j=0
+				while (j<@columnas)
+					matrizresultado << (self[i,j]*object)
+					j=j+1
+        			end
+				i=i+1
+			end
+			return Matriz.constructor(@filas,@columnas,matrizresultado)
+     	        
+
+		elsif ((object.is_a?(Matriz)==true) && (@columnas==object.filas()))
+			i=0
+                        matrizresultado = Array.new
+                        while (i < @filas)
+                                j = 0
+                                while (j < object.columnas())
+                                        k = 0
+                                        matrizresultado<<0
+                                        while (k < @columnas) #itera en las columnas de la primera matriz y las filas de la segunda
+                                                matrizresultado[(matrizresultado.size)-1]= (matrizresultado.last + (self[i,k] * object[k,j]))
+                                                k = k + 1
+                                        end
+                                        j = j + 1
+                                end
+                                i = i + 1
+                        end
+                        return Matriz.constructor(@filas,object.columnas,matrizresultado)
+                end
+        end
+ 
+	def max()
+		maximo = 0 # maximo provisional
+		i, j = 0,0
+		while i<=@filas
+			while j<=@columnas
+				if (self[i,j]>maximo) #si el valor es mayor que el provisional almacena el nuevo
+					maximo = self[i,j]
+				end
+				j += 1;
+			end
+			i += 1;
+		end
+		return maximo
+	end
+	
+	def min()
+		minimo = 0 # maximo provisional
+		i, j = 0,0
+		while i<=@filas
+			while j<=@columnas
+				if (self[i,j]<minimo) #si el valor es mayor que el provisional almacena el nuevo
+					minimo = self[i,j]
+				end
+				j += 1;
+			end
+			i += 1;
+		end
+		return minimo
+	end
+	
+	def to_s
+		string= "[" ##corchete de matriz
+		
+		fil=0
+		while (fil<@filas)
+			string = string + "[" #corchete de fila
+			col=0
+			while (col<@columnas)
+				string = string + "#{self[fil,col]}"
+				col += 1
+				if(col < @columnas)
+					string = string + ","
+				end
+			end
+			string = string + "]" #cerramos el corchete de fila
+			fil += 1
+			if (fil < @filas)
+				string = string + ","
+			end
+		end
+		string = string +"]" ##cerramos el corchete de matriz
+	end
+                     
+  
+  	def coerce(object)
+    		[self,object]
+  	end
+  
+end

data/lib/prac09/matrizdensa.rb

@@ -0,0 +1,22 @@
+
+ 
+class MatrizDensa < Matriz
+  
+	def initialize(filas, columnas, velementos)
+   		 super(filas, columnas)
+    		 @matriz=Array.new(velementos)
+  	end
+  
+  	def pos(i,j)
+    		 (i*@columnas)+j
+ 	end
+  
+  	def [](i,j)
+    		 @matriz[pos(i,j)]
+  	end
+  
+  	def []=(i,j,valor)
+    		 @matriz[pos(i,j)] = valor
+  	end
+
+end

data/lib/prac09/matrizdispersa.rb

@@ -0,0 +1,59 @@
+
+class MatrizDispersa < Matriz
+
+	def initialize(filas, columnas, velementos)
+    		super(filas, columnas)
+                @vvalores= Array.new 
+                @vfil= Array.new
+                @vcol = Array.new
+
+                longitud=(@filas*@columnas)
+		i=0
+		while(i<longitud)
+
+      			if(velementos[i]!=0)
+
+        		@vvalores<< (velementos[i])
+        		@vfil << (i/@columnas)
+       			@vcol<< (i%@columnas)
+			end
+			i=i+1
+		end
+	end
+
+	def [](f,c)
+		no_nulo = @vvalores.size
+		i=0
+		while(i < no_nulo)
+
+      			if (@vfil[i] == f && @vcol[i] == c)
+        			return @vvalores[i]
+       		        end
+			i=i+1
+     		end
+     		return 0 
+  	end
+  	
+	def []= (i,j,nvalor) #setter
+		ind = 0
+		while ind<@vvalores.size
+			if (i == @vfil[ind] && j == @vcol[ind] && nvalor != 0) #para poner un nuevo valor no nulo
+				@vvalor[ind]=nvalor
+				return
+			end
+			if (i == @vfil[ind] && j == @vcol[ind] && nvalor == 0) 	#para poner un nuevo valor nulo en una posicion ocupada anteriormente
+				@vvalores.delete_at(ind)								#simplemente eliminamos el valor que habia antes pues los nulos no se almacenan
+				@vfil.delete_at(ind)
+				@vcol.delete_at(ind)
+				return
+			end
+			ind += 1
+		end #si la posicion no existia la anyadimos con el correspondiente valor
+		@vvalores << (nvalor)
+		@vfil << (i)
+		@vcol << (j)
+		
+	end	
+
+
+end

data/lib/prac09/version.rb

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

data/prac09.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'prac09/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "prac09"
+  spec.version       = Prac09::VERSION
+  spec.authors       = ["Leonor Priego","Carlos Martin"]
+  spec.email         = ["alu0100699906@ull.edu.es","alu0100702293@ull.edu.es"]
+  spec.description   = %q{Clases que permiten gestionar matrices densas y dispersas de manera distinta}
+  spec.summary       = %q{Aplicación para trabajar con matrices densas y dispersas}
+  spec.homepage      = "https://github.com/alu0100699906/pract09"
+  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"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "guard-bundler"
+end

data/spec/fraccion_spec.rb

@@ -0,0 +1,169 @@
+require "prac09/fraccion.rb"
+  
+describe Fraccion do #espectativa para la clase
+        ##
+        describe "#se asignan bien los valores de denominador y numerador"do
+                it "Creacion correcta de fraccion con numerador y denom." do
+                        fa = Fraccion.new(1,2)
+                        fa.numerador.should == 1
+                        fa.denominador.should == 2
+                end
+        end
+        ##
+        describe "#la fraccion esta en su minima expresion" do
+                it "Fraccion simplificada" do
+                        fa = Fraccion.new(6,4)
+                        fa.numerador.should == 3
+                        fa.denominador.should == 2
+                end
+        end
+        ##
+        describe "#el valor del numerador y denominador se obtiene mediante num() y denom()" do
+                it ".num() existe" do
+                        fa = Fraccion.new(1,2)
+                        fa.num() == 1
+                end
+                it ".denom() existe" do
+                        fa = Fraccion.new(1,2)
+                        fa.denom() == 2
+                end
+        end
+        ##
+        describe " #Se debe mostrar num/denom" do
+                it " .to_s()" do
+                        fa = Fraccion.new(1,2)
+                        fa.to_s().should == "1/2"
+                end
+        end
+        ##
+        describe " #Se debe mostrar en formato flotante" do
+                it " .to_float()" do
+                        fa = Fraccion.new(1,2)
+                        fa.to_float().should == 0.5
+                end
+        end
+        ##
+        describe " #comparacion con == "do
+                it "\n comparando"do
+                        fa = Fraccion.new(6,4)
+                        fb = Fraccion.new(3,2)
+                        fc = Fraccion.new(1,5)
+                        
+                        (fa == fb).should be_true
+                        (fa == fc).should be_false
+                        (fb == fc).should be_false
+                end
+        end
+        ##
+        describe " #valor absoluto con metodo abs"do
+                it ".abs"do
+                        fa = Fraccion.new(-6,4)
+                        fb = Fraccion.new(1,-5)
+                        fc = Fraccion.new(1,5)
+                
+                        fa.abs.num.should == 3
+                        fa.abs.denom.should == 2
+                        fb.abs.should == fc
+                end
+        end
+        
+        ##
+        describe " #Operaciones con fracciones"do
+                it ".recriprocal calcula inversa" do
+                        fa = Fraccion.new(3,2)
+                        fb = Fraccion.new(2,3)
+                
+                        (fa.reciprocal == fb).should be_true
+                end
+                it "-@ opuesto" do
+                        fa = Fraccion.new(2,4)
+                        fb = Fraccion.new(-1,2)
+                        fc = Fraccion.new(1,-4)
+
+                        ((-fa) == fa).should be_true
+                        (-fb).to_s.should eq("1/2")
+                 (-fc).should eq(Fraccion.new(1,4))
+                end
+                it "@+@ operacion suma" do
+                        fa = Fraccion.new(3,2)
+                        fb = Fraccion.new(1,4)
+                        fc = Fraccion.new(7,4)
+                        
+                        (fa + fb).should == fc
+                        (fb + fc).should eq(Fraccion.new(2,1))
+                end
+                it "@-@ operacion resta" do
+                        fa = Fraccion.new(2,3)
+                        fb = Fraccion.new(1,4)
+                        fc = Fraccion.new(5,12)
+                        
+                        (fa - fb).should == fc
+                        (fb - fc).should eq(Fraccion.new(-1,6))
+                end
+                it "@*@ operacion producto" do
+                        fa = Fraccion.new(2,3)
+                        fb = Fraccion.new(1,4)
+                        fc = Fraccion.new(5,2)
+                        
+                        (fa * fb).should eq(Fraccion.new(1,6))
+                        (fa * fc).should eq(Fraccion.new(5,3))
+                        (fb * fc).should eq(Fraccion.new(5,8))
+                end
+                it "@/@ operacion division" do
+                        fa = Fraccion.new(2,3)
+                        fb = Fraccion.new(5,2)
+                        fc = Fraccion.new(4,15)
+                        
+                        (fa / fb == fc).should be_true
+                        (fa / fc == fb).should be_true
+                end
+                it "@%@ operacion modulo" do
+                        fa = Fraccion.new(2,3)
+                        fb = Fraccion.new(5,2)
+                        fc = Fraccion.new(4,15)
+                        
+                        (fa % fb).to_s.should =="2/3"
+                        (fa % fc).to_s.should =="2/15"
+                end
+                it "@<@ operacion menor que" do
+                        fa = Fraccion.new(1,4)
+                        fb = Fraccion.new(5,2)
+                        fc = Fraccion.new(3,4)
+                        
+                        (fa < fb).should be_true
+                        (fa < fc).should be_true
+                        (fc < fb).should be_true
+                end
+                it "@>@ operacion mayor que" do
+                        fa = Fraccion.new(1,4)
+                        fb = Fraccion.new(5,2)
+                        fc = Fraccion.new(3,4)
+                        
+                        (fb > fa).should be_true
+                        (fc > fa).should be_true
+                        (fb > fc).should be_true
+                end
+                it "@<=@ operacion menor o igual que" do
+                        fa = Fraccion.new(1,4)
+                        fb = Fraccion.new(5,2)
+                        fc = Fraccion.new(1,4)
+                        
+                        (fa <= fb).should be_true
+                        (fa <= fc).should be_true
+                        (fc <= fb).should be_true
+                end
+                it "@>=@ operacion mayor o igual que" do
+                        fa = Fraccion.new(1,4)
+                        fb = Fraccion.new(5,2)
+                        fc = Fraccion.new(1,4)
+                        
+                        (fb >= fa).should be_true
+                        (fc >= fa).should be_true
+                        (fb >= fc).should be_true
+                end
+        end
+   
+    
+end
+
+

data/spec/matrices_spec.rb

@@ -0,0 +1,128 @@
+
+require 'prac09.rb'
+
+describe Matriz do
+
+	before (:each) do
+	
+		@ma = Matriz.constructor(2,2,[1,1,2,2])
+		@mz = Matriz.constructor(2,2,[1,1,2,2])
+		@md = Matriz.constructor(2,2,[2,2,4,4])
+		@dis = Matriz.constructor(2,2,[2,0,0,0])
+
+		@mb = Matriz.constructor(3,3,[0,0,0,0,0,1,0,0,0])
+		@mg = Matriz.constructor(3,3,[0,0,0,0,0,1,0,0,0])
+		@mo = Matriz.constructor(3,3,[0,0,0,0,0,2,0,0,0])
+		@mp = Matriz.constructor(3,3,[1,2,3,0,0,0,0,0,4])
+		@mq = Matriz.constructor(3,3,[2,4,0,0,0,0,2,0,0])
+			
+		@fa = Fraccion.new(1,2)
+		@fb = Fraccion.new(3,4)
+		@fc = Fraccion.new(5,6)
+		@fd = Fraccion.new(7,8)
+		@ra = Fraccion.new(11,8)
+		@ro = Fraccion.new(19,12)
+		
+		@a = Matriz.constructor(2,2, [@fa,@fb,@fc,@fd])
+		@b = Matriz.constructor(2,2,[@fd, @fc, @fb, @fa])
+		@c = Matriz.constructor(2,2,[@ra,@ro,@ro,@ra])
+		
+		@pro1 = Matriz.constructor(3,3,[1,1,1,2,2,2,3,3,3])
+                @pro2 = Matriz.constructor(3,3,[1,2,3,1,2,3,1,2,3])
+ 
+		@multip = Matriz.constructor(3,2,[2,3,0,1,0,3])
+		@multip1 = Matriz.constructor(2,4,[0,1,0,0,7,0,2,0])#dispersa
+		
+		@l1=Matriz.constructor(2,2,[0,0,0,1])
+		@l2=Matriz.constructor(2,2,[0,1,0,0])
+
+		@l4=Matriz.constructor(3,3,[0,1,2,1,0,0,0,0,0])
+		@l5=Matriz.constructor(3,3,[2,0,2,2,0,0,0,0,0])
+	
+	
+	end
+
+	 describe "# pruebas " do
+
+		it "instanciacion de un racional" do
+			@fa = Fraccion.new(1,2)		
+			@fa.numerador.should == 1
+			@fa.denominador.should == 2
+		end
+
+                it "suma de matrices con fracciones" do
+			(@a + @b).should == @c
+		end
+
+
+        	it "#comprobacion de clases" do
+			@mb.instance_of?(MatrizDispersa)
+			@ma.instance_of?(MatrizDensa)
+			@dis.instance_of?(MatrizDispersa)
+		end
+
+		it " igualdad densa "do
+			@ma.should == @mz	
+		end
+
+		it " igualdad dispersa "do
+			@mb.should == @mg
+		end
+	
+		it " suma " do
+
+			(@ma + @mz).should == @md #suma densas
+			(@mg + @mb).should == @mo #suma dispersas
+			(@mp + @mq).to_s.should == ('[[3,6,3],[0,0,0],[2,0,4]]') #suma dispersas
+			(@a + @md).to_s.should == ('[[5/2,11/4],[29/6,39/8]]')#suma racional con densa	
+			(@a + @dis).to_s.should ==('[[5/2,3/4],[5/6,7/8]]') #suma racional con dispersa
+			(@dis+ @a).to_s.should == ('[[5/2,3/4],[5/6,7/8]]') #suma dispersa con racional
+			(@ma + @dis).to_s.should == ('[[3,1],[2,2]]') #suma dispersa con densa
+
+		end	
+		
+		it "resta" do
+			(@md -@mz).should eq(@ma)
+			(@mo - @mg).should eq(@mb)
+		end
+
+	
+		 it " producto "do
+			(2*@pro1).to_s.should ==('[[2,2,2],[4,4,4],[6,6,6]]')
+			(@ma * @a).to_s.should == ('[[4/3,13/8],[8/3,13/4]]') 
+			(@a * @l1).to_s.should == ('[[0/4,3/4],[0/24,7/8]]')
+                        ( @a * @a ).to_s.should == ('[[7/8,33/32],[55/48,89/64]]') #multiplica 2 racionales
+                        (@pro1 * @pro2).to_s.should == ('[[3,6,9],[6,12,18],[9,18,27]]')
+			(@multip * @multip1).to_s.should ==('[[21,2,6,0],[7,0,2,0],[21,0,6,0]]') #multiplica densa con dispersa
+			(@l1*@l2).to_s.should ==('[[0,0],[0,0]]') #multiplica dispersas
+			(@l4*@l5).to_s.should ==('[[2,0,0],[2,0,2],[0,0,0]]') #multiplica dispersas
+                end
+
+		it " getter y setter"do
+			@mz[0,0].should == 1
+			@ma[0,1]= 2 
+			@ma[0,1].should == 2
+			
+			@multip[0,0].should == 2
+			@multip[1,2]= 5
+			@mq[0,1].should == 4
+		
+
+			@mb[1,2].should == 1
+			@mb[0,0]= 5
+			@mb[0,0].should == 5
+			
+
+
+		end
+		it " maximo y minimo"do
+			@mq.max.should == 4
+			@md.max.should == 4
+
+
+		end
+	
+	end
+	
+end
+

data/test/tc_matrices.rb

@@ -0,0 +1,69 @@
+require 'prac09.rb'
+require 'test/unit'
+
+class Test_Matrices < Test::Unit::TestCase
+	def setup
+    		@ma = Matriz.constructor(2,2,[1,1,2,2])
+		@mz = Matriz.constructor(2,2,[1,1,2,2])
+		@md = Matriz.constructor(2,2,[2,2,4,4])
+		@mc = Matriz.constructor(3,3,[8,8,4,5,4,7,1,2,9]) 
+
+		@mb = Matriz.constructor(3,3,[0,0,0,0,0,1,0,0,0])
+		@mg = Matriz.constructor(3,3,[0,0,0,0,0,1,0,0,0])
+		@mo = Matriz.constructor(3,3,[0,0,0,0,0,2,0,0,0])
+		@mp = Matriz.constructor(3,3,[1,2,3,0,0,0,0,0,4])
+		@mq = Matriz.constructor(3,3,[2,4,0,0,0,0,2,0,0])
+		@mr = Matriz.constructor(3,3,[3,6,3,0,0,0,2,0,4])
+
+		@fa = Fraccion.new(1,2)
+		@fb = Fraccion.new(3,4)
+		@fc = Fraccion.new(5,6)
+		@fd = Fraccion.new(7,8)
+		@ra = Fraccion.new(11,8)
+		@ro = Fraccion.new(19,12)
+		@rb = Fraccion.new(33,32)
+		@rc = Fraccion.new(55,48)
+		@rd = Fraccion.new(89,64)
+
+		@a = Matriz.constructor(2,2, [@fa,@fb,@fc,@fd])
+		@b = Matriz.constructor(2,2,[@fd, @fc, @fb, @fa])
+		@c = Matriz.constructor(2,2,[@ra,@ro,@ro,@ra])
+		
+		@pro1 = Matriz.constructor(3,3,[1,1,1,2,2,2,3,3,3])
+                @pro2 = Matriz.constructor(3,3,[1,2,3,1,2,3,1,2,3])
+                @pro3 = Matriz.constructor(3,3,[3,6,9,6,12,18,9,18,27])
+  	end
+
+  	def tear_down
+    		#nothing
+  	end
+  
+  #pruebas para el metodo suma
+ 	def test_suma
+    		assert_equal(@mr,(@mq+@mp)) #dispersas
+    		assert_equal(@c,(@a+@b))    #fraccionales
+		assert_equal(@md,(@ma+@mz)) #densa
+  	end
+  
+  #pruebas para el metodo resta
+  	def test_resta
+    		assert_equal(@ma, (@md-@mz)) #densa
+    		assert_equal(@a, (@c-@b))    #fraccionales
+		assert_equal(@mp, (@mr-@mq))  #dispersa
+  	end
+
+  #pruebas para el metodo producto
+  	def test_producto
+    		assert_equal(@pro3, (@pro1*@pro2))
+	        assert_equal((@ma * @a).to_s,('[[4/3,13/8],[8/3,13/4]]')) 
+  	end
+
+  #pruebas para los fallos
+  	def test_failure
+    		assert_equal(@c,(@a+@b))
+  	end
+    
+	def test_maximo_minimo
+		assert_equal(@mq.max,4)
+	end
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: prac09
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Leonor Priego
+- Carlos Martin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &9760260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: *9760260
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &9759780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *9759780
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &9759260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *9759260
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &9758660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *9758660
+- !ruby/object:Gem::Dependency
+  name: guard-bundler
+  requirement: &9758080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *9758080
+description: Clases que permiten gestionar matrices densas y dispersas de manera distinta
+email:
+- alu0100699906@ull.edu.es
+- alu0100702293@ull.edu.es
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/prac09.rb
+- lib/prac09/fraccion.rb
+- lib/prac09/matriz.rb
+- lib/prac09/matrizdensa.rb
+- lib/prac09/matrizdispersa.rb
+- lib/prac09/version.rb
+- pkg/prac09-0.0.1.gem
+- prac09.gemspec
+- spec/fraccion_spec.rb
+- spec/matrices_spec.rb
+- test/tc_matrices.rb
+homepage: https://github.com/alu0100699906/pract09
+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.11
+signing_key: 
+specification_version: 3
+summary: Aplicación para trabajar con matrices densas y dispersas
+test_files:
+- spec/fraccion_spec.rb
+- spec/matrices_spec.rb
+- test/tc_matrices.rb