sparse_matrix 1.0.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4120f3a75b5bbe035792ea2d4591242c98e47b8f
-  data.tar.gz: fa31f06d130f45b3faf16c54f4856a3bc996d007
+  metadata.gz: e4890f260249f7bd02beb51cf3cc713d450dcae7
+  data.tar.gz: c1d4379a558a4cdfb340a9492cb7b4893a7196bf
 SHA512:
-  metadata.gz: 9705df1392dd449ce9e1c22a027800fb79acc56e3d43de157a0c991fe7432870a7e789d54dcf38ad3ddd70f862fd441b992cb32414dd266250a0c910236ec75d
-  data.tar.gz: 93eb2b3be78734d111532d11077a6e29b73bdeab7d20fcde756c755245050745ee8b99da043ccc8f263d367b4687521d082c535b39835c4e3cbe793c914a1068
+  metadata.gz: 5d56e3c8300c20e33415c72a700fa7e1c38a284d67a692b4b670a1a4aa9255fa7b6f6bdab22e79437f977189de37d087d3df856d02c174b77e5a56885475b9ce
+  data.tar.gz: b8e7865f84e0244438ab11453c350ecd4f30de4473ee3b4b8af75014646766760a55d5ac6d0ebb725843e1a48f9e26d37e17106dcd2d53ad2964a3cb7ddb5846

data/README.md

@@ -37,10 +37,6 @@ And then execute:
 Or install it yourself as:
 
     $ gem install sparse_matrix
-
-## Usage
-as soon as
-
 ## Authors 
     Kevin Robayna 
     Jose Antonio Rodriguez Leandro

data/lib/sparse_matrix.rb

@@ -7,103 +7,152 @@ module SparseMatrix
             @row = r
             @column = c
         end
-
+        
         attr_accessor :row,:column
-
-        def read_matrix
         
+        def read_matrix
+            raise "Error. metodo no definido."
         end
         
         def to_s
-
+            raise "Error. metodo no definido."
         end
-            
-        def print_matrix
-        
-        end
-            
-        def +(b)
         
+        def print_matrix
+            raise "Error. metodo no definido."
         end
         
-        def *(b)
-        
-        end
+        def +(b)
+        raise "Error. metodo no definido."
     end
+    
+    def *(b)
+    raise "Error. metodo no definido."
+end
+end
 
-    class SparseVector
-        @i
-        @j
-        @value
+class SparseVector
+    def initialize(i=0,j=0,v=0)
+        @i = i
+        @j = j
+        @value = v
+    end
+    attr_accessor :i,:j,:value
+    
+    def to_s
+        "#{@i},#{@j},#{@value}"
+    end
+    
+end
 
+class SparseMatrix < AbstractMatrix
+    
+    def initialize(*args)
+        @n,@m=args[0],args[1]
+        datos = args[2]
+        @MAT = Array.new()
+        for i in 0...@n
+            for j in 0...@m
+                if datos[i][j] != 0
+                    @MAT[i]=SparseVector.new(i,j,datos[i][j])
+                end
+            end
+        end
+        @max=max()
+        @min=min()
     end
+    attr_accessor :MAT
     
-    class SparseMatrix < AbstractMatrix
+    def insert(vector)
+        @MAT<<vector
+    end
     
+    def to_s
+        cadena=""
+        for i in 0...@n
+            cadena+="["
+            for j in 0...@m
+                cadena+=self.valor(i,j).to_s
+                if j < @m-1
+                    cadena+=", "
+                end
+            end
+            cadena+="]"
+        end
+        return cadena
+        
+    end
     
+    def valor(k,j)
+        dev=0
+        for i in 0...@MAT.size
+            if(@MAT[i].i==k) && (@MAT[i].j==j)
+                return @MAT[i].value
+            end
+        end
+        dev
     end
     
     
-    class DenseMatrix < AbstractMatrix
-        @mat
-        def initialize(r=0,c=0,matrix=[])
-            super(r,c)
-            @mat = matrix
+    def max
+        maximo=@MAT[0].value
+        for i in 0...@m do
+            if maximo < @MAT[i].value
+                maximo=@MAT[i].value
+            end
+        end
+        return maximo
         end
         
-        attr_accessor :mat
-            
-        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
+        def min
+            minimo=@MAT[0].value
+            for i in (0...@m) do
+                if minimo > @MAT[i].value
+                    minimo=@MAT[i].value
                 end
             end
-            s += "|"
-        end
+            return minimo
+            end
             
-        def print_matrix()
-            printf "| "
-            for i in (0... @mat.length)
-                for j in (0... @mat.length)
-                    if j==0
-                        printf "{ "
+            def +(other)
+            if other.instance_of? SparseMatrix
+                o=DenseMatrix.new(@n,@m,Array.new(@n){Array.new(@m)})
+                for i in 0...@MAT.size
+                    for j in 0...@MAT.size
+                        o.mat[i][j]=self.valor(i,j)+other.valor(i,j)
                     end
-                    printf "#{@mat[i][j]}\t"
-                    if j == @mat.length-1
-                        printf " } ,"
+                end
+                return SparseMatrix.new(@n,@m,o.mat)                       #SparseMatrix.new(@n,@m,o)
+                else
+                o=DenseMatrix.new(@n,@m,Array.new(@n){Array.new(@m)})
+                for i in 0...@n
+                    for j in 0...@m
+                        o.mat[i][j]=self.valor(i,j)+other.mat[i][j]
                     end
                 end
+                return o
             end
-            printf "|"
         end
-            
-        def +(b)
+        
+        def *(b)
+        if b.instance_of? SparseMatrix
             c = DenseMatrix.new(2,2,[[0.0,0.0],[0.0,0.0]])
-            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]
+            for i in(0...@MAT.size)
+                for j in(0...@MAT.size)
+                    c.mat[i][j]=0
+                    for k in (0...@MAT.size)
+                        c.mat[i][j] += self.valor(i,k)*b.valor(k,j)
+                    end
                 end
             end
             c
-        end
-        
-        def *(b)
+            else
             c = DenseMatrix.new(2,2,[[0.0,0.0],[0.0,0.0]])
-            c.read_matrix
-            for i in(0...@mat.length)
-                for j in(0...@mat.length)
+            for i in(0...@MAT.size)
+                for j in(0...@MAT.size)
                     c.mat[i][j]=0
-                    for k in (0...@mat.length)
-                        c.mat[i][j] += @mat[i][k]*b.mat[k][j]
+                    for k in (0...@MAT.size)
+                        c.mat[i][j] += self.valor(i,k)*b.mat[k][j]
                     end
                 end
             end
@@ -111,107 +160,201 @@ module SparseMatrix
         end
     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
+
+
+class DenseMatrix < AbstractMatrix
+    @mat
+    def initialize(r=0,c=0,matrix=[])
+        super(r,c)
+        @mat = matrix
+    end
+    
+    attr_accessor :mat,:r,:c
+    
+    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
-        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_
+        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
-            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_
+        printf "|"
+    end
+    
+    def +(b)
+    c = DenseMatrix.new(2,2,[[0.0,0.0],[0.0,0.0]])
+    if b.instance_of? SparseMatrix
+    for i in (0...@mat.length)
+    for j in (0...@mat.size)
+    c.mat[i][j] = self.mat[i][j]+b.valor(i,j)
+end
+end
+c
+else
+for i in (0...mat.length)
+    for j in (0...@mat.size)
+        c.mat[i][j] = self.mat[i][j]+b.mat[i][j]
+    end
+end
+c
+end
+end
+
+def *(b)
+if b.instance_of? SparseMatrix
+    c = DenseMatrix.new(2,2,[[0.0,0.0],[0.0,0.0]])
+    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.valor(k,j)
             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
+    c
+    else
+    c = DenseMatrix.new(2,2,[[0.0,0.0],[0.0,0.0]])
+    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
+end
+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
+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 gcd(u, v)
-        u, v = u.abs, v.abs
-        while v != 0
-            u, v = v, u % v
-        end
-        u
+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
+
+def coerce(other)
+    [self,other]
+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 = "1.0.0"
+  VERSION = "1.5.0"
 end

data/spec/sparsematrix_spec.rb

@@ -36,14 +36,90 @@ describe SparseMatrix do
     end
 
     describe SparseVector do
-
+        before :all do
+            SV = []
+            SVF = []
+            SV << SparseVector.new(1,2,3.0)
+            FRAC = Fraction.new(1,4)
+            SVF << SparseVector.new(1,1,FRAC)
+            
+        end
+        describe "Basicas" do
+            it 'existe una clase sparse vector' do
+                SV.instance_of?(SparseVector) == true
+            end
+            it 'existen los getter y setter? (i)' do
+                SV[0].i.should == 1
+            end
+            it 'existen los getter y setter? (j)' do
+                SV[0].j.should == 2
+            end
+            it 'existen los getter y setter? (value)' do
+                SV[0].value.should == 3.0
+            end
+        end
+        describe "Configuracion y muestreo" do
+           it 'existe un metodo to_s' do
+              SV.should respond_to("to_s") 
+           end
+           it 'se retorna correctamente un vector (sin Fraccion)' do
+              SV[0].to_s.should eq("1,2,3.0")
+           end
+           it 'se retorna correctamente un vector (con Fraccion)' do
+              SVF[0].to_s.should eq("1,1,1/4")
+           end
+        end
     end
     
     describe SparseMatrix do
-    
+        before :all do
+            DM = DenseMatrix.new(2,2,[[1.0,2.0],[4.0,5.0]])
+            SM = SparseMatrix::SparseMatrix.new(2,2,[[2.0,0.0],[4.0,0.0]])
+        end
+        describe "Basicas" do
+            it 'existe una clase sparse Matrix' do
+                SM.instance_of?(SparseMatrix) == true
+            end
+            it 'Existe metodo insertar registro' do
+                SM.should respond_to("insert")
+            end
+            it 'Existe metodo to_s' do
+                SM.should respond_to("to_s")
+            end
+        end
+        describe "funcionalidades" do
+            it 'existe metodo maximo' do
+                SM.should respond_to("max")
+            end
+            it 'existe metodo minimo' do
+                SM.should respond_to("min")
+            end
+            it 'calcula el maximo correctamente' do
+                SM.max.should==4  
+            end
+            it 'calcula el minimo correctamente' do
+                SM.min.should==2
+            end
+            it 'calcula la suma de matrices dispersa + densa' do
+                (SM+DM).to_s.should=="| { 3.0\t2.0\t } , { 8.0\t5.0\t } , |"
+            end
+            it 'calcula la suma de matrices densa + dispersa' do
+                (DM+SM).to_s.should=="| { 3.0\t2.0\t } , { 8.0\t5.0\t } , |"
+            end
+            it 'calcula la suma de matrices dispersa + dispersa' do
+                (SM+SM).to_s.should=="[4.0, 0][8.0, 0]"
+            end
+            it 'calcula la multiplicacion matrices dispersa * densa' do
+                (SM*DM).to_s.should=="| { 2.0\t4.0\t } , { 4.0\t8.0\t } , |"
+            end
+            it 'calcula la multiplicacion matrices densa * dispersa' do
+                (DM*SM).to_s.should=="| { 10.0\t0.0\t } , { 28.0\t0.0\t } , |"
+            end
+            it 'calcula la multiplicacion matrices dispersa * dispersa' do
+                (SM*SM).to_s.should=="| { 4.0\t0.0\t } , { 8.0\t0.0\t } , |"
+            end
     end
 
-
     describe DenseMatrix do
         before :all do
             DMA = DenseMatrix.new(2,2,[[1.0,2.0],[4.0,5.0]])
@@ -89,6 +165,7 @@ describe SparseMatrix do
         it 'multiplicar matrices, multiplica correctamente?' do
             (DMA*DMB).to_s.should eq("| { 7.0\t10.0\t } , { 19.0\t28.0\t } , |")
         end
+     end
     end
 
     describe Fraction do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sparse_matrix
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.5.0
 platform: ruby
 authors:
 - KevinRobayna
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-20 00:00:00.000000000 Z
+date: 2013-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler