NetAnalyzer 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 412854b58d2f6a2dbb1844cb943a90c9b96f7fd6
-  data.tar.gz: df275072cb0d1bb9b9d15099b089897471566eb8
+  metadata.gz: c09e22b1a1867c0ab7c8f8a07214d05d68b3411f
+  data.tar.gz: 3343dd6ae5b60ba7916089118e8e7079db022b2b
 SHA512:
-  metadata.gz: a6d3be799d9def07f7addef75dfad5a8d1c6b9d14c684d3dcb227b6be68ef22912ab069beb2e439d07a08b7dc2a6d7d0f38e873a1303a099c3c110c9cf6b075b
-  data.tar.gz: 561ad012584a397023897047b0e401a96246d39a67082f0c7cfd3ee6dc3cb8075d77d08bb75ae34a8174cbc13e5a8439f0348175f38133162f54ef9e6b55c07c
+  metadata.gz: e2d887cb3d500aa68f45f880f5e25405e186f7658f851c7a9c1a3124ea79263b905671fa244dfbaf6c0c5e8dd13c084af7762493e2b9b02ecb1be08b6ef0b01e
+  data.tar.gz: 23958924d092afdfe317a8ba87b6ea4578e74794ce311ef4549cd0a74e88f8dbe0dd60fcf8dc9179ac591652c9254f615f46965ae1c5b98ba5f00e67761b3773

data/NetAnalyzer.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |spec|
   spec.name          = "NetAnalyzer"
   spec.version       = NetAnalyzer::VERSION
   spec.authors       = ["Elena Rojano, Pedro Seoane"]
-  spec.email         = ["elenarojano@uma.es, seoanezonjic@uma.es"]
+  spec.email         = ["elenarojano@uma.es, seoanezonjic@hotmail.com"]
 
   spec.summary       = %q{Network analysis tool that calculate and validate different association indices.}
   spec.description   = %q{NetAnalyzer is a useful network analysis tool developed in Ruby that can 1) analyse any type of unweighted network, regardless of the number of layers, 2) calculate the relationship between different layers, using various association indices (Jaccard, Simpson, PCC, geometric, cosine and hypergeometric) and 3) validate the results}
@@ -24,4 +24,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_dependency "nmatrix"
   spec.add_dependency "bigdecimal"
+  spec.add_dependency "benchmark"
 end

data/Rakefile

@@ -1,6 +1,13 @@
 require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+#require "rspec/core/rake_task"
 
-RSpec::Core::RakeTask.new(:spec)
+#RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+#task :default => :spec
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = "test/*_test.rb"
+end

data/bin/NetAnalyzer.rb

@@ -2,29 +2,11 @@
 
 ROOT_PATH = File.dirname(__FILE__)
 $: << File.expand_path(File.join(ROOT_PATH, '..', 'lib', 'NetAnalyzer'))
+$: << File.expand_path(File.join(ROOT_PATH, '..', 'lib', 'NetAnalyzer', 'methods'))
 
 require 'network'
 require 'optparse'
 
-##############################
-# MAIN METHODS
-##############################
-
-def set_layer(layer_definitions, node_name)
-	layer = nil
-	if layer_definitions.length > 1
-		layer_definitions.each do |layer_name, regexp|
-			if node_name =~ regexp
-				layer = layer_name
-				break
-			end
-		end
-	else
-		layer = layer_definitions.first.first
-	end
-	return layer
-end
-
 ##############################
 #OPTPARSE
 ##############################
@@ -97,18 +79,11 @@ end.parse!
 ##########################
 
 fullNet = Network.new(options[:layers].map{|layer| layer.first})
+#puts options[:layers].map{|layer| layer.first}.inspect
 puts "Loading network data"
-File.open(options[:input_file]).each("\n") do |line|
-	line.chomp!
-	pair = line.split(options[:splitChar])
-	node1 = pair[0]
-	node2 = pair[1]
-	fullNet.add_node(node1, set_layer(options[:layers], node1))
-	fullNet.add_node(node2, set_layer(options[:layers], node2))
-	fullNet.add_edge(node1, node2)	
-end
-#fullNet.plot(options[:output_file], options[:output_style])
+fullNet.load_network_by_pairs(options[:input_file], options[:layers], options[:splitChar])
 
+#fullNet.plot(options[:output_file], options[:output_style])
 
 if !options[:meth].nil?
 	puts "Performing association method #{options[:meth]} on network"
@@ -121,7 +96,7 @@ if !options[:meth].nil?
 			:transference)
 	else
 		fullNet.get_association_values(
-			options[:use_layers][0], 
+			options[:use_layers][0],
 			options[:use_layers][1].first, 
 			options[:meth])
 	end

data/lib/NetAnalyzer/network.rb

@@ -2,9 +2,11 @@ require 'nodes'
 require 'nmatrix'
 require 'pp'
 require 'bigdecimal'
+require 'benchmark'
 
 class Network
-	attr_reader :association_values
+
+	attr_accessor :association_values, :control_connections
 
 	## BASIC METHODS
 	############################################################
@@ -16,7 +18,7 @@ class Network
 		@association_values = {}
 		@control_connections = {}
 	end
-	
+
 	def add_node(nodeID, nodeType = 0)
 		@nodes[nodeID] = Node.new(nodeID, nodeType)
 	end
@@ -35,6 +37,23 @@ class Network
 		end
 	end
 
+	def load_network_by_pairs(file, layers, split_character="\t")
+		File.open(file).each("\n") do |line|
+			line.chomp!
+			pair = line.split(split_character)
+			node1 = pair[0]
+			node2 = pair[1]
+			add_node(node1, set_layer(layers, node1))
+			add_node(node2, set_layer(layers, node2))
+			add_edge(node1, node2)	
+		end
+	end
+
+	def get_edge_number
+		node_connections = @edges.values.map{|connections| connections.length}.inject(0){|sum, n| sum + n}
+		return node_connections/2
+	end
+
 	def plot(output_filename, layout="dot")		
 		roboWrite = File.open(output_filename, 'w')
 		roboWrite.puts "digraph g {"
@@ -227,7 +246,7 @@ class Network
 
 	def get_pcc_associations(layers, base_layer)
 		#for Ny calcule use get_nodes_layer
-		ny = get_nodes_layer(layers).length
+		ny = get_nodes_layer([base_layer]).length
 		relations = get_associations(layers, base_layer) do |associatedIDs_node1, associatedIDs_node2, intersectedIDs, node1, node2|
 			intersProd = intersectedIDs.length * ny
 			nodesProd = associatedIDs_node1.length * associatedIDs_node2.length
@@ -241,25 +260,20 @@ class Network
 	end
 
 	def get_hypergeometric_associations(layers, base_layer)
-		ny = get_nodes_layer(layers).length
+		ny = get_nodes_layer([base_layer]).length
 		relations = get_associations(layers, base_layer) do |associatedIDs_node1, associatedIDs_node2, intersectedIDs, node1, node2|
 			minLength = [associatedIDs_node1.length, associatedIDs_node2.length].min
 			intersection_lengths = intersectedIDs.length
 			sum = 0
-			nA = associatedIDs_node1.length
-			nB = associatedIDs_node2.length
-			#Using index from A layer proyected to B
-			(intersection_lengths..minLength).each do |i|
-				binom_product = binom(nA, i) * binom(ny - nA, nB - i)
-				sum += binom_product.fdiv(binom(ny, nB))
-				# binom_product_float = binom_product.to_f
-				# to_f = false
-				# if binom_product_float.infinite? # Handle bignum coercition to bigdecimal to avoid infinity values on float class. 
-				# 	binom_product_float = BigDecimal.new(binom_product)
-				# 	to_f = true
-				# end
-				# sum += binom_product_float / binom(ny, nB)
-				# sum = sum.to_f if to_f # once the operation has finished, sum is corced from bigdecimal to float
+			if intersection_lengths > 0
+				nA = associatedIDs_node1.length
+				nB = associatedIDs_node2.length
+				#Using index from A layer proyected to B
+				hyper_denom = binom(ny, nB)
+				(intersection_lengths..minLength).each do |i|
+					binom_product = binom(nA, i) * binom(ny - nA, nB - i)
+					sum += binom_product.fdiv(hyper_denom)
+				end
 			end
 			if sum == 0
 				hypergeometricValue = 0
@@ -272,52 +286,56 @@ class Network
 		return relations
 	end
 
-	def add_record(hash, key, key2, value)
-		query = hash[key]
+	def add_record(hash, node1, node2)
+		query = hash[node1]
 		if query.nil?
-			hash[key]={key2 => value}
+			hash[node1] = [node2]
 		else
-			query[key2] = value
+			query << node2
 		end
 	end
 
+	def add_nested_record(hash, node1, node2, val)
+		query_node1 = hash[node1]
+		if query_node1.nil?
+			hash[node1] = {node2 => val}
+		else
+			query_node1[node2] = val
+		end
+	end
+
+
 	def get_csi_associations(layers, base_layer)
 		pcc_relations = get_pcc_associations(layers, base_layer)
-		indexed_pcc_relations = {}
+		clean_autorelations_on_association_values if layers.length > 1
+		nx = get_nodes_layer(layers).length
+		pcc_vals = {}
+		node_rels = {}
 		pcc_relations.each do |node1, node2, assoc_index|
-			if assoc_index > 0
-				add_record(indexed_pcc_relations, node1, node2, assoc_index)
-				add_record(indexed_pcc_relations, node2, node1, assoc_index)
-			end
+			add_nested_record(pcc_vals, node1, node2, assoc_index.abs)
+			add_nested_record(pcc_vals, node2, node1, assoc_index.abs)
+			add_record(node_rels, node1, node2)
+			add_record(node_rels, node2, node1)
 		end
-		ny = get_nodes_layer(layers).length
-		relations = get_associations(layers, base_layer) do |associatedIDs_node1, associatedIDs_node2, intersectedIDs, node1, node2|
-			query = indexed_pcc_relations[node1]
-			if query.nil?
-				valid_A_nodes = []
-				pccAB = -0.05
-			else
-				nested_query = query[node2]
-				if nested_query.nil?
-					pccAB = -0.05
-				else
-					pccAB = nested_query - 0.05
-				end
-				valid_A_nodes = query.select{|node_id, pcc| pcc>= pccAB}.keys
+		relations = []
+		pcc_relations.each do |node1, node2 ,assoc_index|
+			pccAB = assoc_index - 0.05
+			valid_nodes = 0
+			node_rels[node1].each do |node|
+				valid_nodes += 1 if pcc_vals[node1][node] >= pccAB
 			end
-			query2 = indexed_pcc_relations[node2]
-			if query2.nil?
-				valid_B_nodes = []
-			else
-				valid_B_nodes = query2.select{|node_id, pcc| pcc>= pccAB}.keys
+			node_rels[node2].each do |node|
+				valid_nodes += 1 if pcc_vals[node2][node] >= pccAB
 			end
-			valid_connections = valid_A_nodes | valid_B_nodes
-			csiValue = 1 - valid_connections.length.to_f/ny
+			csiValue = 1 - (valid_nodes-1).fdiv(nx) 
+			# valid_nodes-1 is done due to the connection node1-node2 is counted twice (one for each loop)
+			relations << [node1, node2, csiValue]
 		end
 		@association_values[:csi] = relations
 		return relations
 	end
 
+
 	## PERFORMANCE METHODS
 	############################################################
 	def load_control(ref_array)
@@ -381,11 +399,11 @@ class Network
 			if !pred_info.nil?
 				labels, scores = pred_info
 				reliable_labels = get_reliable_labels(labels, scores, cut, top)
-
 				predicted_labels += reliable_labels.length #m
 				common_labels += (c_labels & reliable_labels).length #k
 			end
 		end
+		#puts "cut: #{cut} trueL: #{true_labels} predL: #{predicted_labels} commL: #{common_labels}"
 		prec = common_labels.to_f/predicted_labels
 		rec = common_labels.to_f/true_labels
 		prec = 0.0 if prec.nan?
@@ -399,13 +417,28 @@ class Network
 	#######################################################################################
 	private
 
+	def set_layer(layer_definitions, node_name)
+		layer = nil
+		if layer_definitions.length > 1
+			layer_definitions.each do |layer_name, regexp|
+				if node_name =~ regexp
+					layer = layer_name
+					break
+				end
+			end
+		else
+			layer = layer_definitions.first.first
+		end
+		return layer
+	end
+
 	def get_cuts(limits, n_cuts)
 		cuts = []
-		range = (limits.last - limits.first).to_f/n_cuts
+		range = (limits.last - limits.first).abs.fdiv(n_cuts)
+		range = BigDecimal(range, 10)
 		cut = limits.first
-		n_cuts.times do
-			cuts << cut
-			cut += range
+		(n_cuts + 1).times do |n|
+			cuts << (cut + n * range).to_f
 		end
 		return cuts
 	end

data/lib/NetAnalyzer/version.rb

@@ -1,3 +1,3 @@
 module NetAnalyzer
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/old_spec/NetAnalyzer_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe NetAnalyzer do
+  it 'has a version number' do
+    expect(NetAnalyzer::VERSION).not_to be nil
+  end
+
+  it 'does something useful' do
+    expect(false).to eq(true)
+  end
+end

data/old_spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'NetAnalyzer'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: NetAnalyzer
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Elena Rojano, Pedro Seoane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-14 00:00:00.000000000 Z
+date: 2018-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,13 +80,27 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: benchmark
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: NetAnalyzer is a useful network analysis tool developed in Ruby that
   can 1) analyse any type of unweighted network, regardless of the number of layers,
   2) calculate the relationship between different layers, using various association
   indices (Jaccard, Simpson, PCC, geometric, cosine and hypergeometric) and 3) validate
   the results
 email:
-- elenarojano@uma.es, seoanezonjic@uma.es
+- elenarojano@uma.es, seoanezonjic@hotmail.com
 executables:
 - NetAnalyzer.rb
 - console
@@ -109,6 +123,8 @@ files:
 - lib/NetAnalyzer/network.rb
 - lib/NetAnalyzer/nodes.rb
 - lib/NetAnalyzer/version.rb
+- old_spec/NetAnalyzer_spec.rb
+- old_spec/spec_helper.rb
 homepage: https://github.com/ElenaRojano/NetAnalyzer
 licenses:
 - MIT
@@ -129,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: Network analysis tool that calculate and validate different association indices.