matrixlpp 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ea46f16e3c9bd15e46bddeeac8e55b2c57d97883
+  data.tar.gz: 7784518a30bd7feb9e3a7aa811682d8a42930b28
+SHA512:
+  metadata.gz: 40325a5a4ab29487ab37dda1fed9e7f5294056dfd021ce085afed6c0182458a64e37f111a3198071de9a55ee461d3e7519faa0c9558f39d2e21447448533e3df
+  data.tar.gz: b28718eccabd7ba18307853d50b1ffe1d31b16f11f31031e77523c6116660e1a0c1ef31e927454953d32ea7a7bf3c9e50f84117153b62d097c769d206e7e3f2a

data/.gitignore

@@ -0,0 +1,19 @@
+*.DS_Store
+*.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/Gemfile

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

data/Guarfile

@@ -0,0 +1,9 @@
+guard 'bundler' do
+  watch('Gemfile')
+end
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^test/.+tc_\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/matriz_spec.rb" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Javier Mena Mena, Diego Williams Aguilar Montaño
+
+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,19 @@
+Práctica de Laboratorio #11
+===========================
+
+
+Equipo-DJ 
+---------
+Diego Williams Aguilar Montaño   
+Javier Mena Mena
+
+Descripción de la práctica
+--------------------------
+Esta práctica en equipo consiste documentar la gema (utlizando RDOC) y desarrollar métodos con la filosofía de la programación funcional para la representación de Matrices de prácticas anteriores.  
+
+
+---
+
+Universidad de La Laguna  
+Escuela Técnica Superior de Ingeniería Informática  
+Lenguajes y Paradigmas de la Programación 2013-14

data/Rakefile

@@ -0,0 +1,24 @@
+$:.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 "Espectativas de la clase Matriz" 
+task :test do
+        sh "rspec -I. spec/matriz_spec.rb --format documentation"
+end
+
+desc "Espectativas de la clase Matriz, con documentacion HTML"
+task :thtml do
+        sh "rspec -I. spec/matriz_spec.rb --format html"
+end
+
+desc "Pruebas unitarias de las clases Matriz_Densa y Matriz_Dispersa" 
+task :tc do
+        sh "ruby -I. test/tc_matrixlpp.rb"
+end

data/lib/matrixlpp/gcd.rb

@@ -0,0 +1,10 @@
+module Matrixlpp
+# Este método devolverá el máximo común divisor entre los parámetros a y b
+  def self.gcd(a, b)
+    a, b = a.abs, b.abs
+    while b != 0
+      a, b = b, a % b
+    end
+    a
+  end
+end

data/lib/matrixlpp/matriz.rb

@@ -0,0 +1,33 @@
+require './lib/matrixlpp/racional.rb'
+
+module Matrixlpp
+# Esta clase contendrá el número de filas y columnas de la matriz.
+  class Matriz
+    # Número de filas.
+    attr_reader :N
+    # Número de columnas.
+    attr_reader :M 
+    # Vector que contendrá los datos de la matriz.
+    attr_reader :contenido
+    
+    # Constructor de la matriz. Crea una matriz de tamaño N*M sin contenido, inicializando sólo N y M.
+    # * *Argumentos*    :
+    #   - +n+: Número de filas. Debe ser mayor que 0.
+    #   - +m+: Número de columnas. Debe ser mayor que 0.
+    def initialize(n, m)
+      raise ArgumentError, 'Indice no valido' unless n.is_a? Fixnum and n > 0 and m.is_a? Fixnum and m > 0
+    
+      @N, @M = n, m
+    end
+    
+    # Método que permite acceder a un elemento de la matriz. Devuelve _nil_. Redefinido en clases hijas.
+    def get(i, j)
+      nil
+    end
+    # Método que permite almacenar un elemento en la matriz. Devuelve _nil_. Redefinido en clases hijas.
+    def set(i, j, val)
+      nil
+    end
+
+  end
+end

data/lib/matrixlpp/matriz_densa.rb

@@ -0,0 +1,138 @@
+require "./lib/matrixlpp/matriz.rb"
+
+module Matrixlpp
+  # Esta clase permite representar matrices densas. Las matrices densas son aquellas que no tienen más de un 60% de elementos nulos.
+  # Su representación será muy similar a como se suelen representar tradicionalmente.
+  class Matriz_Densa < Matriz
+    # Constructor de la matriz. Crea una matriz de tamaño N*M inicializada a valores nulos.
+    # * *Argumentos*    :
+    #   - +n+: Número de filas. Debe ser mayor que 0.
+    #   - +m+: Número de columnas. Debe ser mayor que 0.
+    def initialize(n, m)
+      super
+      
+      @contenido = Array.new(@N,0)
+      i = 0
+      while i < @N
+        @contenido[i] = Array.new(@M,0)
+        i += 1  
+      end
+    end
+    # Permite obtener el elemento en la posición (i,j), donde:
+    # * *Argumentos*    :
+    #   - +i+: Número de fila.
+    #   - +j+: Número de columna.
+    #   - +value+: Valor a insertar en la matriz.
+    # * *Devuelve*    :
+    #   - Valor almacenado en la fila +i+ y en la columna +j+. Devuelve nil si +i+ o +j+ están fuera de rango.
+    def get(i, j)
+      if( i < 0 or i >=@N or j < 0 or j >= @M)
+        return nil
+      end
+
+      @contenido[i][j]
+    end
+    # Devuelve el porcentaje de valores nulos que hay en la matriz.
+    # * *Devuelve*    :
+    #   - Número flotante entre 0 y 1 que represente cuantos valores nulos existen en la matriz densa.
+   def null_percent
+      total = @N*@M
+      no_nulos = 0
+      
+      i = 0
+      while(i < @N)
+        j = 0
+        while(j < @M)
+          if(@contenido[i][j] != @contenido[i][j].class.null)
+            no_nulos += 1
+	  end
+          j += 1
+        end
+        i += 1
+      end
+      
+      nulos = total - no_nulos
+      nulos.to_f/total.to_f
+    end #-- #endmethod null_percent  #++
+
+    # Establece el valor _value_ en la posición (i,j) de la matriz, donde:
+    # * *Argumentos*    :
+    #   - +i+: Número de fila.
+    #   - +j+: Número de columna.
+    #   - +value+: Valor a insertar en la matriz.
+    
+    def set(i, j, value)
+      if( i < 0 or i >=@N or j < 0 or j >= @M)
+       return nil
+      end
+        
+      if(!(value.class.respond_to? :null))
+        puts "Se debe definir el metodo \"null\" que devuelva un elemento nulo para la clase #{value.class}"
+        return nil
+      end
+      #--
+      # Contar elementos nulos y comprobar si se hace una matriz dispersa
+      # De momento, no dejamos añadir elementos nulos
+      # ¿o si?
+      #if(value != nil and value != value.class.null) # Y se puede comprobar para todos los tipos si es necesario. (con un método zero, por ejemplo)
+        @contenido[i][j] = value
+      #end 
+      #++
+    end
+    # Permite representar de manera gráfica la matriz por consola.
+    # * *Devuelve*    :
+    #   - Objeto del tipo string con todos los elementos de la matriz.
+    def to_s
+      s = ""
+      i = 0
+      while(i < @N)
+        j = 0
+        while(j < @M)
+          s += "#{@contenido[i][j].to_s}\t"
+          j += 1
+        end
+        s += "\n"
+        i += 1
+      end
+      s
+    end
+    
+    # Devuelve el máximo valor almacenado en la matriz.
+    # * *Devuelve*    :
+    #   - Valor máximo almacenado en la matriz.
+    def max
+	m = get(0,0)
+        i = 0
+	while(i < @N)
+		j = 0
+		while(j < @M)
+			if (get(i,j) > m)
+				m = get(i,j)
+			end
+			j += 1
+		end
+		i += 1
+	end
+	m
+    end
+    
+    # Devuelve el mínimo valor almacenado en la matriz.
+    # * *Devuelve*    :
+    #   - Valor mínimo almacenado en la matriz.
+    def min
+	m = get(0,0)
+        i = 0
+	while(i < @N)
+		j = 0
+		while(j < @M)
+			if (get(i,j) < m)
+				m = get(i,j)
+			end
+			j += 1
+		end
+		i += 1
+	end
+	m
+    end #-- # Method min
+  end # Class
+end # Module #++

data/lib/matrixlpp/matriz_dispersa.rb

@@ -0,0 +1,199 @@
+require "./lib/matrixlpp/matriz.rb"
+require "./lib/matrixlpp/matriz_densa.rb"
+
+module Matrixlpp
+  # Esta clase permite representar matrices dispersas. Estas matrices tendrán un 60% o más de valores nulos.
+  # La representación se hará por filas que no tengan elementos nulos, indicando para cada una de ellas qué elementos son no nulos.
+  class Matriz_Dispersa < Matriz  
+    # Rellena el array de contenido de la matriz con hashes vacíos. Equivale a una matriz con un 100% de elementos nulos.
+    def reset
+      @contenido = Array.new(@N) #-- # Array con @N filas y ninguna columna (vacio) #++
+      i = 0
+      while(i < @N)
+        @contenido[i] = {}
+        i += 1
+      end
+    end
+    # Constructor de la matriz. Crea una matriz dispersa de tamaño N*M vacía (Array de hashes vacíos).
+    # * *Argumentos*    :
+    #   - +n+: Número de filas. Debe ser mayor que 0.
+    #   - +m+: Número de columnas. Debe ser mayor que 0.
+    def initialize(n, m)
+      super
+      reset
+    end
+    
+    # Se devuelve una matriz dispersa a partir de otra matriz pasada por parámetro con los mismos valores. Metodo factoria. 
+    # * *Argumentos*    :
+    #   - +matriz+: Matriz densa. Si sólo tiene valores nulos, la matriz actual se inicializará a vacío.
+    # * *Devuelve*    :
+    #   - +obj+: Referencia al objeto creado.
+    def self.copy(matriz)
+      raise ArgumentError, 'Tipo invalido' unless matriz.is_a? Matrixlpp::Matriz_Densa
+      obj = new(matriz.N, matriz.M)
+    
+      i = 0
+      while(i < matriz.N)
+        j = 0
+        while(j < matriz.M)
+          value = matriz.get(i,j)
+          raise RuntimeError , "No se ha definido \"null\" para la clase #{value.class}" unless value.class.respond_to? :null
+          
+          if( value != value.class.null)
+            obj.contenido[i][j] = value
+          end #-- #endif 
+          j += 1
+        end #endwhile j
+        i += 1
+      end #endwhile i
+      obj
+    end #endmethod copy #++
+    
+    # Devuelve el porcentaje de elementos nulos que tiene la matriz.
+    # * *Devuelve*    :
+    #   - Número flotante entre 0 y 1 que represente cuantos valores nulos existen en la matriz densa.
+    def null_percent
+      total = @N*@M
+      no_nulos = 0
+      
+      i = 0
+      while(i < @N)
+        no_nulos += @contenido[i].size #-- # Nunca habra elementos nulos en alguna fila #++
+        i += 1
+      end
+      
+      nulos = total - no_nulos
+      nulos.to_f/total.to_f
+    end #-- #endmethod null_percent #++
+    # Permite obtener el elemento en la posición (i,j), donde:
+    # * *Argumentos*    :
+    #   - +i+: Número de fila.
+    #   - +j+: Número de columna.
+    # * *Devuelve*    :
+    #   - Valor almacenado en la fila +i+ y en la columna +j+. Devuelve nil si +i+ o +j+ están fuera de rango. Devuelve 0 (valor nulo) si no existe el elemento en la matriz.
+    def get(i, j)
+      if( !(i.is_a? Fixnum) or i < 0 or i >=@N or !(j.is_a? Fixnum) or j < 0 or j >= @M)
+        return nil
+      end
+        
+      if(@contenido[i][j] != nil) #-- # Elemento no nulo (esta en el hash)
+        return @contenido[i][j]
+      else # Elemento nulo (no esta en el Hash)
+        return 0
+      end
+    end #endmethod get #++
+    # Establece el valor _value_ en la posición (i,j) de la matriz, donde:
+    # * *Argumentos*    :
+    #   - +i+: Número de fila.
+    #   - +j+: Número de columna.
+    #   - +value+: Valor a insertar en la matriz. Si se sobrepasa el número de valores nulos permitidos, no se harán modificaciones en la matriz.
+    def set(i, j, value)
+      if(!(value.class.respond_to? :null))
+        puts "Se debe definir el metodo \"null\" que devuelva un elemento nulo para la clase #{value.class}"
+        return nil
+      end
+      
+      if( !(i.is_a? Fixnum) or i < 0 or i >=@N or !(j.is_a? Fixnum) or j < 0 or j >= @M)
+        return nil
+      end
+      
+      if(value == nil or value == value.class.null)
+        @contenido[i].delete(j)  #-- # Borrar elemento (valor nulo) #++
+      else
+        @contenido[i][j] = value
+      end
+      
+      if(null_percent < 0.6) #-- # Si se ha sobrepasado el número de elementos nulos, borramos el último elemento modificado #++
+          @contenido[i].delete(j)
+          puts "Borrado el elemento #{i},#{j} por sobrepasar el numero de elementos no nulos (Porcentaje actual: #{null_percent}"
+      end
+      
+    end #-- #endmethod set #++
+    # Permite representar de manera gráfica la matriz por consola.
+    # * *Devuelve*    :
+    #   - Objeto del tipo string con todos los elementos de la matriz.
+    def to_s
+      #--
+      # Ejemplo: "Fila 0: \nFila 1: 0=>1 1=>3 \nFila 2: \n"
+      # 0 0
+      # 1 3
+      # 0 0
+      #++
+      i = 0
+      output = ""
+      while(i < @N)
+        output += "Fila #{i}: "
+        @contenido[i].sort.each{|k, v| output += "#{k.to_s}=>#{v.to_s} "}
+        output += "\n"
+        i += 1
+      end
+      output
+    end
+    
+    # Devuelve el máximo valor no nulo almacenado en la matriz.
+    # * *Devuelve*    :
+    #   - Valor máximo no nulo almacenado en la matriz.
+	def max
+	  if(null_percent == 1.0)
+	    return nil  #-- # o return 0 #++
+	  end
+	  #--
+	  # Valor máximo: si todos los elementos son menores que el elemento nulo
+	  # Se devolverá el mayor elemento no nulo.
+	  max = nil
+	  
+	  # Asignar al primer valor no-nulo de la matriz
+	  i = 0
+	  while(max == nil)
+	    if(@contenido[i].size != 0)
+		  max = @contenido[i].values[0]
+		end
+		i += 1
+	  end
+	  
+	  # Iterar por todos los elementos no nulos para encontrar el maximo
+	  i = 0
+	  while(i < @contenido.size)
+	    if(@contenido[i].values.max != nil and @contenido[i].values.max > max)
+		  max = @contenido[i].values.max
+		end
+	    i += 1
+	  end
+	  
+	  max
+	end #++
+    # Devuelve el mínimo valor no nulo almacenado en la matriz.
+    # * *Devuelve*    :
+    #   - Valor mínimo no nulo almacenado en la matriz.
+	def min
+	  if(null_percent == 1.0)
+	    return nil #-- # o return 0 #++
+	  end
+	  # --
+	  # Valor máximo: si todos los elementos son menores que el elemento nulo
+	  # Se devolverá el mayor elemento no nulo.
+	  min = nil
+	  
+	  # Asignar al primer valor no-nulo de la matriz
+	  i = 0
+	  while(min == nil)
+	    if(@contenido[i].size != 0)
+		  min = @contenido[i].values[0]
+		end
+		i += 1
+	  end
+	  
+	  # Iterar por todos los elementos no nulos para encontrar el maximo
+	  i = 0
+	  while(i < @contenido.size)
+	    if(@contenido[i].values.min != nil and @contenido[i].values.min < min)
+		  min = @contenido[i].values.min
+		end
+	    i += 1
+	  end
+	  
+	  min
+    end 
+    
+  end #endclass
+end #end module #++

data/lib/matrixlpp/matriz_operaciones.rb

@@ -0,0 +1,91 @@
+require "./lib/matrixlpp/matriz.rb"
+require "./lib/matrixlpp/matriz_dispersa.rb"
+require "./lib/matrixlpp/matriz_densa.rb"
+
+module Matrixlpp
+  class Matriz  
+    # Permite sumar matrices (dispersas o densas) de iguales dimensiones.
+    # * *Argumentos*    :
+    #   - +other+: Matriz densa o dispersa. Debe ser de igual tamaño que la actual.
+    # * *Devuelve*    :
+    #   - Matriz de tamaño N*M resultado de la suma de la matriz actual con +other+. Si el porcentaje de valores nulos es mayor al 60%, se devuelve una matriz dispersa. Si no, se devuelve una matriz densa.
+    def +(other)
+      raise ArgumentError , 'Tipo invalido' unless other.is_a? Matriz
+      raise ArgumentError , 'Matriz no compatible' unless @N == other.N and @M == other.M
+      c = Matriz_Densa.new(@N, @M)
+      
+      #(0...@N).each do |i|
+        #(0...@M).each do |j|
+      (@N).times do |i|
+        (@M).times do |j|
+          c.set(i, j, get(i,j) + other.get(i,j))
+        end
+      end
+      
+      if (c.null_percent > 0.6)
+        return Matrixlpp::Matriz_Dispersa.copy(c)
+      else
+        return c
+      end 
+    end # +(other) #++
+    
+    # Permite restar matrices (dispersas o densas) de iguales dimensiones.
+    # * *Argumentos*    :
+    #   - +other+: Matriz densa o dispersa. Debe ser de igual tamaño que la actual.
+    # * *Devuelve*    :
+    #   - Matriz de tamaño N*M resultado de la resta de la matriz actual con +other+. Si el porcentaje de valores nulos es mayor al 60%, se devuelve una matriz dispersa. Si no, se devuelve una matriz densa.
+    def -(other)
+      raise ArgumentError , 'Tipo invalido' unless other.is_a? Matriz
+      raise ArgumentError , 'Matriz no compatible' unless @N == other.N and @M == other.M
+      c = Matriz_Densa.new(@N, @M)
+      
+      (@N).times do |i|
+        (@M).times do |j|
+          c.set(i, j, get(i,j) - other.get(i,j))
+        end
+      end
+      
+      if (c.null_percent > 0.6)
+        return Matrixlpp::Matriz_Dispersa.copy(c)
+      else
+        return c
+      end 
+    end # -(other) #++
+    
+    # Permite multiplicar un elemento a una matriz.
+    def *(other)
+      raise ArgumentError , 'Parametro invalido' unless other.is_a? Numeric or other.is_a? Matriz
+
+      if(other.is_a? Numeric) # Matriz * numero
+        c = Matriz_Densa.new(@N, @M)
+        
+        (@N).times do |i|
+          (@M).times do |j|
+            c.set(i, j, get(i,j)*other)
+          end
+        end
+      else # Matriz * Matriz
+        raise ArgumentError , 'Matriz no compatible (A.N == B.M)' unless @M == other.N
+        c = Matriz_Densa.new(@N, other.M)
+        
+        (@N).times do |i|
+          (other.M).times do |j|
+            buffer = (0...@M).inject(0) { |acc, k| get(i, k) * other.get(k,j) + acc }
+            c.set(i, j, buffer)
+            #(@M).times do |k|
+              # Esto NO es programación funcional...
+              # c.set(i, j, get(i, k) * other.get(k,j) + c.get(i,j))
+            #end
+          end
+        end
+      end
+
+      if (c.null_percent > 0.6)
+        return Matrixlpp::Matriz_Dispersa.copy(c)
+      else
+        return c
+      end
+    end # *(other) #++
+    
+  end
+end

data/lib/matrixlpp/racional.rb

@@ -0,0 +1,163 @@
+require "./lib/matrixlpp/gcd.rb"
+
+module Matrixlpp  
+# Esta clase permite representar números racionales de la forma _numerador/denominador_.
+  class Fraccion
+    #--
+    # Módulos usados
+    #++
+    include Comparable
+
+    #--
+    # Métodos principales
+    #++
+    # Los parámetros que se pasan son el numerador y el denominador, respectivamente:
+    # * *x*: Numerador.
+    # * *y*: Denominador.
+      def initialize(x,y)
+          raise ArgumentError , 'Argumentos no enteros.' unless x.is_a? Fixnum and y.is_a? Fixnum
+          raise ArgumentError , 'Denominador nulo.' unless y != 0
+
+          @num, @den = x, y
+          reducir
+          #--
+          # En caso de ser negativa, la fracción será -a/b, y no a/(-b)
+          #++
+          if(@num < 0 && @den < 0)
+              @num = -@num
+              @den = -@den
+          elsif(@den < 0)
+              @den = -@den
+              @num = -@num
+          end
+      end
+    # Devuelve el valor del numerador.
+      def num()
+          @num
+      end
+    # Devuelve el valor del denominador.
+      def den()
+          @den
+      end
+    # Este método permite invertir el orden de los operandos para posibilitar las operaciones aritméticas.
+      def coerce(other)
+          [Fraccion.new(other,1),self]  
+      end
+    # Devuelve la fracción nula (con valor 0) _0/1_.
+      def self.null
+          Fraccion.new(0,1)
+      end
+    # Devuelve la representación de la fracción como "_numerador/denominador_".
+      def to_s
+          "#{@num}/#{@den}"
+      end
+    # Reduce la fracción a su mínima expresión.
+      def reducir
+          mcd = Matrixlpp::gcd(@num,@den)
+          @num = @num / mcd
+          @den = @den / mcd
+      end
+    # Permite usar números en representación de punto flotante en el numerador y en el denominador.
+      def to_f
+          @num.to_f/@den.to_f
+      end
+    
+    #--
+    # Operadores unarios
+    #++
+    
+    # Devulve el valor absoluto de una fracción
+      def abs
+          a, b = @num, @den
+          if @num < 0
+              a = @num * (-1)
+          end
+          if @den < 0
+              b = @den * (-1)
+          end
+          Fraccion.new(a.to_i,b.to_i)
+      end
+    # Devuelve la fracción recíproca.
+      def reciprocal
+          aux = @num
+          @num = @den
+          @den = aux
+          Fraccion.new(@num,@den)
+      end
+    # Devuelve la fracción con signo negativo.
+      def -@ # Operación negación
+          Fraccion.new(-@num, @den)
+      end
+    
+    #--
+    # Operadores aritméticos
+    #++
+
+    # Permite sumar otro elemento a una fracción.
+      def +(other) #-- # Operación suma #++
+          if(other.respond_to? :den and other.respond_to? :num)
+            Fraccion.new(@num*other.den + @den*other.num, @den*other.den) # a/b + c/d = (a*d + b*c)/(b*d)
+          else
+            Fraccion.new(@num + @den*other, @den) # a/b + c = (a + b*c)/b
+          end
+      end
+    # Permite restar otro elemento a una fracción.
+      def -(other) #-- # Operación resta #++
+          if(other.respond_to? :den and other.respond_to? :num)
+            Fraccion.new(@num*other.den - @den*other.num, @den*other.den) # a/b - c/d = (a*d - b*c)/(b*d)
+          else
+            Fraccion.new(@num - @den*other, @den) # a/b - c = (a - b*c)/b
+          end
+      end
+    # Permite multiplicar otro elemento a una fracción.
+      def *(other) #-- # Operación producto #++
+          if(other.respond_to? :den and other.respond_to? :num)
+            if(@num*other.num == 0)
+              Fraccion.null
+            else
+              Fraccion.new(@num*other.num, @den*other.den) # a/b * c/d = (a*c)/(b*d)
+            end
+          else
+            Fraccion.new(@num*other, @den)  # a/b * c = (a*c)/b
+          end
+      end
+    # Permite dividir otro elemento a una fracción.
+      def /(other) #-- # Operación división #++
+          if(other.respond_to? :den and other.respond_to? :num)
+            if(other.num == 0)
+              Fraccion.null
+            else
+              Fraccion.new(@num*other.den, @den*other.num) # a/b / c/d = (a*d)/(b*c)
+            end
+          else
+            if(other == 0)
+              Fraccion.null
+            else
+              Fraccion.new(@num, @den*other)
+            end
+          end
+      end
+    # Permite obtener el resto entre la división de una fracción y otro elemento.
+      def %(other) #-- # Operación módulo #++
+          raise ArgumentError, 'Argumento no racional' unless other.is_a? Fraccion
+    
+          Fraccion.new(0,1) #-- # Resto de una división de fracciones = siempre nulo (0/1) #++
+      end
+   
+    #--
+    # Operadores comparacionales
+    #++
+
+    # Este método permite hacer operaciones comparacionales entre una fracción y otro elemento.
+      def <=> (other)
+          #-- #raise ArgumentError, 'Argumento no racional' unless other.is_a? Fraccion #++
+        
+          #-- # a/b <=> c/d -> (a*d)/(b*d) <=> (c*b)/(d*b) -> a*d <=> c*b #++
+          if(other.respond_to? :den and other.respond_to? :num)
+            (@num * other.den) <=> (other.num * @den)
+          else
+            (@num.to_f / @den.to_f) <=> (other)
+          end
+      end
+  end
+end

data/lib/matrixlpp/version.rb

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

data/lib/matrixlpp.rb

@@ -0,0 +1,13 @@
+require "./lib/matrixlpp/version"
+require "./lib/matrixlpp/matriz.rb"
+require "./lib/matrixlpp/matriz_densa.rb"
+require "./lib/matrixlpp/matriz_dispersa.rb"
+require "./lib/matrixlpp/matriz_operaciones.rb"
+
+require "./lib/matrixlpp/racional.rb"
+require "./lib/matrixlpp/gcd.rb"
+
+
+module Matrixlpp
+  # Your code goes here...
+end

data/matrixlpp.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'matrixlpp/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "matrixlpp"
+  spec.version       = Matrixlpp::VERSION
+  spec.authors       = ["Javier Mena Mena", "Diego Williams Aguilar Montaño"]
+  spec.email         = ["alu0100454741@ull.edu.es","alu0100592368@ull.edu.es"]
+  spec.description   = %q{Esta es una clase Matrix}
+  spec.summary       = %q{Contiene todo lo necesario para definir una clase matrix}
+  spec.homepage      = "https://github.com/alu0100454741/EquipoDJ-prct11"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/spec/matriz_spec.rb

@@ -0,0 +1,342 @@
+require "./lib/matrixlpp.rb"
+
+describe Matrixlpp::Matriz do
+    before :each do
+        @m1 = Matrixlpp::Matriz.new(5, 5)
+    end
+    describe " # Almacenamiento de matrices. " do
+        it " # Se debe almacenar el numero de filas." do
+            @m1.N
+        end
+        it " # Se debe almacenar el numero de columnas." do
+            @m1.M
+        end
+        it " # Se debe almacenar un contenido." do
+            @m1.contenido
+        end
+    end
+end
+
+describe Matrixlpp::Matriz_Densa do
+    before :all do
+        class Fixnum
+            def self.null
+                0
+            end
+        end
+        
+        class String
+            def self.null
+                ""
+            end
+        end
+        
+        class Float
+            def self.null
+                0.0
+            end
+        end
+        
+        # Etc
+    end
+    
+    before :each do
+        @m1 = Matrixlpp::Matriz_Densa.new(2,2)
+        @m2 = Matrixlpp::Matriz_Densa.new(2,2)
+        
+        @m1.set(0,0,1)
+        @m1.set(0,1,2)
+        @m1.set(1,0,3)
+        @m1.set(1,1,4)
+        
+        @m2.set(0,0,5)
+        @m2.set(0,1,6)
+        @m2.set(1,0,7)
+        @m2.set(1,1,8)
+        
+    end
+    describe " # Almacenamiento de matrices. " do
+        it " # Se debe poder acceder a los datos almacenados en la matriz " do      
+            @m1.get(0,0).should eq(1)
+            @m1.get(0,1).should eq(2)
+        end
+        it " # Se deben poder modificar los datos almacenados en la matriz " do     
+            @m1.set(0,0,5)
+            @m1.get(0,0).should eq(5)
+            
+            @m1.set(0,1,8)
+            @m1.get(0,1).should eq(8)
+        end
+        it " # Se deben poder almacenar todo tipo de datos numericos (flotantes, enteros, etc...) " do      
+            @m1.set(0,0,3.0)
+            @m1.set(0,1,-6)
+            @m1.to_s.should == "3.0\t-6\t\n3\t4\t\n"
+        end
+    end
+
+    describe " # Operaciones con matrices densas. " do
+    it " # Se debe poder sumar dos matrices " do
+        @m3 = Matrixlpp::Matriz_Densa.new(2,2)
+        @m3.set(0,0,6)
+        @m3.set(0,1,8)
+        @m3.set(1,0,10)
+        @m3.set(1,1,12)
+
+        (@m1+@m2).to_s.should eq(@m3.to_s)
+    end
+
+    it " # Se debe poder restar dos matrices " do
+        @m3 = Matrixlpp::Matriz_Densa.new(2,2)
+        @m3.set(0,0,4)
+        @m3.set(0,1,4)
+        @m3.set(1,0,4)
+        @m3.set(1,1,4)
+
+        (@m2-@m1).to_s.should eq(@m3.to_s)
+    end
+    it " # Se debe poder multiplicar dos matrices " do
+        @m3 = Matrixlpp::Matriz_Densa.new(2,2)
+        @m3.set(0,0,19)
+        @m3.set(0,1,22)
+        @m3.set(1,0,43)
+        @m3.set(1,1,50)
+
+        (@m1*@m2).to_s.should eq(@m3.to_s)
+    end
+    it " # Si una m. densa tiene mas de un 60% de nulos, debe ser dispersa." do
+	@m_neg = Matrixlpp::Matriz_Densa.new(2,2)
+	@m_neg.set(0,0,-1)
+	@m_neg.set(0,1,-2)
+	@m_neg.set(1,0,-3)
+	@m_neg.set(1,1,-1)
+
+	@m3 = Matrixlpp::Matriz_Dispersa.new(2,2)
+	@m3.set(1,1,3)
+
+	(@m1+@m_neg).to_s.should eq(@m3.to_s)
+    end
+    it " # Se debe poder operar con Fracciones." do
+	@mf = Matrixlpp::Matriz_Densa.new(2,2)
+	@mf.set(0,0,Matrixlpp::Fraccion.new(1,3))
+	@mf.set(0,1,Matrixlpp::Fraccion.new(1,3))
+	@mf.set(1,0,Matrixlpp::Fraccion.new(1,3))
+	@mf.set(1,1,Matrixlpp::Fraccion.new(1,3))
+
+	@mf_res = Matrixlpp::Matriz_Densa.new(2,2)
+	@mf_res.set(0,0,Matrixlpp::Fraccion.new(2,3))
+	@mf_res.set(0,1,Matrixlpp::Fraccion.new(2,3))
+	@mf_res.set(1,0,Matrixlpp::Fraccion.new(2,3))
+	@mf_res.set(1,1,Matrixlpp::Fraccion.new(2,3))
+
+	(@mf+@mf).to_s.should eq(@mf_res.to_s)
+    
+    @mf1 = Matrixlpp::Matriz_Densa.new(2,2)
+    @mf1.set(1,0,Matrixlpp::Fraccion.new(1,4))
+     
+    @mf2 = Matrixlpp::Matriz_Densa.new(2,2)
+    @mf2.set(0,0,1)
+    
+    @mf_res = Matrixlpp::Matriz_Dispersa.new(2,2)
+    @mf_res.set(1,0,Matrixlpp::Fraccion.new(1,4))
+        
+    (@mf1 * @mf2).to_s.should == @mf_res.to_s
+    
+    end
+    end
+    describe " # Operaciones varias. " do
+        it " # Se debe poder calcular el maximo de una matriz densa (elemento no nulo)" do
+		  @m1.max.should == 4
+		end
+		it " # Se debe poder calcular el minimo de una matriz densa (elemento no nulo)" do
+		  @m2.min.should == 5
+		end
+    end
+end
+
+
+describe Matrixlpp::Matriz_Dispersa do
+    before :all do
+        class Fixnum
+            def self.null
+                0
+            end
+        end
+        
+        class String
+            def self.null
+                ""
+            end
+        end
+        
+        class Float
+            def self.null
+                0.0
+            end
+        end
+        
+        # Etc
+    end
+    
+    before :each do
+        @m1 = Matrixlpp::Matriz_Densa.new(3,2)
+        
+        @m1.set(0,0,0)
+        @m1.set(0,1,0)
+        
+        @m1.set(1,0,1)
+        @m1.set(1,1,3)
+        
+        @m1.set(2,0,0)
+        @m1.set(2,1,0)
+        
+        @md1 = Matrixlpp::Matriz_Dispersa.copy(@m1)
+        @md2 = Matrixlpp::Matriz_Dispersa.new(3, 2)
+        
+    end
+    
+    describe " # Almacenamiento de matrices. " do
+        it " # Se debe poder crear matrices dispersas vacias o a partir de matrices densas." do     
+            Matrixlpp::Matriz_Dispersa.new(5, 5)
+            Matrixlpp::Matriz_Dispersa.copy(@m1)
+        end
+        
+        it " # Se debe poder calcular el porcentaje de elementos nulos de la matriz dispersa." do
+            @md2.null_percent.should == 1.0
+            @md1.null_percent.should == 4.0/6.0
+        end
+        
+        it " # Se debe poder acceder a los elementos de la matriz dispersa." do
+            @md2.get(0,0).should == 0
+            
+            @md1.get(1,1).should == 3
+            @md1.get(1,0).should == 1
+            @md1.get(0,0).should == 0
+            
+            @md1.get(10,10).should == nil
+        end
+        
+        it " # Se deben poder modificar los elementos de la matriz dispersa." do
+            @md2.set(0,0,1)
+            @md2.get(0,0).should == 1
+            
+            @md2.set(0,1,1)
+            @md2.set(1,0,1)
+            @md2.set(1,1,1)
+            @md2.set(2,0,1)
+            @md2.set(2,1,1)
+            
+            # Elemento nulo debido a que ha sobrepasado el porcentaje maximo de valores nulos
+            @md2.get(2,1).should == 0
+            
+            @md1.set(1,1,4)
+            @md1.set(1,0,2)
+            @md1.get(1,1).should == 4
+            @md1.get(1,0).should == 2
+            
+            @md1.get(0,0).should == 0
+        end
+        
+        it " # Se debe poder transformar una matriz dispersa a una cadena de caracteres." do
+            @md1.to_s.should == "Fila 0: \nFila 1: 0=>1 1=>3 \nFila 2: \n"
+            @md2.to_s.should == "Fila 0: \nFila 1: \nFila 2: \n"
+        end
+
+    
+    end
+
+    describe " # Operaciones con matrices dispersas. " do
+    it " # Se debe poder sumar dos matrices " do        
+        @md3 = Matrixlpp::Matriz_Dispersa.new(3,2)
+        @md3.set(0,0,0)
+        @md3.set(0,1,0)
+        @md3.set(1,0,1)
+        @md3.set(1,1,3)
+        @md3.set(2,0,0)
+        @md3.set(2,1,0)
+        
+        
+        (@md1+@md2).to_s.should eq(@md3.to_s)
+    end
+    it " # Se debe poder restar dos matrices " do
+        @md3 = Matrixlpp::Matriz_Dispersa.new(3,2)
+        @md3.set(0,0,0)
+        @md3.set(0,1,0)
+        @md3.set(1,0,-1)
+        @md3.set(1,1,-3)
+        @md3.set(2,0,0)
+        @md3.set(2,1,0)
+
+        (@md2-@md1).to_s.should eq(@md3.to_s)
+    end
+    it " # Se debe poder multiplicar dos matrices " do
+        @md4 = Matrixlpp::Matriz_Dispersa.new(2,3)
+        @md4.set(1,0,-1)
+        @md4.set(1,1,-1)
+        @md4.set(1,2,0)
+        
+        @md3 = Matrixlpp::Matriz_Dispersa.new(3,3)
+        @md3.set(0,0,0)
+        @md3.set(0,1,0)
+        @md3.set(0,2,0)
+        @md3.set(1,0,-3)
+        @md3.set(1,1,-3)
+        @md3.set(1,2,0)
+        @md3.set(2,0,0)
+        @md3.set(2,1,0)
+        @md3.set(2,2,0)
+
+        (@md1*@md4).to_s.should eq(@md3.to_s)
+    end
+    it " # Se debe poder hacer operaciones con Fracciones. " do
+	@mf1 = Matrixlpp::Matriz_Dispersa.new(2,2)
+	@mf1.set(1,0,Matrixlpp::Fraccion.new(1,4))
+
+	@mf2 = Matrixlpp::Matriz_Dispersa.new(2,2)
+	@mf2.set(1,0,Matrixlpp::Fraccion.new(-1,4))
+
+	@mf_res = Matrixlpp::Matriz_Dispersa.new(2,2)
+	@mf_res.set(1,0,Matrixlpp::Fraccion.new(1,2))
+
+	(@mf1-@mf2).to_s.should eq(@mf_res.to_s)
+    
+    
+     @mf3 = Matrixlpp::Matriz_Dispersa.new(2,2)
+     @mf3.set(1,0,Matrixlpp::Fraccion.new(1,4))
+     
+     @mf4 = Matrixlpp::Matriz_Dispersa.new(2,2)
+     @mf4.set(0,0,1)
+     
+     (@mf3 * @mf4).to_s.should == @mf3.to_s
+     
+     @mf5 = Matrixlpp::Matriz_Densa.new(2,2)
+     @mf6 = Matrixlpp::Matriz_Dispersa.new(2,2)
+
+     @mf5.set(0,0,3)
+     @mf5.set(0,1,4)
+     @mf5.set(1,0,5)
+     @mf5.set(1,1,6)
+
+     @mf6.set(0,0,Matrixlpp::Fraccion.new(1,2))
+
+     @mf_res2 = Matrixlpp::Matriz_Densa.new(2,2)
+     @mf_res2.set(0,0,Matrixlpp::Fraccion.new(7,2))
+     @mf_res2.set(0,1,4)
+     @mf_res2.set(1,0,5)
+     @mf_res2.set(1,1,6)
+
+     (@mf5+@mf6).to_s.should == @mf_res2.to_s
+    
+    end
+
+
+    end
+	    describe " # Operaciones varias. " do
+        it " # Se debe poder calcular el maximo de una matriz densa (elemento no nulo)" do
+		  @md1.set(1,0,4)
+		  @md1.max.should == 4
+		end
+		it " # Se debe poder calcular el minimo de una matriz densa (elemento no nulo)" do
+		  @md1.min.should == 1
+		end
+    end
+end

data/test/tc_matrixlpp.rb

@@ -0,0 +1,95 @@
+# Implementar en este fichero las Pruebas Unitarias de nuestra gema
+
+require "./lib/matrixlpp.rb"
+require "test/unit"
+
+# Fixnum
+class Fixnum
+        # Devuelve el valor nulo de la clase Fixnum (0).
+	def self.null
+       		0
+	end
+end
+#String        
+class String
+        # Devuelve el valor nulo de la clase String (cadena vacía).
+	def self.null
+       		""
+	end
+end
+#Float
+class Float
+        # Devuelve el valor nulo de la clase Float (0.0).
+	def self.null
+       		0.0
+	end
+end	
+	
+# Clase de pruebas unitarias.
+class Test_Matriz < Test::Unit::TestCase
+	# En este método se prueba que la suma de dos matrices densas @m1 y @m2 coincida con una matriz resultado densa @m3.
+        def test_simple
+		@m1 = Matrixlpp::Matriz_Densa.new(2,2)
+	        @m2 = Matrixlpp::Matriz_Densa.new(2,2)
+		@m3 = Matrixlpp::Matriz_Densa.new(2,2)
+        
+        	@m1.set(0,0,1)
+        	@m1.set(0,1,2)
+        	@m1.set(1,0,3)
+        	@m1.set(1,1,4)
+        	
+        	@m2.set(0,0,5)
+        	@m2.set(0,1,6)
+        	@m2.set(1,0,7)
+        	@m2.set(1,1,8)
+
+		@m3.set(0,0,6)
+		@m3.set(0,1,8)
+		@m3.set(1,0,10)
+		@m3.set(1,1,12)
+
+
+		assert_equal(@m3.to_s,(@m1+@m2).to_s)
+	end
+	# En este método se prueba que la resta entre dos matrices dispersas @md1 y @md2 coincida con una matriz dispersa resultado @m3.
+	def test_simple2
+		@md1 = Matrixlpp::Matriz_Dispersa.new(2,2)
+		@md2 = Matrixlpp::Matriz_Dispersa.new(2,2)
+		@m3 = Matrixlpp::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)
+
+		@m3.set(0,0,0)
+		@m3.set(0,1,0)
+		@m3.set(1,0,2)
+		@m3.set(1,1,0)
+
+		assert_equal(@m3.to_s,(@md1-@md2).to_s)
+
+
+	end
+	# En este método se prueba que se de un fallo de tipo (TypeError).
+	def test_typecheck
+		@m1 = Matrixlpp::Matriz_Densa.new(1,1)
+		@m2 = Matrixlpp::Matriz_Densa.new(1,1)
+		@m1.set(0,0,5)
+		@m2.set(0,0,"hola")
+
+		assert_raise(TypeError) {@m1+@m2}
+	end
+	# En este test se hace fallar intencionadamente al programa.
+	def test_failure
+		@m1 = Matrixlpp::Matriz_Densa.new(1,1)
+		@m2 = Matrixlpp::Matriz_Densa.new(2,2)
+
+		assert_raise(ArgumentError) {@m1*@m2}
+	end
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: matrixlpp
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Javier Mena Mena
+- Diego Williams Aguilar Montaño
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Esta es una clase Matrix
+email:
+- alu0100454741@ull.edu.es
+- alu0100592368@ull.edu.es
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Guarfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/matrixlpp.rb
+- lib/matrixlpp/gcd.rb
+- lib/matrixlpp/matriz.rb
+- lib/matrixlpp/matriz_densa.rb
+- lib/matrixlpp/matriz_dispersa.rb
+- lib/matrixlpp/matriz_operaciones.rb
+- lib/matrixlpp/racional.rb
+- lib/matrixlpp/version.rb
+- matrixlpp.gemspec
+- spec/matriz_spec.rb
+- test/tc_matrixlpp.rb
+homepage: https://github.com/alu0100454741/EquipoDJ-prct11
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Contiene todo lo necesario para definir una clase matrix
+test_files:
+- spec/matriz_spec.rb
+- test/tc_matrixlpp.rb