prct09 0.0.1 → 1.0.0

data/doc/rdoc-style.css

@@ -0,0 +1,208 @@
+
+body {
+    font-family: Verdana,Arial,Helvetica,sans-serif;
+    font-size:   90%;
+    margin: 0;
+    margin-left: 40px;
+    padding: 0;
+    background: white;
+}
+
+h1,h2,h3,h4 { margin: 0; color: #efefef; background: transparent; }
+h1 { font-size: 150%; }
+h2,h3,h4 { margin-top: 1em; }
+
+a { background: #eef; color: #039; text-decoration: none; }
+a:hover { background: #039; color: #eef; }
+
+/* Override the base stylesheet's Anchor inside a table cell */
+td > a {
+  background: transparent;
+  color: #039;
+  text-decoration: none;
+}
+
+/* and inside a section title */
+.section-title > a {
+  background: transparent;
+  color: #eee;
+  text-decoration: none;
+}
+
+/* === Structural elements =================================== */
+
+div#index {
+    margin: 0;
+    margin-left: -40px;
+    padding: 0;
+    font-size: 90%;
+}
+
+
+div#index a {
+    margin-left: 0.7em;
+}
+
+div#index .section-bar {
+   margin-left: 0px;
+   padding-left: 0.7em;
+   background: #ccc;
+   font-size: small;
+}
+
+
+div#classHeader, div#fileHeader {
+    width: auto;
+    color: white;
+    padding: 0.5em 1.5em 0.5em 1.5em;
+    margin: 0;
+    margin-left: -40px;
+    border-bottom: 3px solid #006;
+}
+
+div#classHeader a, div#fileHeader a {
+    background: inherit;
+    color: white;
+}
+
+div#classHeader td, div#fileHeader td {
+    background: inherit;
+    color: white;
+}
+
+
+div#fileHeader {
+    background: #057;
+}
+
+div#classHeader {
+    background: #048;
+}
+
+
+.class-name-in-header {
+  font-size:  180%;
+  font-weight: bold;
+}
+
+
+div#bodyContent {
+    padding: 0 1.5em 0 1.5em;
+}
+
+div#description {
+    padding: 0.5em 1.5em;
+    background: #efefef;
+    border: 1px dotted #999;
+}
+
+div#description h1,h2,h3,h4,h5,h6 {
+    color: #125;;
+    background: transparent;
+}
+
+div#validator-badges {
+    text-align: center;
+}
+div#validator-badges img { border: 0; }
+
+div#copyright {
+    color: #333;
+    background: #efefef;
+    font: 0.75em sans-serif;
+    margin-top: 5em;
+    margin-bottom: 0;
+    padding: 0.5em 2em;
+}
+
+
+/* === Classes =================================== */
+
+table.header-table {
+    color: white;
+    font-size: small;
+}
+
+.type-note {
+    font-size: small;
+    color: #DEDEDE;
+}
+
+.xxsection-bar {
+    background: #eee;
+    color: #333;
+    padding: 3px;
+}
+
+.section-bar {
+   color: #333;
+   border-bottom: 1px solid #999;
+    margin-left: -20px;
+}
+
+
+.section-title {
+    background: #79a;
+    color: #eee;
+    padding: 3px;
+    margin-top: 2em;
+    margin-left: -30px;
+    border: 1px solid #999;
+}
+
+.top-aligned-row {  vertical-align: top }
+.bottom-aligned-row { vertical-align: bottom }
+
+/* --- Context section classes ----------------------- */
+
+.context-row { }
+.context-item-name { font-family: monospace; font-weight: bold; color: black; }
+.context-item-value { font-size: small; color: #448; }
+.context-item-desc { color: #333; padding-left: 2em; }
+
+/* --- Method classes -------------------------- */
+.method-detail {
+    background: #efefef;
+    padding: 0;
+    margin-top: 0.5em;
+    margin-bottom: 1em;
+    border: 1px dotted #ccc;
+}
+.method-heading {
+  color: black;
+  background: #ccc;
+  border-bottom: 1px solid #666;
+  padding: 0.2em 0.5em 0 0.5em;
+}
+.method-signature { color: black; background: inherit; }
+.method-name { font-weight: bold; }
+.method-args { font-style: italic; }
+.method-description { padding: 0 0.5em 0 0.5em; }
+
+/* --- Source code sections -------------------- */
+
+a.source-toggle { font-size: 90%; }
+div.method-source-code {
+    background: #262626;
+    color: #ffdead;
+    margin: 1em;
+    padding: 0.5em;
+    border: 1px dashed #999;
+    overflow: hidden;
+}
+
+div.method-source-code pre { color: #ffdead; overflow: hidden; }
+
+/* --- Ruby keyword styles --------------------- */
+
+.standalone-code { background: #221111; color: #ffdead; overflow: hidden; }
+
+.ruby-constant  { color: #7fffd4; background: transparent; }
+.ruby-keyword { color: #00ffff; background: transparent; }
+.ruby-ivar    { color: #eedd82; background: transparent; }
+.ruby-operator  { color: #00ffee; background: transparent; }
+.ruby-identifier { color: #ffdead; background: transparent; }
+.ruby-node    { color: #ffa07a; background: transparent; }
+.ruby-comment { color: #b22222; font-weight: bold; background: transparent; }
+.ruby-regexp  { color: #ffa07a; background: transparent; }
+.ruby-value   { color: #7fffd4; background: transparent; }

data/lib/Fraccion.rb

@@ -3,7 +3,7 @@ class Fraccion
    attr_reader :n, :d
 
    include Comparable
-
+   #Calcula el máximo comun divisor de una fraccion   
    def mcd(a,b)
       d = a.abs, b.abs
       while d.min != 0
@@ -13,49 +13,55 @@ class Fraccion
    end
    private :mcd
 
-   #Construccion
+   #Constructor de la clase Fraccion
    def initialize(n, d)
       @n = n / mcd(n,d)
       @d = d / mcd(n,d)
    end
    
-   #Pasar a string el objeto Fraccion
+   #Pasa a string el objeto Fraccion
    def imprimirFraccion
       "#{@n}/#{@d}" 
    end
    
-   #Pasar a flotante el objeto Fraccion
+   #Pasa a flotante el objeto Fraccion
    def imprimirFlotante
       @n.to_f/@d.to_f
    end
+   
+   def coerce(other)
+     if (other.is_a?(Numeric))
+       [Fraccion.new(other.to_i,1),self]
+     end
+   end
 
-   #Sobrecarga de operadores
-
+   
+   #Sobrecarga del operador + para operar con fracciones
    def + (other)
 	Fraccion.new(@n* other.d + other.n*@d, @d * other.d)
    end
-
+   #Sobrecarga del operador - para operar con fracciones
    def - (other)
 	Fraccion.new(@n* other.d - other.n*@d, @d * other.d)
    end
-
+   #Sobrecarga del operador * para operar con fracciones
    def * (other)
 	Fraccion.new(@n* other.n, @d * other.d)
    end
-
+   #Sobrecarga del operador / para operar con fracciones
    def / (other)
 	Fraccion.new(@n* other.d, @d * other.n)
    end
-
+   #Sobrecarga del operador % para operar con fracciones
    def % (other)
 	Fraccion.new((imprimirFlotante % other.imprimirFlotante*1000).to_i, 1000)
    end
-
+   #Sobrecarga del <=> para poder comparar fracciones (==, <=, >=, ...)
    def <=> (other)
 	imprimirFlotante <=> other.imprimirFlotante
    end
 
-   #valor absoluto
+   #Calcula el valor absoluto
    def abs
 	if (@n < 0) ^ (@d < 0)
 	   if @n < 0
@@ -73,13 +79,13 @@ class Fraccion
      end
 
 
-   #inverso de una fraccion
+   #Calcula el inverso de una fraccion
    def reciprocal
 	Fraccion.new(@d, @n)
    end
 
 
-   #opuesta de una fraccion
+   #Calcula el opuesto de una fraccion
    def -@
 	Fraccion.new(@n*-1, @d)
    end

data/lib/Matriz.rb

@@ -3,84 +3,50 @@ class Matriz
 
 attr_accessor :filas, :cols, :matriz
 
+#Constructor de la matriz
 def initialize(m)
 @filas = m.size
 @cols = m[1].size
 @matriz = m
 end
 
+#Función que imprime la matriz
 def to_s () 
    @matriz.each do |fila|			
    puts fila.join(" ")			
    end
 end
 
+#Definición de la sobrecarga del operador +
 def + (other)
-   aux_m = Array.new
-   for i in 0...@filas do
-      aux_m[i] = Array.new			
-      for j in 0...@cols do			
-         aux_m[i][j] = 0;
-      end
-   end 
-   for i in 0...@filas do			
-      for j in 0...@cols do			
-         aux_m[i][j] = @matriz[i][j] + other.matriz[i][j]
-      end
-   end
-   Matriz.new(aux_m).matriz
 end
 
+#Definición de la sobrecarga del operador -
 def - (other)
-   aux_m = Array.new
-   for i in 0...@filas do
-      aux_m[i] = Array.new			
-      for j in 0...@cols do			
-         aux_m[i][j] = 0;
-      end
-   end 
-   for i in 0...@filas do			
-      for j in 0...@cols do			
-         aux_m[i][j] = @matriz[i][j] - other.matriz[i][j]
-      end
-   end
-   Matriz.new(aux_m).matriz
 end
 
+#Definición de la sobrecarga del operador *
 def * (other) 
-   aux_m = Array.new
-   for i in 0...@filas do
-      aux_m[i] = Array.new			
-      for j in 0...@cols do			
-         aux_m[i][j] = 0;
-      end
-   end   
-   for i in 0...@filas do			
-      for j in 0...other.cols do			
-         for k in 0...other.filas do		
-            aux_m[i][j] += @matriz[i][k] * other.matriz[k][j]	
-         end
-      end
-   end
-   Matriz.new(aux_m).matriz
 end
 
+#Calcula la traspuesta de una matriz y la devuelve según el tipo que sea
 def traspuesta ()
    aux_m = Array.new
-   for i in 0...@filas do
+   @filas.times do |i|
       aux_m[i] = Array.new			
-      for j in 0...@cols do
+      @cols.times do |j|
          aux_m[i][j] = @matriz[(@filas-1)-i][(@cols-1)-j]
       end
    end
    Matriz.new(aux_m).comprobar
 end
 
+#Comprueba la matriz y la devuelve según su tipo
 def comprobar()
    cont_total = 0
    cont_ceros = 0
-   for i in 0...@filas do			
-      for j in 0...@cols do			
+   @filas.times do |i|			
+      @cols.times do |j|			
          if @matriz[i][j] == 0
             cont_ceros = cont_ceros + 1
          end
@@ -94,9 +60,11 @@ def comprobar()
    end
 end
 
+#Definición de el cálculo del máximo de una matriz
 def max()
 end
 
+#Definición de el cálculo del mínimo de una matriz
 def min()
 end
 

data/lib/Matriz_densa.rb

@@ -2,17 +2,18 @@ require "Fraccion.rb"
 require "Matriz.rb"
 class Matriz_densa < Matriz
 
+#Sobrecarga del operador + para operar con matrices densas y dispersas
 def + (other)
    aux_m = Array.new
-   for i in 0...@filas do
+   @filas.times do |i|
       aux_m[i] = Array.new			
-      for j in 0...@cols do			
+      @cols.times do |j|			
          aux_m[i][j] = 0;
       end
    end
    if other.is_a?(Matriz_dispersa)
-      for i in 0...@filas do			
-         for j in 0...@cols do			
+      @filas.times do	|i|		
+         @cols.times do	|j|		
             if other.matriz[i.to_s+"_"+j.to_s] != nil
                aux_m[i][j] = @matriz[i][j] + other.matriz[i.to_s+"_"+j.to_s]
             else
@@ -21,8 +22,8 @@ def + (other)
          end
       end
    elsif other.is_a?(Matriz_densa)
-      for i in 0...@filas do			
-         for j in 0...@cols do			
+      @filas.times do	|i|		
+         @cols.times do	|j|			
             aux_m[i][j] = @matriz[i][j] + other.matriz[i][j]
          end
       end
@@ -30,17 +31,18 @@ def + (other)
    Matriz.new(aux_m).comprobar()
 end
 
+#Sobrecarga del operador - para operar con matrices densas y dispersas
 def - (other)
    aux_m = Array.new
-   for i in 0...@filas do
+   @filas.times do |i|
       aux_m[i] = Array.new			
-      for j in 0...@cols do			
+      @cols.times do |j|			
          aux_m[i][j] = 0;
       end
-   end 
+   end
    if other.is_a?(Matriz_dispersa)
-      for i in 0...@filas do			
-         for j in 0...@cols do			
+      @filas.times do	|i|		
+         @cols.times do	|j|			
             if other.matriz[i.to_s+"_"+j.to_s] != nil
                aux_m[i][j] = @matriz[i][j] - other.matriz[i.to_s+"_"+j.to_s]
             else
@@ -49,8 +51,8 @@ def - (other)
          end
       end
    elsif other.is_a?(Matriz_densa)
-      for i in 0...@filas do			
-         for j in 0...@cols do			
+      @filas.times do	|i|		
+         @cols.times do	|j|			
             aux_m[i][j] = @matriz[i][j] - other.matriz[i][j]
          end
       end
@@ -58,18 +60,19 @@ def - (other)
    Matriz.new(aux_m).comprobar()
 end
 
+#Sobrecarga del operador * para operar con matrices densas y dispersas
 def * (other) 
    aux_m = Array.new
-   for i in 0...@filas do
+   @filas.times do |i|
       aux_m[i] = Array.new			
-      for j in 0...@cols do			
+      @cols.times do |j|			
          aux_m[i][j] = 0;
       end
    end
    if other.is_a?(Matriz_dispersa) 
-      for i in 0...@filas do			
-         for j in 0...other.cols do			
-            for k in 0...other.filas do
+      @filas.times do	|i|		
+         other.cols.times do |j|			
+            other.filas.times do |k|
                if other.matriz[k.to_s+"_"+j.to_s] != nil	
                   aux_m[i][j] += @matriz[i][j] * other.matriz[k.to_s+"_"+j.to_s]
                end	
@@ -77,9 +80,9 @@ def * (other)
          end
       end
    elsif other.is_a?(Matriz_densa)
-      for i in 0...@filas do			
-         for j in 0...other.cols do			
-            for k in 0...other.filas do		
+      @filas.times do	|i|		
+         other.cols.times do |j|			
+            other.filas.times do |k|	
                aux_m[i][j] += @matriz[i][k] * other.matriz[k][j]	
             end
          end
@@ -88,12 +91,13 @@ def * (other)
    Matriz.new(aux_m).comprobar()
 end
 
+#Calcula el máximo de una matriz densa
 def max()
 
    aux_max = @matriz[0][0]
 
-   for i in 0...@filas do			
-      for j in 0...@cols do
+   @filas.times do |i|		
+      @cols.times do |j|
          if aux_max < @matriz[i][j]
             aux_max = @matriz[i][j]
          end
@@ -103,12 +107,13 @@ def max()
    aux_max
 end
 
+#Calcula el mínimo de una matriz densa
 def min()
 
    aux_min = @matriz[0][0]
 
-   for i in 0...@filas do			
-      for j in 0...@cols do
+   @filas.times do |i|			
+      @cols.times do |j|
          if aux_min > @matriz[i][j]
             aux_min = @matriz[i][j]
          end