matrix_expansion 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/.travis.yml

@@ -0,0 +1,15 @@
+nguage: ruby
+
+rvm:
+
+  - 1.9.3
+
+  - jruby-18mode # JRuby in 1.8 mode
+
+  - jruby-19mode # JRuby in 1.9 mode
+
+  - rbx-18mode
+
+  - rbx-19mode
+
+  - 1.8.7

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,30 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+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

@@ -0,0 +1,22 @@
+Copyright (c) 2013 TODO: Write your name
+
+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,23 @@
+# MatrixExpansion
+
+## Introducción
+    
+Gema que permite el uso de matrices densas y dispersas a través de la herencia de una matriz simple. Todas las operaciones con números y fracciones incluidas.
+
+## Instalación
+
+Add this line to your application's Gemfile:
+
+    gem 'matrix_expansion'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install matrix_expansion
+
+## Diseño
+
+A la hora de realizar las matrices densas se ha realizado de forma natural (como para cualquier matriz simple). El planteamiento importante es para la representación de las matrices dispersas. Hemos decidido finalmente, tras haber pensado en implementarlo con varios vectores, en que era más sencillo, tanto para el acceso como para las operaciones, implementarlo con un array de hash. Cada fila es un array que contiene hashes, donde la clave es la columna del elemento no nulo y el valor es el propio valor del elemento no nulo. De esta  forma, solamente se almacenan los valores nulos. Si se accediera a otra posición se devolvería 0 (aunque este no este almacenado en la matriz dispersa para ahorrar memoria).

data/Rakefile

@@ -0,0 +1,30 @@
+
+$:.unshift File.dirname(__FILE__) + 'lib'
+$:.unshift './lib', './spec'
+
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+
+desc "Expectativas de la clase Matriz" 
+task :spec do
+        sh "rspec -I. spec/matrix_spec.rb"
+end
+
+desc "Expectativas de la clase Matriz, con documentacion" 
+task :test do
+        sh "rspec -I. spec/matrix_spec.rb --format documentation"
+end
+
+desc "Expectativas de la clase Matriz, con documentacion HTML"
+task :thtml do
+        sh "rspec -I. spec/matrix_spec.rb --format html"
+end
+
+desc "Pruebas unitarias de las clases Matriz_Densa y Matriz_Dispersa" 
+task :tc do
+        sh "ruby -i. test/tc_matrix.rb"
+end

data/lib/matrix_expansion.rb

@@ -0,0 +1,11 @@
+require "./lib/matrix_expansion/version"
+require "./lib/matrix_expansion/matrix.rb"
+require "./lib/matrix_expansion/matrix_densa.rb"
+require "./lib/matrix_expansion/matrix_dispersa.rb"
+
+require "./lib/matrix_expansion/fraccion.rb"
+require "./lib/matrix_expansion/gcd.rb"
+
+module MatrixExpansion
+  # Your code goes here...
+end

data/lib/matrix_expansion/fraccion.rb

@@ -0,0 +1,118 @@
+require "./lib/matrix_expansion/gcd.rb"
+
+class Fraccion
+        include Comparable
+        attr_reader :a, :b #a: numerador, b: denominador
+        def initialize(a,b)
+                #comprobamos que los datos de entradas sean numericos
+                raise unless a.is_a?(Numeric)
+                raise unless b.is_a?(Numeric)
+                #comprobamos que el dominador no sea cero 
+                raise unless (b != 0)
+                #inicializamos las variables
+                 @a, @b = a, b
+        end
+        #formateo de la salida (a/b)
+        def to_s
+                "#{@a}/#{@b}"
+        end
+
+        #metodo que retorna el numerador 
+        def num
+                return @a
+        end
+        #metedo que retorna el denominador 
+        def denom
+                return @b
+        end
+        #Fraccion en modo flotante
+        def to_f
+                @a.to_f / @b.to_f #conversion de tipo a flotante mediante to_f
+        end
+        
+        #Fracción pasada a float. (ej: 1.25)
+        def abs
+                 f= Fraccion.new(@a.abs, @b.abs)
+        end
+
+        #Fracción reciproca o inversa (a/b -> b/a)
+        def reciprocal
+                f= Fraccion.new(@b, @a)
+        end
+        
+        #Suma de fracciones
+        def + (other)
+                comun = @b * other.denom
+                a1 = @a * other.denom
+                a2 = other.num * @b
+                a3 = a1 + a2
+                k = gcd(a3,comun)
+                a3 /= k
+                comun /= k
+                Fraccion.new(a3,comun)
+        end
+        
+        #Resta de fracciones
+        def - (other)
+                comun = @b * other.denom
+                a1 = @a * other.denom
+                a2 = other.num * @b
+                a3 = a1 - a2
+                k = gcd(a3,comun)
+                a3 /= k
+                comun /= k
+                Fraccion.new(a3,comun)
+        end
+
+        #Opuesto de fracción. La suma de una fracción y su opuesto debe ser 0. 
+        def -@
+                k = gcd(@a, @b)
+        a = @a / k
+        b = @b / k
+        if (b < 0)  #Si el denominador es negativo
+                        return Fraccion.new(a,-b)
+                else 
+                        return Fraccion.new(-a,b)
+                end
+        end
+
+        #Producto de fracciones
+        def * (other)
+                a = @a * other.num
+                b = @b * other.denom
+                k = gcd(a,b)
+                a /= k
+                b /= k
+                Fraccion.new(a,b)
+        end
+
+        #División de fracciones
+        def / (other)
+                a = @a * other.denom
+                b = @b * other.num
+                k = gcd(a,b)
+                a /= k
+                b /= k
+                Fraccion.new(a,b)
+        end
+        
+        #Resto de fracciones
+        def % (other)
+                r = Fraccion.new(0,1) #Inicializa objeto
+                r = self
+                while (r.to_f >= other.to_f) do   #Hasta que no se pueda restar más. Queda en r el resto.
+                        r = r - other
+                end
+                return r        
+        end
+        
+
+        def <=> (other)
+                self.to_f <=> other.to_f
+        end
+        
+        def coerce (other)
+            [Fraccion.new(other,1),self]
+        end
+        
+end

data/lib/matrix_expansion/gcd.rb

@@ -0,0 +1,18 @@
+=begin
+**********************************************************
+* Autores:
+*        Teno González Dos Santos
+*   Albano José Yanes Reyes
+* Fecha: 18/10/2013
+* Asignatura: Lenguejes y Paradigmas de Programación
+* Tercero de Grado en Ingeniería Informática
+* Universidad de la Laguna
+***********************************************************
+=end
+def gcd(u, v)
+  u, v = u.abs, v.abs
+  while v != 0 
+    u, v = v, u % v
+  end
+  u
+end

data/lib/matrix_expansion/matrix.rb

@@ -0,0 +1,31 @@
+=begin
+*******************************************************************************************
+* Autores: 
+       Teno González Dos Santos
+       Albano José Yanes Reyes
+* Fecha: 19/11/2013 -
+* Asignatura: Lenguujes y Paradigmas de Programación
+* Tercero de Grado en Ingeniería Informática
+* Universidad de la Laguna
+*
+* Practica 10: Matrices densas y dispersas
+********************************************************************************************
+=end
+
+# Clase Matriz
+
+require './lib/matrix_expansion/fraccion.rb'
+
+module MatrixExpansion
+  class Matriz
+    attr_reader :fil, :col
+    attr_accessor :matrix
+    
+    def initialize(n, m)
+      raise ArgumentError, 'Valores para filas y columnas incorrectas' unless n.is_a? Fixnum and n > 0 and m.is_a? Fixnum and m > 0
+    
+      @fil, @col= n, m
+    end
+
+  end
+end

data/lib/matrix_expansion/matrix_densa.rb

@@ -0,0 +1,232 @@
+=begin
+*******************************************************************************************
+* Autores: 
+       Teno González Dos Santos
+       Albano José Yanes Reyes
+* Fecha: 19/11/2013 -
+* Asignatura: Lenguujes y Paradigmas de Programación
+* Tercero de Grado en Ingeniería Informática
+* Universidad de la Laguna
+*
+* Practica 10: Matrices densas y dispersas
+********************************************************************************************
+=end
+
+# Clase Matriz_Densa
+
+require "./lib/matrix_expansion/matrix.rb"
+
+module MatrixExpansion
+    class Matriz_Densa < Matriz
+        
+        # Crea una matriz anidando array e inicializa los valores a 0
+        def initialize(n, m)
+          super
+          
+          @matrix = Array.new(@fil,0)
+          i = 0
+          while i < @fil
+            @matrix[i] = Array.new(@col,0)
+            i += 1  
+          end
+        end
+        
+        # Da valores numericos a la matriz densa
+        def set_valores_num
+            valor = 1
+            i = 0
+            while(i < @col)
+                j = 0
+                while(j < @fil)
+                    @matrix[i][j] = valor
+                    valor += 1
+                    j += 1
+                end
+                i += 1
+            end
+        end
+        
+        # Da valores fraccionales a la matriz densa
+        def set_valores_fracc
+            a = 1
+            b = 2
+            i = 0
+            while(i < @col)
+                j = 0
+                while(j < @fil)
+                    @matrix[i][j] = Fraccion.new(a,b)
+                    a += 1
+                    b += 1
+                    j += 1
+                end
+                i += 1
+            end
+        end
+
+        #Comprueba que se accede dentro de la matriz y devuelve el valor
+        def get(i,j)
+            if( !(i.is_a? Fixnum) or i < 0 or i >=@fil or !(j.is_a? Fixnum) or j < 0 or j >= @col)
+                return nil
+            end
+            
+            return @matrix[i][j]
+        end
+        
+        # Calcula el porcentaje de valores nulos
+        def porcentaje_nulos
+          total = @fil*@col
+          no_nulos = 0
+          
+          i = 0
+          while(i < @fil)
+            j = 0
+            while(j < @col)
+              if(@matrix[i][j] != 0)
+                no_nulos += 1
+              end
+              j += 1
+            end
+            i += 1
+          end
+          
+          nulos = total - no_nulos
+          nulos.to_f/total.to_f
+        end
+    
+        # Muestra la matriz densa
+        def to_s
+          s = ""
+          i = 0
+          while(i < @col)
+            j = 0
+            while(j < @fil)
+              s += "#{@matrix[i][j].to_s}\t"
+              j += 1
+            end
+            s += "\n"
+            i += 1
+          end
+          s
+        end
+        
+        # Suma de matrices densas
+        def +(other)
+            raise ArgumentError , 'El argumento debe ser una matriz' unless other.is_a? Matriz
+            raise ArgumentError , 'Las matrices deben ser del mismo tamano' unless @fil == other.fil and @col == other.col
+            
+            c = Matriz_Densa.new(@fil, @col)
+            i = 0
+            while(i < @fil)
+                j = 0
+                while(j < @col)
+                    c.matrix[i][j] = @matrix[i][j] + other.matrix[i][j]
+                    j += 1
+                end 
+                i += 1
+            end
+            c
+        end
+            
+        # Resta de matrices densas
+        def -(other)
+            raise ArgumentError , 'El argumento debe ser una matriz' unless other.is_a? Matriz
+            raise ArgumentError , 'Las matrices deben ser del mismo tamano' unless @fil == other.fil and @col == other.col
+            
+            c = Matriz_Densa.new(@fil, @col)
+            i = 0
+            while(i < @fil)
+                j = 0
+                while(j < @col)
+                    c.matrix[i][j] = @matrix[i][j] - other.matrix[i][j]
+                    j += 1
+                end
+                i += 1
+            end
+            c
+        end
+            
+            
+        #Producto de matrices densas
+        def *(other)
+            raise ArgumentError , 'El argumento debe ser una matriz' unless other.is_a? Numeric or other.is_a? Matriz
+            
+            #Si el argumento es un numero
+            if(other.is_a? Numeric)
+                c = Matriz_Densa.new(@fil, @col)
+                i = 0
+                while(i < @N)
+                    j = 0
+                    while(j < @M)
+                        c.matrix = @matrix[i][j] * other
+                        j += 1
+                    end
+                    i += 1
+                end
+            #Si el arguumento es una matriz
+            else
+                raise ArgumentError , 'Matriz no compatible (A.fil == B.col)' unless @col == other.fil
+                
+                c = Matriz_Densa.new(@fil, other.col)
+                i = 0
+                while(i < @fil)
+                    j = 0
+                    while(j < other.col)
+                        k = 0
+                        c.matrix[i][j] = 0
+                        while(k < @col)
+                            c.matrix[i][j] += @matrix[i][k] * other.matrix[k][j]
+                            k += 1
+                        end
+                        j += 1
+                    end
+                    i += 1
+                end
+            end
+            
+            c
+        end
+        
+        
+        # Calcula el minimo elemento de la matriz
+        def min
+            # Establecemos valor del primer elemento
+            min = @matrix[0][0]
+            i = 0
+            
+            # Fila a fila actualizando el valor minimo
+            while (i < @fil)
+                j = 0
+                while (j < @col)
+                    if (@matrix[i][j] < min)
+                        min = @matrix[i][j]
+                    end
+                    j += 1
+                end
+                i += 1
+            end
+            min
+        end
+        
+        # Calcula el maximo elemento de la matriz
+        def max
+                
+            # Establecemos valor del primer elemento
+            max = @matrix[0][0]
+            i = 0
+            
+            #Fila a fila actualizando el valor maximo
+            while (i < @fil)
+                j = 0
+                while (j < @col)
+                    if (@matrix[i][j] > max)
+                        max = @matrix[i][j]
+                    end
+                    j += 1
+                end
+                i += 1
+            end
+            max
+        end
+    end
+end
+

data/lib/matrix_expansion/matrix_dispersa.rb

@@ -0,0 +1,268 @@
+=begin
+*******************************************************************************************
+* Autores: 
+       Teno González Dos Santos
+       Albano José Yanes Reyes
+* Fecha: 19/11/2013 -
+* Asignatura: Lenguujes y Paradigmas de Programación
+* Tercero de Grado en Ingeniería Informática
+* Universidad de la Laguna
+*
+* Practica 10: Matrices densas y dispersas
+********************************************************************************************
+=end
+
+# Clase Matriz_Dispersa
+
+require "./lib/matrix_expansion/matrix.rb"
+require "./lib/matrix_expansion/matrix_densa.rb"
+
+module MatrixExpansion
+  class Matriz_Dispersa < Matriz  
+    
+        # Se crea un array de hashes en el que en cada fila i, por cada elemento no nulo hay un hash de clave j y valor no_nulo
+        def initialize(n, m)
+            super
+            @matrix = Array.new(@fil)
+            i = 0
+            while(i < @fil)
+                @matrix[i] = {}
+                i += 1
+            end
+        end
+        
+        # Metodo de la clase que permite convertir una matriz densa en una dispersa 
+        def self.densa_a_dispersa(matriz)
+            raise ArgumentError, 'El parametro debe ser una matriz densa' unless matriz.is_a? MatrixExpansion::Matriz_Densa
+            
+            obj = new(matriz.fil, matriz.col)
+            
+            i = 0
+            while(i < matriz.fil)
+                j = 0
+                while(j < matriz.col)
+                    value = matriz.matrix[i][j]
+              
+                    if( value != 0)
+                        obj.matrix[i][j] = value
+                    end
+                    j += 1
+                end
+                i += 1
+            end
+            obj
+        end
+        
+        #Calcula el procentaje de nulos en la matriz dispersa
+        def porcentaje_nulos
+            total = @fil*@col
+            no_nulos = 0
+            
+            i = 0
+            while(i < @fil)
+                # El tamaño de cada fila es el numero de elementos no nulos que hay en ellas
+                no_nulos += @matrix[i].size
+                i += 1
+            end
+            
+            nulos = total - no_nulos
+            nulos.to_f/total.to_f
+        end
+        
+        # Metodo para asignar valores a la matriz dispersa que permite controlar que siga siendo dispersa en todo momento
+        def set(i, j, valor)
+            # Se accede dentro de los limites de la  matriz
+            if( !(i.is_a? Fixnum) or i < 0 or i >=@fil or !(j.is_a? Fixnum) or j < 0 or j >= @col)
+                return nil
+            end
+             # Borrar elemento si es un valor nulo. Si no, introducirlo
+            if(valor == nil or valor == 0)
+                @matrix[i].delete(j)
+            else
+                @matrix[i][j] = valor
+            end
+            # Si se ha sobrepasado el número de elementos nulos, borramos el último elemento modificado
+            if(porcentaje_nulos < 0.6)
+                @matrix[i].delete(j)
+                puts "Borrado el elemento #{i},#{j} por sobrepasar el numero de elementos no nulos (Porcentaje actual: #{porcentaje_nulos}"
+            end
+          
+        end
+        
+        # Metodo que muestra la matriz dispersa de la forma: (0,1)=>2  (0,2)=>3
+        #                                                    (1,3)=>1
+        def to_s
+    
+            i = 0
+            salida = ""
+            while(i < @fil)
+                @matrix[i].sort.each{|k, v| salida += "(#{i},#{k.to_s})=>#{v.to_s} "}
+                salida += "\n"
+                i += 1
+            end
+            salida
+        end
+        
+        # Metodo que devuelve el valor de la posicion dentro de la matriz si es no nulo, o 0 eoc
+        def get(i, j)
+            if( !(i.is_a? Fixnum) or i < 0 or i >=@fil or !(j.is_a? Fixnum) or j < 0 or j >= @col)
+                return nil
+            end
+            
+            if(@matrix[i][j] != nil)
+                return @matrix[i][j]
+            else
+                return 0
+            end
+        end
+    
+        # Suma de matrices
+        def +(other)
+            raise ArgumentError , 'El argumento debe ser una matriz' unless other.is_a? Matriz
+            raise ArgumentError , 'Las matrices deben ser del mismo tamano' unless @fil == other.fil and @col == other.col
+            
+            c = Matriz_Densa.new(@fil, @col)
+            i = 0
+            while(i < @fil)
+                j = 0
+                while(j < @col)
+                    c.matrix[i][j] = get(i,j) + other.get(i,j)
+                    j += 1
+                end 
+                i += 1
+            end
+            # Si el resultado es una matriz dispersa se convierte la densa
+            if(c.porcentaje_nulos > 0.6)
+                c = Matriz_Dispersa.densa_a_dispersa(c)
+            end
+            c
+        end
+            
+        # Resta de matrices
+        def -(other)
+            raise ArgumentError , 'El argumento debe ser una matriz' unless other.is_a? Matriz
+            raise ArgumentError , 'Las matrices deben ser del mismo tamano' unless @fil == other.fil and @col == other.col
+            
+            c = Matriz_Densa.new(@fil, @col)
+            i = 0
+            while(i < @fil)
+                j = 0
+                while(j < @col)
+                    c.matrix[i][j] = get(i,j) - other.get(i,j)
+                    j += 1
+                end 
+                i += 1
+            end
+            
+            # Si el resultado es una matriz dispersa se convierte la densa
+            if(c.porcentaje_nulos > 0.6)
+                c = Matriz_Dispersa.densa_a_dispersa(c)
+            end
+            c
+        end
+            
+        # Producto de matrices
+        def *(other)
+            raise ArgumentError , 'El argumento debe ser una matriz' unless other.is_a? Numeric or other.is_a? Matriz
+    
+            # Si el arguento es un numero
+            if(other.is_a? Numeric)
+                c = Matriz_Densa.new(@fil, @col)
+                i = 0
+                while(i < @fil)
+                    j = 0
+                    while(j < @col)
+                        c.matrix[i][j] = get(i,j) * other
+                        j += 1
+                    end
+                    i += 1
+                end
+            # Si el argumento es una matriz
+            else
+                raise ArgumentError , 'Matriz no compatible (A.fil == B.col)' unless @col == other.fil
+                c = Matriz_Densa.new(@fil, other.col)
+                i = 0
+                while(i < @fil)
+                    j = 0
+                    while(j < other.fil)
+                        k = 0
+                        c.matrix[i][j] = 0
+                        while(k < @col)
+                            c.matrix[i][j] = c.matrix[i][j] + (get(i,j) * other.get(i,j))
+                            k += 1
+                        end
+                        j += 1
+                    end
+                    i += 1
+                end
+            end
+            
+            # Si el resultado es una matriz dispersa se convierte la densa
+            if(c.porcentaje_nulos > 0.6)
+                c = Matriz_Dispersa.densa_a_dispersa(c)
+            end  
+            c
+        end
+          
+        # Calcula el valor maximo de la matriz dispersa
+        def max
+            # Si toda la matriz es 0, el maximo sera 0
+            if(porcentaje_nulos == 1.0)
+                return 0
+            end
+                
+            max = nil
+            
+            # Asignar al primer valor no-nulo de la matriz (el primero que encuentre hasta que deje de ser nil)
+            i = 0
+            while(max == nil)
+                if(@matrix[i].size != 0)
+                    max = @matrix[i].values[0]
+                end
+                i += 1
+            end
+            
+            # Iterar por todos los elementos no nulos para encontrar el maximo
+            i = 0
+            while(i < @matrix.size)
+                if(@matrix[i].values.max != nil and @matrix[i].values.max > max)
+                    max = @matrix[i].values.max
+                end
+                i += 1
+            end
+            
+            max
+        end
+        
+        # Calcula el valor maximo de la matriz dispersa
+        def min
+            # Si toda la matriz es 0, el minimo sera 0
+            if (porcentaje_nulos == 1.0)
+                return 0
+            end
+
+            min = nil
+            
+            # Asignar al primer valor no-nulo de la matriz (el primero que encuentre hasta que deje de ser nil)
+            i = 0
+            while(min == nil)
+                if(@matrix[i].size != 0)
+                    min = @matrix[i].values[0]
+                end
+                i += 1
+            end
+            
+            # Iterar por todos los elementos no nulos para encontrar el maximo
+            i = 0
+            while(i < @matrix.size)
+                if(@matrix[i].values.min != nil and @matrix[i].values.min < min)
+                    min = @matrix[i].values.min
+                end
+            i += 1
+            end
+            
+            min
+        end
+    
+    end
+end

data/lib/matrix_expansion/version.rb

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

data/matrix_expansion.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/matrix_expansion/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Teno Gonzalez Dos Santos / Albano Jose Yanes Reyes"]
+  gem.email         = ["alu0100536829@ull.edu.es / alu0100457094@ull.edu.es"]
+  gem.description   = %q{Gema de matrices densas y dispersas}
+  gem.summary       = %q{Matrices densas y dispersas.}
+  gem.homepage      = "https://github.com/alu01005368291/prct10.git"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "matrix_expansion"
+  gem.require_paths = ["lib"]
+  gem.version       = MatrixExpansion::VERSION
+end

data/spec/matrix_spec.rb

@@ -0,0 +1,206 @@
+=begin
+*******************************************************************************************
+* Autores: 
+       Teno González Dos Santos
+       Albano José Yanes Reyes
+* Fecha: 19/11/2013 -
+* Asignatura: Lenguujes y Paradigmas de Programación
+* Tercero de Grado en Ingeniería Informática
+* Universidad de la Laguna
+*
+* Practica 10: Matrices densas y dispersas
+********************************************************************************************
+=end
+
+# Pruebas rspec
+
+require "./lib/matrix_expansion.rb"
+
+describe MatrixExpansion::Matriz do
+    before :each do
+        @m1 = MatrixExpansion::Matriz.new(5, 5)
+    end
+    describe " # Almacenamiento de matrices. " do
+        it " # Se debe almacenar el numero de filas." do
+            @m1.fil
+        end
+        it " # Se debe almacenar el numero de columnas." do
+            @m1.col
+        end
+        it " # Se debe almacenar un contenido." do
+            @m1.matrix
+        end
+    end
+end
+
+describe MatrixExpansion::Matriz_Densa do
+    
+    before :each do
+        @m1 = MatrixExpansion::Matriz_Densa.new(2,2)
+        @m2 = MatrixExpansion::Matriz_Densa.new(2,2)
+        @m3 = MatrixExpansion::Matriz_Densa.new(2,2)
+        @m4 = MatrixExpansion::Matriz_Densa.new(2,2)
+        
+        @m1.set_valores_num
+        @m2.set_valores_num
+        @m3.set_valores_fracc
+        @m4.set_valores_fracc
+        
+    end
+    describe " # Almacenamiento de matrices. " do
+        it " # Se debe poder acceder a los datos almacenados en la matriz " do      
+            @m1.matrix[0][0].should eq(1)
+            @m1.matrix[0][1].should eq(2)
+        end
+        it " # Se deben poder modificar los datos almacenados en la matriz " do     
+            @m1.matrix[0][0] = 5
+            @m1.matrix[0][0].should eq(5)
+            
+            @m1.matrix[0][1] = 8
+            @m1.matrix[0][1].should eq(8)
+        end
+    end
+
+    describe " # Representacion de la matriz." do
+        it " # Mostrar la matriz con numeros." do
+            @m1.to_s.should == "1\t2\t\n3\t4\t\n"
+        end
+        
+        it " # Mostrar la matriz con fracciones. " do
+            @m3.to_s.should == "1/2\t2/3\t\n3/4\t4/5\t\n"
+        end 
+    end
+    
+    describe " # Operaciones con matrices. " do
+        it " # Suma de matrices. " do
+            (@m1 + @m2).to_s.should == "2\t4\t\n6\t8\t\n"
+            (@m3 + @m4).to_s.should == "1/1\t4/3\t\n3/2\t8/5\t\n"
+        end
+        
+        it " # Resta de matrices." do
+            (@m1 - @m2).to_s.should == "0\t0\t\n0\t0\t\n"
+            (@m3 - @m4).to_s.should == "0/1\t0/1\t\n0/1\t0/1\t\n"
+        end
+        
+        it " # Producto de matrices." do
+            (@m1 * @m2).to_s.should == "7\t10\t\n15\t22\t\n"
+            (@m3 * @m4).to_s.should == "3/4\t13/15\t\n39/40\t57/50\t\n"
+        end
+        
+        it " # Suma de matrices de fracciones y numeros." do
+            (@m1 + @m3).to_s.should == "3/2\t8/3\t\n15/4\t24/5\t\n"
+        end
+        
+        it " # Resta de matrices de fracciones y numeros." do
+            (@m1 - @m3).to_s.should == "1/2\t4/3\t\n9/4\t16/5\t\n"
+        end
+        
+        it " # Producto de matrices de fracciones y numeros." do
+            (@m1 * @m3).to_s.should == "2/1\t34/15\t\n9/2\t26/5\t\n"
+        end
+    end
+    
+    describe " # Otras operaciones. " do
+        it " # Minimo de una matriz. " do
+            @m1.min.should eq(1)
+            @m3.min.to_s.should eq("1/2")
+        end
+        
+        it " # Maximo de una matriz. " do
+            @m1.max.should eq(4)
+            @m3.max.to_s.should eq("4/5")
+        end
+    end
+    
+end
+
+
+describe MatrixExpansion::Matriz_Densa do
+    
+    before :each do
+        @mden = MatrixExpansion::Matriz_Densa.new(2,2)
+        @mden.matrix[0][1] = 3
+        
+        @mdis1 = MatrixExpansion::Matriz_Dispersa.densa_a_dispersa(@mden)
+        
+        @mdis2 = MatrixExpansion::Matriz_Dispersa.new(2,2)
+        @mdis2.set(1,1,2)
+        
+        @mdis3 = MatrixExpansion::Matriz_Dispersa.new(2,2)
+        @mdis3.set(1,1,Fraccion.new(1,2))
+        
+    end
+    describe " # Almacenamiento de matrices. " do
+        it " # Se debe poder crear matrices dispersas vacias o a partir de matrices densas." do     
+            MatrixExpansion::Matriz_Dispersa.new(5, 5)
+            MatrixExpansion::Matriz_Dispersa.densa_a_dispersa(@mden)
+        end
+        it " # Se debe poder acceder a los datos almacenados en la matriz " do      
+            @mdis1.get(0,1).should eq(3)
+            @mdis2.get(1,1).should eq(2)
+        end
+        it " # Se deben poder modificar los datos almacenados en la matriz " do     
+            @mdis1.set(0,1,5)
+            @mdis1.get(0,1).should eq(5)
+            
+            @mdis2.set(1,1,8)
+            @mdis2.get(1,1).should eq(8)
+        end
+    end
+
+    describe " # Representacion de la matriz." do
+        it " # Mostrar la matriz con numeros." do
+            @mdis1.to_s.should == "(0,1)=>3 \n\n"
+        end
+        
+        it " # Mostrar la matriz con fracciones. " do
+            @mdis3.to_s.should == "\n(1,1)=>1/2 \n"
+        end 
+    end
+    describe " # Operaciones con matrices. " do
+        it " # Suma de matrices. " do
+            (@mdis1 + @mdis2).to_s.should == "0\t3\t\n0\t2\t\n"
+            (@mdis3 + @mdis3).to_s.should == "\n(1,1)=>1/1 \n"
+        end
+        
+        it " # Resta de matrices." do
+            (@mdis1 - @mdis2).to_s.should == "0\t3\t\n0\t-2\t\n"
+            (@mdis3 - @mdis3).to_s.should == "\n\n"
+        end
+        
+        it " # Producto de matrices." do
+            (@mdis1 * @mdis1).to_s.should == "(0,1)=>18 \n\n"
+            (@mdis3 * @mdis3).to_s.should == "\n(1,1)=>1/2 \n"
+        end
+        
+        it " # Suma de matrices de fracciones y numeros." do
+            (@mdis2 + @mdis3).to_s.should == "\n(1,1)=>5/2 \n"
+        end
+        
+        it " # Resta de matrices de fracciones y numeros." do
+            (@mdis2 - @mdis3).to_s.should == "\n(1,1)=>3/2 \n"
+        end
+        
+        it " # Producto de matrices de fracciones y numeros." do
+            (@mdis2 * @mdis3).to_s.should == "\n(1,1)=>2/1 \n"
+        end
+    end
+    
+    describe " # Otras operaciones. " do
+        it " # Minimo de una matriz. " do
+            @mdis1.min.should eq(3)
+            @mdis3.min.to_s.should eq("1/2")
+        end
+        
+        it " # Maximo de una matriz. " do
+            @mdis1.max.should eq(3)
+            @mdis3.max.to_s.should eq("1/2")
+        end
+    end
+        
+    
+    
+
+    
+    
+end

data/test/tc_matrix.rb

@@ -0,0 +1,87 @@
+=begin
+*******************************************************************************************
+* Autores: 
+       Teno González Dos Santos
+       Albano José Yanes Reyes
+* Fecha: 19/11/2013 -
+* Asignatura: Lenguujes y Paradigmas de Programación
+* Tercero de Grado en Ingeniería Informática
+* Universidad de la Laguna
+*
+* Practica 10: Matrices densas y dispersas
+********************************************************************************************
+=end
+
+# Clase Test_Matriz
+
+require "./lib/matrix_expansion.rb"
+require "test/unit"
+       
+        
+
+class Test_Matriz < Test::Unit::TestCase
+        def setup
+            
+            #matrices densas
+            @m1 = MatrixExpansion::Matriz_Densa.new(2,2)
+            @m2 = MatrixExpansion::Matriz_Densa.new(2,2)
+            @m3 = MatrixExpansion::Matriz_Densa.new(2,2)
+    
+            @m1.set_valores_num
+            
+            @m2.set_valores_num
+
+            @m3.matrix[0][0] = 2
+            @m3.matrix[0][1] = 4
+            @m3.matrix[1][0] = 6
+            @m3.matrix[1][1] = 8
+            
+            #matrices dispersas
+            @md1 = MatrixExpansion::Matriz_Dispersa.new(2,2)
+            @md2 = MatrixExpansion::Matriz_Dispersa.new(2,2)
+            @md3 = MatrixExpansion::Matriz_Dispersa.new(2,2)
+
+            @md1.set(0,0,0)
+            @md1.set(0,1,0)
+            @md1.set(1,0,5)
+            @md1.set(1,1,0)
+
+            @md2.set(0,0,0)
+            @md2.set(0,1,0)
+            @md2.set(1,0,3)
+            @md2.set(1,1,0)
+
+            @md3.set(0,0,0)
+            @md3.set(0,1,0)
+            @md3.set(1,0,2)
+            @md3.set(1,1,0)
+            
+            #matrices densas para provocar fallo typecheck
+            @merr1 = MatrixExpansion::Matriz_Densa.new(1,1)
+            @merr2 = MatrixExpansion::Matriz_Densa.new(1,1)
+            @merr1.matrix[0][0] = 5
+            @merr2.matrix[0][0] ="error"
+            
+            
+            #matrices densas para provocar error en valor de argumentos
+            @mfail1 = MatrixExpansion::Matriz_Densa.new(1,1)
+            @mfail2 = MatrixExpansion::Matriz_Densa.new(2,2)
+            
+        end
+    
+        def test_simple
+            assert_equal(@m3.to_s,(@m1+@m2).to_s)
+        end
+        
+        def test_simple2
+            assert_equal(@md3.to_s,(@md1-@md2).to_s)
+        end
+        
+        def test_typecheck
+            assert_raise(TypeError) {@merr1+@merr2}
+        end
+        
+        def test_failure
+            assert_raise(ArgumentError) {@mfail1*@mfail2}
+        end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: matrix_expansion
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Teno Gonzalez Dos Santos / Albano Jose Yanes Reyes
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-20 00:00:00.000000000 Z
+dependencies: []
+description: Gema de matrices densas y dispersas
+email:
+- alu0100536829@ull.edu.es / alu0100457094@ull.edu.es
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/matrix_expansion.rb
+- lib/matrix_expansion/fraccion.rb
+- lib/matrix_expansion/gcd.rb
+- lib/matrix_expansion/matrix.rb
+- lib/matrix_expansion/matrix_densa.rb
+- lib/matrix_expansion/matrix_dispersa.rb
+- lib/matrix_expansion/version.rb
+- matrix_expansion.gemspec
+- spec/matrix_spec.rb
+- test/tc_matrix.rb
+homepage: https://github.com/alu01005368291/prct10.git
+licenses: []
+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.24
+signing_key: 
+specification_version: 3
+summary: Matrices densas y dispersas.
+test_files:
+- spec/matrix_spec.rb
+- test/tc_matrix.rb