sparse_matrix 0.0.1 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cefab8ce99739715090611dd4a221806e9e4711f
-  data.tar.gz: a9a7bf3c925db43e9761f75d39975b838428c3af
+  metadata.gz: 2d3bb6f0f82c1dac4b679ee0ecc93f2a45c9f556
+  data.tar.gz: fa6fd2a910191e1a4f7ca60989e586b0303e41ce
 SHA512:
-  metadata.gz: d040255afe87e2df3197474835d322f126d055fb11e429bbc33b6c25762a28ce6ac91dde6a2f515c62e2a9ef72aeec80122567f9cbec941b166a980f2b8273b3
-  data.tar.gz: 7649db8cc449535adff9f22e2916794ab88b7f124e110bbedc64dfab40d3b8c3c149c1f3f1db5bc8220b2f056824e76e97461dc30555f4340ac91a921633af43
+  metadata.gz: edd4515e564e016b8f0b350cea8a5eef68e52d7c32147db28ccfbce08a3742f0673c893e07966e321528a316ec412001832b5eee5327b45c3ee6d064f542521b
+  data.tar.gz: 06093fe0182f748338cdf1cc4d1b647ad15aa1d30a866d7afcaf0c5d5d90fcf73d98d507c3b07c0f7936259f24a0fe15515c209573fce7388fa552907439c41a

data/README.md

@@ -1,27 +1,33 @@
-# SparseMatrix
+# SparseMatrix [![Build Status](https://travis-ci.org/kevinrobayna/SparseMatrix.png?branch=master)](https://travis-ci.org/kevinrobayna/SparseMatrix)
 
 Build a sparce matrix from dense matrix
 
+##RubyGems
+    https://rubygems.org/gems/sparse_matrix
+
 ## Tree
 
+    .
     ├── Gemfile
+    ├── Gemfile.lock
+    ├── Guardfile
+    ├── LICENSE.txt
+    ├── README.md
+    ├── Rakefile
     ├── input
+    │   ├── matrix_a
+    │   ├── matrix_b
+    │   └── null
     ├── lib
     │   ├── sparse_matrix
     │   │   └── version.rb
     │   └── sparse_matrix.rb
-    ├── LICENSE.txt
-    ├── Rakefile
-    ├── README.md
+    ├── pkg
+    │   └── sparse_matrix-0.0.1.gem
     ├── sparse_matrix.gemspec
-    ├── spec
-    │   └── math
-    │       ├── matrix_spec.rb
-    │       └── sparsematrix_spec.rb
-    └── test
-        └── math
-                ├── matrix_test.rb
-                        └── sparsematrix_test.rb
+    └── spec
+        ├── spec_helper.rb
+        └── sparsematrix_spec.rb
 
 ## Installation
 Add this line to your application's Gemfile:

data/Rakefile

@@ -7,6 +7,5 @@ RSpec::Core::RakeTask.new
 task :default => :spec
 desc "Ejecucion de pruebas rspec" 
 task :spec do
-    sh "rspec --color --format documentation -Ilib -Ispec spec/math/matrix_spec.rb"
-    sh "rspec --color --format documentation -Ilib -Ispec spec/math/sparsematrix_spec.rb"
+    sh "rspec --color --format documentation -Ilib -Ispec spec/sparsematrix_spec.rb"
 end

data/lib/sparse_matrix.rb

@@ -1,81 +1,209 @@
 require "sparse_matrix/version"
 
-class SparseMatrix
-    @sparse_mat
-    
-    def initialize(b=0)
-        @sparse_mat=b
-    end
-
-    def to_s
-
-    end
-    
-end
-
-class Matrix_T
-    @mat
-    @filename
+module SparseMatrix
+    class AbstractMatrix
+        
+        def intialize ()
+        
+        end
     
-    def initialize(fn="./input/null")
-        @filename=fn
-        @mat=0
     end
     
-    attr_accessor :mat
+    class SparseMatrix < AbstractMatrix
     
-    def read_matrix
-        text = File.open(@filename).read
-        a = text.split(/\n\n+/)
-        a = text.split(/\n/)
-        @mat = to_m(a)
-    end
     
-    def mapmap(a)
-        a.map { |r|
-            r.map { |e|
-                yield e
-            }
-        }
     end
     
-    def to_m(a)
-        a = a.map { |r| r.split(/\s+/) }
-        a = mapmap(a) { |x| x.to_f }
-    end
     
-    def to_s()
-        s="| "
-        for i in (0... @mat.length)
-            for j in (0... @mat.length)
-                if j==0
-                    s += "{ "
+    class DenseMatrix < AbstractMatrix
+        @mat
+        @filename
+        def initialize(fn="./input/null")
+            @filename=fn
+            @mat = 0
+        end
+        
+        attr_accessor :mat
+            
+        def read_matrix
+            text = File.open(@filename).read
+            a = text.split(/\n\n+/)
+            a = text.split(/\n/)
+            @mat = to_m(a)
+        end
+            
+        def mapmap(a)
+            a.map { |r|
+                r.map { |e|
+                    yield e
+                }
+            }
+        end
+            
+        def to_m(a)      
+            a = a.map { |r| r.split(/\s+/) }
+            a = mapmap(a) { |x| x.to_f }
+        end
+            
+        def to_s()
+            s="| "
+            for i in (0... @mat.length)
+                for j in (0... @mat.length)
+                    if j==0
+                        s += "{ "
+                    end
+                    s += "#{@mat[i][j]}\t"
+                    if j == @mat.length-1
+                        s += " } , "
+                    end
                 end
-                s += "#{@mat[i][j]}\t"
-                if j == @mat.length-1
-                    s += " } , "
+            end
+            s += "|"
+        end
+            
+        def print_matrix()
+            printf "| "
+            for i in (0... @mat.length)
+                for j in (0... @mat.length)
+                    if j==0
+                        printf "{ "
+                    end
+                    printf "#{@mat[i][j]}\t"
+                    if j == @mat.length-1
+                        printf " } ,"
+                    end
                 end
             end
+            printf "|"
         end
-        s += "|"
-    end
-    
-    def print()
-        printf "| "
-        for i in (0... @mat.length)
-            for j in (0... @mat.length)
-                if j==0
-                    printf "{ "
+            
+        def +(b)
+            c = DenseMatrix.new()
+            c.read_matrix
+            for i in (0...@mat.length)
+                for j in(0...@mat.length)
+                    c.mat[i][j] = self.mat[i][j]+b.mat[i][j]
                 end
-                printf "#{@mat[i][j]}\t"
-                if j == @mat.length-1
-                    printf " } , "
+            end
+            c
+        end
+        
+        def *(b)
+            c=DenseMatrix.new()
+            c.read_matrix
+            for i in(0...@mat.length)
+                for j in(0...@mat.length)
+                    c.mat[i][j]=0
+                    for k in (0...@mat.length)
+                        c.mat[i][j] += @mat[i][k]*b.mat[k][j]
+                    end
                 end
             end
+            c
         end
-        printf "|"
     end
     
-    
-    
+    class Fraction
+        include Comparable
+        def  initialize (*args)
+            if args.size == 2
+                c = gcd(args[0],args[1])
+                @num_ = (args[0]/c)
+                @den_ = (args[1]/c)
+            else
+                @num_ = args[0]
+                @den_ = 1
+            end
+        end
+        attr_accessor :num_,:den_
+        
+        def to_s
+            "#{@num_}/#{@den_}"
+        end
+        def to_f
+            @num_.to_f/@den_.to_f
+        end
+        
+        def ==(b)
+            return @num_.eql?(b.num_) && @den_.eql?(b.den_)
+        end
+        
+        def abs
+            c = @num_.to_f/@den_.to_f
+            return c.abs
+        end
+       
+        def reciprocal
+            f=Fraction.new
+            f.num_=@den_
+            f.den_ = @num_
+            f
+        end
+        
+        def -@
+            Fraction.new(-@num_,@den_)
+        end
+        
+        def +(b)
+            r=Fraction.new
+            if (@den_==b.den_)
+                r.num_ = @num_ + b.num_
+                r.den_ = @den_
+            else
+                r.num_ = @num_ * b.den_ + b.num_ * @den_
+                r.den_ = @den_ * b.den_
+            end
+            r.num_,r.den_ = minimiza(r.num_,r.den_)
+            return r
+        end
+        
+        def -(b)
+            r =Fraction.new
+            if (@den_ == b.den_)
+                r.num_=@num_- b.num_
+                r.den_=@den_
+            else
+                r.num_=@num_ * b.den_ - b.num_ * @den_
+                r.den_ = @den_ * b.den_
+            end
+            r.num_,r.den_ = minimiza(r.num_,r.den_)
+            r
+        end
+        
+        def *(b)
+            r =Fraction.new
+            r.num_=@num_ * b.num_
+            r.den_=@den_ * b.den_
+            r.num_,r.den_ = minimiza(r.num_,r.den_)
+            return r
+        end
+
+        def /(b)
+            r =Fraction.new
+            r.num_=@num_ / b.num_
+            r.den_=@den_ * b.den_
+            r.num_,r.den_ = minimiza(r.num_,r.den_)
+            r
+        end
+        
+        def <=>(b)
+            self.to_f <=> b.to_f
+        end
+        
+        def minimiza(x,y)
+            d = gcd(x,y)
+            x = x/d
+            y = y/d
+            return x,y
+        end
+    end
+
+    def gcd(u, v)
+        u, v = u.abs, v.abs
+        while v != 0
+            u, v = v, u % v
+        end
+        u
+    end
+
 end

data/lib/sparse_matrix/version.rb

@@ -1,3 +1,3 @@
 module SparseMatrix
-  VERSION = "0.0.1"
+  VERSION = "0.3.1"
 end

data/spec/sparsematrix_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+include SparseMatrix
+
+describe SparseMatrix do
+
+    describe AbstractMatrix do
+    
+    end
+    
+    describe SparseMatrix do
+    
+    end
+
+
+    describe DenseMatrix do
+        before :all do
+            DMA = DenseMatrix.new("input/matrix_a")
+            DMB = DenseMatrix.new("input/matrix_b")
+        end
+        
+        it 'existe una clase Matrix' do
+            DMA.instance_of?(DenseMatrix) == true
+        end
+        
+        it 'No se ha cargado los datos del fichero al objeto Matrix_T' do
+            DMA.mat.should eq(0)
+        end
+        
+        it 'Se han cargado los datos al objeto A' do
+            DMA.read_matrix
+            DMA.mat.should be_kind_of(Array)
+        end
+        
+        it 'Se han cargado los datos al objeto B' do
+            DMB.read_matrix
+            DMB.mat.should be_kind_of(Array)
+        end
+        
+        it 'Existe metodo imprimir matrix?' do
+            DMA.should respond_to("print_matrix")
+        end
+        
+        it 'Se muetra la matriz correctamente?' do
+            DMA.print_matrix.should eq(nil)
+        end
+        
+        it 'Se convierte la matriz correctamente?' do
+            DMA.to_s.should eq("| { 1.0\t2.0\t } , { 4.0\t5.0\t } , |")
+        end
+        
+        it 'suma de matrices, existe metodo?' do
+            DMA.should respond_to("+")
+        end
+        
+        it 'suma de matrices, suma correctamente?' do
+            (DMA+DMB).to_s.should eq("| { 2.0\t4.0\t } , { 7.0\t9.0\t } , |")
+        end
+        
+        it 'multiplicar matrices, existe metodo?' do
+            DMA.should respond_to("*")
+        end
+        
+        it 'multiplicar matrices, multiplica correctamente?' do
+            (DMA*DMB).to_s.should eq("| { 7.0\t10.0\t } , { 19.0\t28.0\t } , |")
+        end
+    end
+
+    describe Fraction do
+        before :all do
+            FA = Fraction.new(1,1)
+            FB = Fraction.new(1,4)
+        end
+
+        describe" basicas" do
+            it "Existe un numerador" do
+                FA.num_.should == 1
+            end
+            it "Existe un denominador" do
+                FA.den_.should == 1
+            end
+            it "se debe mostrar en consola de la forma a/b" do
+                FA.to_s.should == "1/1"
+            end
+            it "se debe mostrar en consola la fraccion en formato flotante" do
+                FA.to_f.should == 1.0
+            end
+        end
+
+        describe "Unarias" do
+            it "Se debe comparar si dos fracciones son iguales con ==" do
+                (FA==FB).should == false
+            end
+
+            it "Se debe calcular el valor absoluto de una fraccion con el meto abs" do
+                FA.abs.should == 1
+            end
+            it "Se debe calcular el reciproco" do
+                (FB.reciprocal).to_s.should == "4/1"
+            end
+            it "Calcular el opuesto de la fraccion con -" do
+                (-FA).to_s.should == "-1/1"
+            end
+        end
+
+        describe "aritmeticas" do
+            it "Se debe sumar dos fracciones con +" do
+                (FA+FB).to_s.should == "5/4"
+            end
+            it "Se debe restar dos fracciones con -" do
+                (FA-FB).to_s.should == "3/4"
+            end
+            it "Se debe multiplicar dos fracciones con *" do
+                (FA*FB).to_s.should == "1/4"
+            end
+            it "Se debe dividir dos fracciones con /" do
+                (FA/FB).to_s.should == "1/4"
+            end
+        end
+
+        describe "Comparacion" do
+            it "Se debe de poder comprobar si una fraccion es menor que otra" do
+                (FB<FA).should == true 
+            end
+            it "Se debe de poder comprobar si una fraccion es mayor que otra" do
+                (FA>FB).should == true
+            end
+            it "Se debe de poder comprobar si una fraccion es menor o igual que otra" do
+                (FB<=FA).should == true
+            end
+            it "Se debe de poder comprobar si una fraccion es mayor o igual que otra" do
+                (FA>=FB).should == true
+            end
+        end
+    end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'sparse_matrix'
+
+RSpec.configure do |config|
+    config.treat_symbols_as_metadata_keys_with_true_values = true
+    config.run_all_when_everything_filtered = true
+    config.filter_run :focus
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sparse_matrix
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.3.1
 platform: ruby
 authors:
 - KevinRobayna
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-12 00:00:00.000000000 Z
+date: 2013-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -111,14 +111,11 @@ files:
 - input/matrix_a
 - input/matrix_b
 - input/null
-- lib/matrix.rb
 - lib/sparse_matrix.rb
 - lib/sparse_matrix/version.rb
 - sparse_matrix.gemspec
-- spec/math/matrix_spec.rb
-- spec/math/sparsematrix_spec.rb
-- test/math/matrix_test.rb
-- test/math/sparsematrix_test.rb
+- spec/sparsematrix_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/kevinrobayna/SparseMatrix
 licenses:
 - MIT
@@ -144,7 +141,5 @@ signing_key:
 specification_version: 4
 summary: sparse matrix
 test_files:
-- spec/math/matrix_spec.rb
-- spec/math/sparsematrix_spec.rb
-- test/math/matrix_test.rb
-- test/math/sparsematrix_test.rb
+- spec/sparsematrix_spec.rb
+- spec/spec_helper.rb

data/lib/matrix.rb

@@ -1,66 +0,0 @@
-class Matrix_T
-    @mat
-    @filename
-    
-    def initialize(fn="./input/null")
-        @filename=fn
-        @mat=0
-    end
-
-    attr_accessor :mat
-
-    def read_matrix
-        text = File.open(@filename).read
-        a = text.split(/\n\n+/)
-        a = text.split(/\n/)
-        @mat = to_m(a)
-    end
-
-    def mapmap(a)
-         a.map { |r|
-             r.map { |e|
-                 yield e
-             }
-         }
-    end
-
-    def to_m(a)
-        a = a.map { |r| r.split(/\s+/) }
-        a = mapmap(a) { |x| x.to_f }
-    end
-
-    def to_s()
-        s="| "
-        for i in (0... @mat.length)
-            for j in (0... @mat.length)
-                if j==0
-                    s += "{ "
-                end
-                s += "#{@mat[i][j]}\t"
-                if j == @mat.length-1
-                    s += " } , "
-                end
-            end
-        end
-        s += "|"
-    end
-
-    def print()
-        printf "| "
-        for i in (0... @mat.length)
-            for j in (0... @mat.length)
-                if j==0
-                    printf "{ "
-                end
-                printf "#{@mat[i][j]}\t"
-                if j == @mat.length-1
-                    printf " } , "
-                end
-            end
-        end
-        printf "|"
-    end
-
-
-
-end

data/spec/math/matrix_spec.rb

@@ -1,56 +0,0 @@
-require 'sparse_matrix'
-
-describe Matrix_T do
-    before :all do
-        A = Matrix_T.new("input/matrix_a")
-    end
-    describe "Basicas" do
-        it 'Existe una clase Matrix?' do
-            A.instance_of?(Matrix_T) == true
-        end
-
-        it 'Se puede acceder a la matriz?' do
-            A.mat.should == 0
-        end
-    end
-
-    describe "Construyendo Matriz" do
-        it 'Existe metodo para leer matrices (READ-MATRIX)?' do
-            A.should respond_to("read_matrix")
-        end
-
-        it 'Existe sub-metodo para leer matrices (MAPMAP)?' do
-            A.should respond_to("mapmap")
-        end
-
-        it 'Existe sub-metodo para leer matrices (TO_M)?' do
-            A.should respond_to("to_m")
-        end
-
-        it 'Se han cargado los datos al objeto A' do
-            A.read_matrix
-            A.mat.should be_kind_of(Array)
-        end
-
-    end
-
-    describe "Mostrando Matrices" do
-        it 'Existe metodo to_s para devolver una matriz?' do
-            A.should respond_to("to_s")
-        end
-
-        it 'Existe metodo print para mostrar una matriz?' do
-            A.should respond_to("print")
-        end
-        
-        it 'El Metodo to_s devuelve correctamente la matriz?' do
-            A.to_s.should eq("| { 1.0\t2.0\t } , { 4.0\t5.0\t } , |")
-        end
-        
-        it 'El metodo print imprime correctamente la matriz?' do
-            A.print.should eq(nil)
-        end
-    end
-        
-
-end

data/spec/math/sparsematrix_spec.rb

@@ -1,16 +0,0 @@
-require 'sparse_matrix.rb'
-
-describe SparseMatrix do
-
-    before :all do
-        A = SparseMatrix.new()
-    end
-
-    describe "Basicas" do
-       
-        it 'Existe una clase SparseMatrix?' do
-            A.instance_of?(SparseMatrix) == true
-        end
-
-    end
-end