matrices 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*~

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - jruby-19mode
+  - rbx-2.1.1
+  - ruby-head
+  - jruby-head
+  - rbx-19mode

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Guardfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Cristo González - Juvenal Santiso
+
+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/Rakefile

@@ -0,0 +1,14 @@
+require 'bundler/gem_tasks'
+
+$:.unshift File.dirname(__FILE__) + 'lib'
+$:.unshift './lib', './spec'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+
+desc "Test Unitarios"
+task :test do
+  sh "ruby -I ./lib test/tc_matrices.rb" 
+end

data/Readme.md

@@ -0,0 +1,43 @@
+Cristo González Rodríguez | Juvenal Santiso Hernández
+
+Grupo 07 - Turno de mañana
+
+====> Práctica 9 <====
+
+ -> Repositorio Inicial
+
+  - Fichero "Rake", con las tareas de ayuda de Bundler, preparado para poder trabajar con la herramienta de integración continua "Travis".
+  - Fichero ".travis.yml" con las versiones/implementaciones de Ruby en las que se va a testear.
+  - Fichero "Gemfile" que controla las dependencias de las gemas utilizadas (gestionadas a través del fichero con extension ".gemspec").
+  - Fichero "Guardfile" para trabajar con la herramienta de comprobación continua "Guard".
+  - Fichero "matrices.gemspec", plantilla para la creación de nuestra gema, con la información requerida, y las dependencias de gemas para "Gemfile".
+
+  - Se incluyen los ficheros "lib/fraccion.rb", "lib/mcd.rb", "lib/matrices.rb" (anterior clase Matriz), que contienen las implementaciones de las anteriores prácticas.
+  - Se incluyen los ficheros de definición de espectativas "spec/fraccion_spec.rb" (para "fraccion.rb"), y "spec/matrices_spec.rb" (para "matrices.rb"), con las espectativas para la antigua clase Matriz.
+  - Se incluye el fichero "tc_matrices.rb" vacío, para la posterior definición de pruebas unitarias.
+
+ -> Definición de espectativas "spec/fraccion_spec.rb"
+ 
+  - Se definen las espectativas para la creación de matrices dispersas y densas, y la realización de operaciones con las mismas.
+ 
+ -> Creando el código
+    
+  - Se plantea la jerarquía de herencia de la clase matriz, esta se ha planteado que se creara dos clases hijas de matriz.rb matriz_dispersa.rb y matriz_densa.rb. Todos los métodos de operadores se han definido en la clase madre; en las clases hijas en lo que se ha querido hacer incapié es en el modo de almacenar cada una y por consiguiente tendrá metodos de acceso distintos, por esto de definió el método [] y []= de nuevo en la matriz dispersa.
+
+ -> Añadiendo los Test Case
+ 
+  - Se definen los test para la revisión de los métodos de la clase.
+
+ -> Definición de espectativas para matrices que puedan contener fracciones
+
+  - Se definen las espectativas para trabajar con matrices densas y disperas, y se modifica levemente la implementación para su correcto funcionamiento.
+
+ -> Definición de espectativas de utilización de métodos "max" y "min"
+
+  - Se definen las espectativas para el cálculo de los valores máximos y mínimos de una matriz, con las funciones "max" y "min" respectivamente.
+
+ -> Implementación métodos "max" y "min", y creación de pruebas
+
+  - Se satisfacen las espectativas para el cálculo de los elementos máximos y mínimos de una matriz, mediante la creación de los métodos "max" y "min", en la clase abstracta Matriz
+  - Se añaden al fichero "test/tc_matrices.rb", los test necesarios para comprobar el correcto funcionamiento de dichos métodos.
+ 

data/lib/matrices.rb

@@ -0,0 +1,12 @@
+require 'matrices/version'
+
+module Matrices
+  
+  require 'matrices/mcd.rb'
+  require 'matrices/elemento_nulo.rb'
+  require 'matrices/fraccion.rb'
+  require 'matrices/matriz.rb'
+  require 'matrices/matriz_densa.rb'
+  require 'matrices/matriz_dispersa.rb'
+  
+end # Module Matrices

data/lib/matrices/elemento_nulo.rb

@@ -0,0 +1,7 @@
+
+class Numeric
+  
+  def elemento_nulo
+    0
+  end
+end

data/lib/matrices/fraccion.rb

@@ -0,0 +1,139 @@
+
+class Fraccion 
+  
+  include Comparable
+  attr_accessor :n,:d
+  
+  def initialize(x,y=1)
+    m=mcd(x,y)
+    
+    # Si el denominador tiene signo negativo, se pasa el signo al numerador
+    if(y < 0)
+      x, y = -x, -y
+    end
+    
+    @n,@d = x/m,y/m
+  end
+  
+  # Metodo que devuelve el numerador
+  def num()
+    @n
+  end
+
+  # Metodo que devuelve el denominador
+  def denom()
+    @d
+  end
+  
+  # Conversion a string
+  def to_s()
+    "#@n/#@d"
+  end
+  
+  # Conversion a flotante
+  def to_f()
+    (@n.to_f()/@d.to_f())
+  end
+  
+  # Valor absoluto
+  def abs()
+    
+    # Si la fraccion es negativa, se devuelve tras cambiarla de signo
+    if(@n < 0)
+      return Fraccion.new((-1)*@n, @d)
+    end
+    
+    # Si es positiva, se devuelve
+    self
+  end
+  
+  # Calculo del reciproco
+  def reciprocal()
+    
+    # Se intercambia el numerador y el denominador
+    # Si el signo es negativo, se pasa al nuevo numerador
+    if(@n != @n.abs)
+      return Fraccion.new(@d*(-1), (-1)*@n)
+    end
+    Fraccion.new(@d, @n)
+  end
+  
+  # Sobrecarga del operador "-" unario
+  def -@
+    Fraccion.new((-1)*@n,@d)
+  end
+  
+  # Suma de fracciones
+  def +(other)
+    if (other.is_a? Numeric)
+      other = Fraccion.new(other)
+    end
+    # Se aplica el algoritmo de euclides para obtener el mcm (nuevo denominador), a partir del mcd
+    den = (@d * other.d) / mcd(@d, other.d)
+    num = ((@n * den) / @d) + ((other.n * den) / other.d)
+    mx = mcd(num, den)
+    Fraccion.new(num / mx, den / mx)
+  end
+  
+  # Resta de fracciones
+  def -(other)
+    if (other.is_a? Numeric)
+      other = Fraccion.new(other)
+    end
+    # Se aplica el algoritmo de euclides para obtener el mcm (nuevo denominador), a partir del mcd
+    den = (@d * other.d) / mcd(@d, other.d)
+    num = ((@n * den) / @d) - ((other.n * den) / other.d)
+    mx = mcd(num, den)
+    Fraccion.new(num / mx, den / mx)
+  end
+  
+  # Producto de fracciones
+  def *(other)
+    if (other.is_a? Numeric)
+      other = Fraccion.new(other)
+    end
+    num, den = @n * other.n, @d * other.d
+    mx = mcd(num, den)
+    Fraccion.new(num / mx, den / mx)
+  end
+  
+  # Division de fracciones
+  def /(other)
+    if (other.is_a? Numeric)
+      other = Fraccion.new(other)
+    end
+    num, den = @n * other.d, @d * other.n
+    mx = mcd(num, den)
+    Fraccion.new(num / mx, den / mx)
+  end
+  
+  # Modulo de fracciones
+  def %(other)
+    
+    # Se realiza la division, y al cociente se le quita la parte entera, multiplicandola por el divisor para obtener el resto
+    div=self.abs/other.abs
+    resto=other.abs * (div - Fraccion.new(div.to_f.to_i))
+    # Si el dividendo es negativo, el resto sera negativo
+    if (@n < 0)
+      return -resto
+    end
+    resto  
+  end
+  
+  # Operador <=>
+  def <=>(other)   
+    raise TypeError, 'Objeto no valido' unless other.respond_to? :to_f
+      self.to_f <=> other.to_f
+  end
+  
+  # Elemento_nulo
+  def elemento_nulo
+    Fraccion.new(0)
+  end
+  
+  # Coerce
+  def coerce(other)
+    [self,other]
+  end
+  
+end

data/lib/matrices/matriz.rb

@@ -0,0 +1,123 @@
+
+class Matriz
+
+  attr_reader :rows, :cols
+
+  def initialize(rows, cols)
+    @rows, @cols = rows , cols
+  end
+       
+  def Matriz.vector(rows, cols, ele)
+    raise TypeError, 'No se han introducido suficientes valores' unless (ele.length==rows*cols) 
+      if (((ele.count{|e| e == e.elemento_nulo}*100)/(rows*cols)) >= 60) # Matriz dispersa
+        Matriz_dispersa.new(rows,cols,ele)
+      else # Matriz densa
+        Matriz_densa.new(rows,cols,ele)
+      end
+  end
+  
+  def Matriz.nula(rows=1, cols=1)
+    aux=Array.new(rows*cols, 0)
+    Matriz_dispersa.new(rows, cols, aux)
+  end
+       
+  def to_s  
+    cadena = "["
+    for i in (0..(@rows-1))
+      cadena += "["
+      for j in (0..(@cols-1))
+        cadena += "#{self[i,j]}"
+        if (j < (@cols-1)) 
+          cadena += "," 
+        end
+      end
+      cadena += "]"
+      if (i < (@rows-1)) 
+        cadena += "," 
+      end
+    end
+    cadena += "]"
+  end
+
+  def +(other) 
+    raise TypeError, 'Las matrices no son del mismo tamanyo' unless (@rows==other.rows && @cols==other.cols)
+      result=Array.new
+      for i in 0...@rows
+        for j in 0...@cols
+          result << (self[i,j] + other[i,j])
+        end 
+      end
+      Matriz.vector(@rows, @cols, result)
+  end
+  
+  def -(other) 
+    raise TypeError, 'Las matrices no son del mismo tamanyo' unless (@rows==other.rows && @cols==other.cols)
+      result=Array.new
+      for i in 0...@rows
+        for j in 0...@cols
+          result << (self[i,j] - other[i,j])
+        end 
+      end
+      Matriz.vector(@rows, @cols, result)
+  end
+  
+  def *(other)
+    if(other.is_a? Numeric)
+      result=Array.new
+      for i in 0...@rows
+        for j in 0...@cols
+          result << (self[i,j]*other)
+        end
+      end
+      return Matriz.vector(@rows,@cols,result)
+      
+    elsif(other.is_a? Matriz)
+      raise TypeError, 'Las matrices dadas no se pueden multiplicar entre si' unless (@cols == other.rows)
+      result=Array.new
+      for i in 0...@rows
+        for j in 0...other.cols
+          result << 0
+          for k in 0...@cols
+            result[(result.length)-1]= (result.last + (self[i,k] * other[k,j]))
+          end
+        end
+      end
+    end
+    Matriz.vector(@rows,other.cols,result)
+  end
+
+  def max
+    aux=self[0,0]
+    for i in 0...@rows
+      for j in 0...@cols
+        r = aux.coerce(self[i,j])
+        if (r[0] > r[1])
+          aux = r[0]
+        else
+          aux = r[1]
+        end
+      end
+    end
+    aux
+  end
+  
+  def min
+    aux=self[0,0]
+    for i in 0...@rows
+      for j in 0...@cols
+        r = aux.coerce(self[i,j])
+        if (r[0] < r[1])
+          aux = r[0]
+        else
+          aux = r[1]
+        end
+      end
+    end
+    aux
+  end
+  
+  def coerce(other)
+    [self,other]
+  end
+  
+end

data/lib/matrices/matriz_densa.rb

@@ -0,0 +1,38 @@
+
+class Matriz_densa < Matriz 
+
+  attr_reader :rows, :cols
+  
+  def initialize(rows, cols, ele)
+    super(rows, cols)
+    @mat=Array.new(ele)
+    @mat.map! {|e|; if e == e.elemento_nulo; e = 0; else e; end}
+  end
+  
+  def pos(x,y)
+    (x*@cols)+y
+  end
+  
+  def [](x,y)
+    @mat[pos(x,y)]
+  end
+  
+  def []=(x,y,value)
+    @mat[pos(x,y)] = value
+  end 
+
+  def ==(other)
+    if (@rows != other.rows || @cols != other.cols)
+      return false
+    end
+    for i in 0...@rows
+      for j in 0...@cols
+        if (@mat[pos(i,j)] != other[i,j])
+          return false
+        end
+      end
+    end
+    return true
+  end
+  
+end

data/lib/matrices/matriz_dispersa.rb

@@ -0,0 +1,66 @@
+
+class Matriz_dispersa < Matriz
+
+  attr_reader :rows, :cols
+  
+  def initialize(rows, cols, ele)
+    
+    super(rows, cols)
+    
+    @val, @f, @c = Array.new, Array.new, Array.new
+
+    for i in 0...(@rows*@cols)
+      if(ele[i]!=0)
+        @val << (ele[i])
+        @f << (i/@cols)
+        @c << (i%@cols)
+      end
+    end
+  end
+  
+  def [](x,y)
+    for pos in 0...@val.length
+      if (@f[pos] == x && @c[pos] == y)
+        return @val[pos]
+      end
+    end
+    0
+  end
+ 
+  def []=(x,y,value)
+    for pos in 0...@val.length
+      if (@f[pos] == x && @c[pos] == y)
+        if (value != 0)
+          @val[pos] = value
+        else
+          @val.delete_at(pos)
+          @f.delete_at(pos)
+          @c.delete_at(pos)
+        end
+        return
+      end
+    end
+    if (value != 0)
+      @val << value
+      @f << x
+      @c << y
+    end
+  end
+ 
+  def length
+    @val.length
+  end
+
+  def ==(other)
+    if (@val.length != other.length || @rows != other.rows || @cols != other.cols)
+      return false
+    end
+    for pos in 0...@val.length
+      if (@val[pos] != other(@f[pos],@c[pos]))
+        return false
+      end
+    end
+    true
+  end
+  
+end

data/lib/matrices/mcd.rb

@@ -0,0 +1,10 @@
+
+# Metodo que calcula el maximo comun divisor
+
+def mcd(x, y)
+  x, y = x.abs, y.abs
+  while y != 0
+    x, y = y, x % y
+  end
+  x
+end

data/lib/matrices/version.rb

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

data/matrices.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "matrices/version"
+
+Gem::Specification.new do |s|
+  s.name        = "matrices"
+  s.version     = Matrices::VERSION
+  s.authors     = ["Cristo González | Juvenal Santiso"]
+  s.email       = ["alu0100694987@ull.edu.es | alu0100696585@ull.edu.es"]
+  s.homepage    = "https://github.com/alu0100694987/prct09.git"
+  s.summary     = %q{Creación de matrices}
+  s.description = %q{Permite representar y realizar operaciones con matrices densas y dispersas}
+
+  s.rubyforge_project = "matrices"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_development_dependency "rake"  
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "guard-rspec"
+  s.add_development_dependency "guard-bundler"
+end

data/spec/fraccion_spec.rb

@@ -0,0 +1,109 @@
+require 'matrices/fraccion.rb'
+
+describe Fraccion do
+  
+  before :each do
+    @frac1 = Fraccion.new(3,4)
+    @frac2 = Fraccion.new(4,10)
+    @frac3 = Fraccion.new(2,-5)
+  end
+  
+  describe "# Numerador y denominador: " do
+    it "Almacenamiento correcto de numerador" do
+      @frac1.n.should eq(3)
+    end
+    it "Almacenamiento correcto de denominador" do
+      @frac1.d.should eq(4)
+    end
+    it "Almacenamiento reducido de numerador" do
+      @frac2.n.should eq(2)
+    end
+    it "Almacenamiento reducido de denominador" do
+      @frac2.d.should eq(5)
+    end  
+  end
+  
+  describe "# Metodos num() y denom(): " do
+    it "Obtencion de numerador" do
+      @frac1.num().should == 3
+    end
+    it "Obtencion de denominador" do
+      @frac2.denom().should == 5
+    end
+  end
+  
+  describe "# Salida en consola: " do
+    it "Mostrar fraccion en pantalla" do
+      @frac1.to_s().should == "3/4"
+      @frac2.to_s().should == "2/5"
+    end
+    it "Mostrar fraccion en formato flotante" do
+      @frac1.to_f().to_s().should eq("0.75")
+      @frac2.to_f().to_s().should eq("0.4")
+    end
+  end
+  
+  describe "# Igualdad de fracciones:" do
+    it "Comparar si dos fracciones son iguales" do
+      (@frac1 == Fraccion.new(4)).should be_false
+      (@frac1 == Fraccion.new(6,8)).should be_true
+    end
+  end
+  
+  describe "# Operaciones unarias:" do
+    it "Calculo del valor absoluto" do
+      @frac1.abs.should == @frac1
+      @frac3.abs.to_s().should eq("2/5")
+    end
+    it "Calculo del reciproco" do
+      @frac1.reciprocal.to_s().should eq("4/3")
+      @frac3.reciprocal.to_s().should eq("-5/2")
+    end
+    it "Calculo del opuesto" do
+      ((-@frac1) == @frac1).should be_false
+      (-@frac3).to_s.should eq("2/5")
+    end
+  end
+  
+  describe "# Operaciones binarias:" do
+    
+    it "Suma de fracciones" do
+      (@frac1 + @frac2).to_s().should eq("23/20")
+      ((@frac2 + @frac3) == Fraccion.new(0)).should be_true
+    end
+
+    it "Diferencia de fracciones" do
+      (@frac1 - @frac2).to_s().should eq("7/20")
+      (@frac3 - @frac2).to_s().should eq("-4/5")
+    end
+    
+    it "Producto de fracciones" do
+      ((@frac1 * @frac2) == Fraccion.new(3,10)).should be_true
+      ((@frac2 * @frac3) == Fraccion.new(-4,25)).should be_true
+    end
+
+    it "Division de fracciones" do
+      ((@frac1 / @frac2) == Fraccion.new(15,8)).should be_true
+      ((@frac3 / @frac3) == Fraccion.new(1,1)).should be_true
+    end     
+
+    it "Resto entre fracciones" do
+      ((@frac1 % @frac2) == Fraccion.new(7,20)).should be_true
+      ((@frac2 % @frac3) == Fraccion.new(0,1)).should be_true
+    end
+    
+  end
+
+
+  describe "# Comparaciones entre fracciones:" do
+     it "Comparacion mayor, y mayor e igual" do
+       (@frac1 >= @frac2).should be_true
+       (@frac1 > @frac1).should be_false
+     end
+     it "Comparacion menor, y menor e igual" do
+       (@frac2 <= @frac2).should be_true
+       (@frac2 < @frac3).should be_false
+     end
+  end
+
+end

data/spec/matrices_spec.rb

@@ -0,0 +1,140 @@
+# Fichero en el que se definen las espectativas de la clase Matriz
+
+require 'matrices.rb'
+
+describe Matriz do
+
+  before :all do
+    @m1 = Matriz.nula # Dispersa
+    @m2 = Matriz.nula(3,2) # Dispersa
+    @m3 = Matriz.vector(3,2,[2,3,0,1,0,3]) # Densa
+    @m4 = Matriz.vector(2,4,[0,1,0,0,7,0,2,0]) # Dispersa
+    @m5 = Matriz.vector(4,4,[1,1,5,1,2,1,6,1,1,5,1,3,1,2,1,1]) # Densa
+    @m6 = Matriz.vector(2,2,[Fraccion.new(1),Fraccion.new(1,5),Fraccion.new(0),Fraccion.new(1,3)]) # Densa
+    @m7 = Matriz.vector(1,3,[Fraccion.new(0),Fraccion.new(0),Fraccion.new(4)]) # Dispersa
+    @m8 = Matriz.vector(1,2,[Fraccion.new(1,2),Fraccion.new(3,2)]) # Densa
+  end
+  
+  describe "# Asignacion correcta del tipo de matriz: " do
+    it "Identificacion de Matriz.nula como Matriz_dispersa" do
+      @m1.class.should eq(Matriz_dispersa)
+      @m2.class.should eq(Matriz_dispersa)
+    end
+    it "Identificacion de Matriz.vector como Matriz_dispersa o Matriz.vector en funcion del numero de ceros" do
+      @m3.class.should eq(Matriz_densa)
+      @m4.class.should eq(Matriz_dispersa)
+    end
+    it "Identificacion de matrices de fracciones como Matriz_dispersa y Matriz_nula" do
+      @m6.class.should eq(Matriz_densa)
+      @m7.class.should eq(Matriz_dispersa)
+    end
+  end  
+  
+  describe "# Almacenamiento de numero de filas y columnas: " do
+    it "Almacenamiento correcto del numero de filas en matrices densas" do
+      @m3.rows.should eq(3)
+      @m5.rows.should eq(4)
+    end
+    it "Almacenamiento correcto del numero de filas en matrices dispersas" do
+      @m1.rows.should eq(1)
+      @m4.rows.should eq(2)
+    end
+    it "Almacenamiento correcto del numero de columnas en matrices densas" do
+      @m3.cols.should eq(2)
+      @m5.cols.should eq(4)
+    end
+    it "Almacenamiento correcto del numero de columnas en matrices dispersas" do
+      @m1.cols.should eq(1)
+      @m4.cols.should eq(4)
+    end
+    it "Almacenamiento correcto del numero de filas y columnas en matrices de fracciones" do
+      @m7.rows.should eq(1)
+      @m7.cols.should eq(3)
+    end
+  end
+  
+  describe "# Correcta conversion a cadena de caracteres: " do
+    it "Funcionamiento correcto del metodo to_s en matrices densas" do
+      @m3.to_s.should eq('[[2,3],[0,1],[0,3]]')
+      @m5.to_s.should eq('[[1,1,5,1],[2,1,6,1],[1,5,1,3],[1,2,1,1]]')
+    end
+    it "Funcionamiento correcto del metodo to_s en matrices dispersas" do
+      @m1.to_s.should eq('[[0]]')
+      @m4.to_s.should eq('[[0,1,0,0],[7,0,2,0]]')
+    end
+    it "Funcionamiento correcto del metodo to_s en matrices densas y dispersas de fracciones" do
+      @m6.to_s.should eq('[[1/1,1/5],[0,1/3]]')
+      @m7.to_s.should eq('[[0,0,4/1]]')
+    end
+  end
+  
+  describe "# Acceso a los elementos de la matriz: " do
+    it "Insercion correcta de elementos en matrices densas y dispersas" do
+      @m2[0,0]= 1; @m2[0,1]= 1
+      @m2[1,0]= 1; @m2[1,1]= 1
+      @m2[2,0]= 1; @m2[2,1]= 1
+      @m3[2,0]= 5
+      @m2.to_s.should eq('[[1,1],[1,1],[1,1]]')    
+      @m3.to_s.should eq('[[2,3],[0,1],[5,3]]')
+    end
+    it "Obtencion correcta de elementos en matrices densas y dispersas" do
+      @m4[1,0].should eq(7)
+      @m5[1,2].should eq(6)
+    end
+    it "Insercion y obtencion correcta de elementos en matrices de fracciones" do
+      @m7[0,2]= Fraccion.new(1,2)
+      @m7[0,2].to_s.should eq('1/2')
+    end
+  end
+  
+  describe "# Operaciones aritmeticas: " do
+    it "Suma de matrices" do
+      (@m2 + @m3).to_s.should eq('[[3,4],[1,2],[6,4]]')
+    end
+    it "Resta de matrices" do
+      (@m3 - @m3).to_s.should eq('[[0,0],[0,0],[0,0]]')
+    end
+    it "Multiplicacion por escalar" do
+      (2 * @m3).to_s.should eq('[[4,6],[0,2],[10,6]]')
+    end
+    it "Multiplicacion de matrices" do
+      (@m3 * @m4).to_s.should eq('[[21,2,6,0],[7,0,2,0],[21,5,6,0]]')
+    end
+    it "Comprobacion del tipo de clase del resultado de las operaciones" do
+      (@m2 + @m3).class.should eq(Matriz_densa)
+      (@m2 - @m2).class.should eq(Matriz_dispersa)
+      (@m3 * @m4).class.should eq(Matriz_densa)
+    end
+    it "Operaciones con matrices que contienen alguna fraccion" do
+      (@m6 + @m6).to_s.should eq('[[2/1,2/5],[0,2/3]]')
+      (@m8 * @m6).to_s.should eq('[[1/2,3/5]]')
+    end
+  end
+  
+  describe "# Comparacion de matrices: " do
+    it "Igualdad de matrices" do
+      (@m5 == Matriz.vector(4,4,[1,1,5,1,2,1,6,1,1,5,1,3,1,2,1,1])).should be_true
+      (@m1 == Matriz.nula(5,2)).should be_false
+    end
+    it "Igualdad de matrices de fracciones" do
+      (@m6 == Matriz.vector(2,2,[Fraccion.new(1),Fraccion.new(1,5),Fraccion.new(0),Fraccion.new(1,3)])).should be_true
+      (@m6 == Matriz.vector(2,2,[1,Fraccion.new(1,5),0,Fraccion.new(1,3)])).should be_true
+    end
+  end
+  
+  describe "# Calculo del minimo y el maximo de los elementos de una matriz" do
+    it "Obtencion del minimo de una matriz" do
+      @m4.min.should eq(Fraccion.new(0))
+      @m5.min.should eq(1)
+      @m6.min.should eq(0)
+      @m8.min.should eq(Fraccion.new(1,2))
+    end
+    it "Obtencion del maximo de una matriz" do
+      @m4.max.should eq(7)
+      @m5.max.should eq(6)
+      @m6.max.should eq(1)
+      @m7.max.should eq(Fraccion.new(1,2))
+    end
+  end
+
+end

data/test/tc_matrices.rb

@@ -0,0 +1,81 @@
+# Pruebas unitarias asociadas a la creacion de matrices
+
+require 'lib/matrices.rb'
+require 'test/unit'
+
+class Test_Matrices < Test::Unit::TestCase
+
+  def setup
+    @m1=Matriz.vector(2,2,[0,1,1,0])
+    @m2=Matriz.vector(2,2,[1,1,1,1])
+    @m3=Matriz.nula
+    @m4=Matriz.vector(2,2,[0,0,0,5])
+    @m5=Matriz.vector(2,2,[1,1,1,1])
+    @m6=Matriz.vector(2,2,[1,2,3,4])
+  end
+  
+  def tear_down
+    #nothing
+  end
+  
+  #to_s
+  def test_str
+    assert_equal(@m3.to_s,'[[0]]')
+    assert_equal(@m2.to_s,'[[1,1],[1,1]]')
+  end
+  
+  #Comprobacion de la creacion de matrices
+  def test_creac
+    #Matriz densa
+    assert_equal(@m1.rows, 2)
+    assert_equal(@m1.cols, 2)
+    
+    #Matriz dispersa
+    assert_equal(@m4.rows, 2)
+    assert_equal(@m4.cols, 2)
+    
+    #Creacion
+    assert_equal(Matriz.vector(2,2,[1,1,1,1]).to_s,@m2.to_s)
+    assert_equal(Matriz.nula.to_s,@m3.to_s)
+  end
+  
+  #Comprobacion del tipo de las matrices creadas
+  
+  def test_tipo
+    assert_kind_of(Matriz_dispersa, @m3)
+    assert_kind_of(Matriz_dispersa, @m4) #Matriz.vector siendo clase dispersa 
+    assert_kind_of(Matriz_densa, @m2)
+  end
+  
+  #Comprobacion de las operaciones 
+  def test_method
+    #==
+    assert_operator(@m2,'==',@m5)
+    #max y min
+    assert_equal(5,@m4.max)
+    assert_equal(4,@m6.max)
+    assert_equal(1,@m6.min)
+    #Operaciones
+    assert_equal(Matriz.vector(2,2,[1,2,2,1]).to_s,(@m1+@m2).to_s)
+    assert_equal(Matriz.vector(2,2,[1,0,0,1]).to_s,(@m2-@m1).to_s)
+    assert_equal(Matriz.vector(2,2,[1,1,1,1]).to_s,(@m1*@m2).to_s)
+    assert_equal(Matriz.vector(2,2,[2,2,2,2]).to_s,(@m2*2).to_s)
+  end  
+
+  #Insercion y obtencion del contenido
+  def test_cont
+    @m4[0,0]=1
+    @m1[0,0]=1
+    #insercion
+    assert_equal(@m4.to_s,'[[1,0],[0,5]]')
+    assert_equal(@m1.to_s,'[[1,1],[1,0]]')
+    #obtencion
+    assert_equal(@m4[1,1],5)
+    assert_equal(@m1[0,0],1)
+  end
+  
+  #test de fallo 
+  def test_failure
+    assert_equal(Matriz.vector(2,2,[5,1,0,2]).to_s,(@m1+@m2).to_s)
+  end
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification 
+name: matrices
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- "Cristo Gonz\xC3\xA1lez | Juvenal Santiso"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-11-19 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: guard-rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: guard-bundler
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: Permite representar y realizar operaciones con matrices densas y dispersas
+email: 
+- alu0100694987@ull.edu.es | alu0100696585@ull.edu.es
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .travis.yml
+- Gemfile
+- Guardfile
+- LICENSE
+- Rakefile
+- Readme.md
+- lib/matrices.rb
+- lib/matrices/elemento_nulo.rb
+- lib/matrices/fraccion.rb
+- lib/matrices/matriz.rb
+- lib/matrices/matriz_densa.rb
+- lib/matrices/matriz_dispersa.rb
+- lib/matrices/mcd.rb
+- lib/matrices/version.rb
+- matrices.gemspec
+- spec/fraccion_spec.rb
+- spec/matrices_spec.rb
+- test/tc_matrices.rb
+homepage: https://github.com/alu0100694987/prct09.git
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: matrices
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: "Creaci\xC3\xB3n de matrices"
+test_files: []
+