NetAnalyzer 0.1.5 → 0.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 35cb3956bb731175602f6149bce80bec19e11d67
-  data.tar.gz: d0b3127557d53140681054dd73f85b781b823408
+SHA256:
+  metadata.gz: 1c71fe9b15d48d8ce8c76d2aec32a60ef2ede83686f49d18b09a8dc7204f07a9
+  data.tar.gz: 697edf91abebe9cbf600b65838dbaa9f0761342bb6f89bcbfadfab270e4ad1ce
 SHA512:
-  metadata.gz: 7848fe8950d1e7ce9ce1a2f74e427a7ff0825cfce3994bfb69580323d5e08b46981810749a1091c8a7fd3e2b7bd0c7e95a265d59e43dbae6f73695ed0e48eb8e
-  data.tar.gz: ff6a98cce36dad00ef8f9eb015343117d8128fd6ddc5f4ade641edc69fb87ad0e4dcb1ecb731caaa2de42bd2a19b3f4b6c23d148e972bc2ecda7a8a8cb1e72d8
+  metadata.gz: eee16b18357c98e62ea4d1799991efb878ad8f8385d50a45a5f89154e3a36829e03768e560b8821dc0e0b7d10b64c2efee3bf3dadf13efb6adc7177f96e41e82
+  data.tar.gz: 1b2b19082a15a60df2585a99d6e3253eef98682398d6969aaa3e584ed8c425147f2389a668be3439474562b2da5100ec4d91f2790b9bce11b9bbbbf868251fb0

data/.rspec

@@ -1,2 +1,3 @@
 --format documentation
 --color
+--require spec_helper

data/Gemfile

@@ -2,3 +2,7 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in NetAnalyzer.gemspec
 gemspec
+semtools_dev_path = File.expand_path('~/dev_gems/semtools')
+gem "semtools", github: "seoanezonjic/semtools", branch: "master" if Dir.exist?(semtools_dev_path)
+expcalc_dev_path = File.expand_path('~/dev_gems/expcalc')
+gem "expcalc", github: "seoanezonjic/expcalc", branch: "master" if Dir.exist?(expcalc_dev_path)

data/NetAnalyzer.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   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}
+  spec.description   = %q{DEPRECATED PROJECT. MIGRATED TO PYTHON: https://github.com/seoanezonjic/NetAnalyzer. 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}
   spec.homepage      = "https://github.com/ElenaRojano/NetAnalyzer"
   spec.license       = "MIT"
 
@@ -19,9 +19,19 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.11"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_dependency "nmatrix"
-  spec.add_dependency "bigdecimal"
+  spec.add_development_dependency "rake", ">= 13.0.3"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "minitest"
+  spec.add_dependency "cmath", ">= 1.0.0"
+  spec.add_dependency "numo-linalg", ">= 0.1.5"
+  spec.add_dependency "numo-narray", ">= 0.9.1.9"
+  spec.add_dependency "pp", ">= 0.1.0"
+  spec.add_dependency "npy", ">= 0.2.0"
+  spec.add_dependency "bigdecimal", ">= 3.0.0"
+  spec.add_dependency "gv", ">= 0.1.0"
+  spec.add_dependency "semtools", ">= 0.1.1"
+  spec.add_dependency "expcalc"
+  spec.add_dependency "parallel" 
+  spec.add_dependency "rubystats"
+  spec.add_dependency "red-colors"
 end

data/README.md

@@ -1,8 +1,14 @@
 # NetAnalyzer
 
+DEPRECATED PROJECT. MIGRATED TO [python semtools](https://github.com/seoanezonjic/NetAnalyzer)
+ 
 NetAnalyzer is a network analysis tool that can be used to calculate the associations between nodes in unweighted n-partite networks [1]. The calculation of the association between nodes is based on similarity indices (Jaccard, Simpson, geometric and cosine), statistic-based (Pearson correlation coefficient, CSI and  hypergeometric) [2] and a special metric designed only for tripartite networks (here called as 'transference' method [3]). The user can choose the association index method according to the network to analyse. The tool gives a table of results, with all the associations between nodes and the association value calculated.
+ 
+If you use this tool, please cite us: [1] E. Rojano, P. Seoane, A. Bueno, J. R. Perkins & J. A. G. Ranea. Revealing the Relationship Between Human Genome Regions and Pathological Phenotypes Through Network Analysis. Lecture Notes in Computer Science, Vol 10208, 197-207 (2017).
 
-If you use this tool, please cite us: E. Rojano, P. Seoane, A. Bueno, J. R. Perkins & J. A. G. Ranea. Revealing the Relationship Between Human Genome Regions and Pathological Phenotypes Through Network Analysis. Lecture Notes in Computer Science, Vol 10208, 197-207 (2017).
+[2] Fuxman-Bass et al. Using networks to measure similarity between genes: association index selection. Nature Methods, 10(12):1169-76. 2013.
+
+[3] Alaimo et al. ncPred: ncRNA-Disease Association Prediction through Tripartite Network-Based Inference. Frontiers in Bioengineering and Biotechnology, 2:71, 2014.
 
 ## Installation
 
@@ -32,7 +38,6 @@ Once nmatrix gem is installed:
 gem install 'NetAnalyzer'
 ```
 
-
 ## Usage
 
 The program NetAnalyzer.rb can analyse an unweighted network to calculate the association index between different nodes. 
@@ -47,9 +52,18 @@ Where:
 -i: Input file with the network to analyse. It must have two columns (separated by default by tabs) that represents the nodes that are related (NodeA\tNodeB). Please if you have doubts about the format, check the example providen.
 -l: Layers construction. Please consider that, depending on the n-partite network you provide, NetAnalyzer will transform it into a bipartite one to perform the analysis (excepting if the association method used is 'transference'). The layers must contain a identifier of the node, and a character or pattern to identify. In this example, the bipartite network has HPO terms (with 'HP:' string in each of them) and patients that have these HPO terms (they are given as numerical patient IDs). Both layers must be separated by ';'.
 -m: Association method. There are 8 different association methods to choose: 'jaccard', 'cosine', 'pcc', 'csi', 'hypergeometric', 'simpson', 'geometric' and 'transference'.
+-u: Set which layer will be the one that establish connections between nodes in the other layer. In this case, we will get with patient is associated to other patient because the HPO they share.
 -a: Associations output file name. Here you can find the associations between nodes in the network and the calculated association value, according to the chosen method.
 ``` 
 
+Optional flags:
+
+```
+-s: Split character. Change if the layers of the network are not separated by tabs.
+-o: Output file name.
+
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/Rakefile

@@ -1,13 +1,17 @@
 require "bundler/gem_tasks"
-#require "rspec/core/rake_task"
+require "rake/testtask"
+require 'rdoc/task'
 
-#RSpec::Core::RakeTask.new(:spec)
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
 
-#task :default => :spec
+RDoc::Task.new do |rdoc|
+  rdoc.main = "README.doc"
+  rdoc.rdoc_files.include("README.md", "lib/*.rb", "lib/NetAnalyzer/*.rb")
+  rdoc.options << "--all"
+end
 
-require 'rake/testtask'
-
-Rake::TestTask.new do |t|
-  t.libs << 'test'
-  t.pattern = "test/*_test.rb"
-end
+task :default => :test

data/bin/NetAnalyzer.rb

@@ -1,11 +1,21 @@
 #! /usr/bin/env ruby
 
 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'
+$LOAD_PATH.unshift(File.expand_path(File.join(ROOT_PATH, '..', 'lib')))
 require 'optparse'
+require 'benchmark'
+require 'NetAnalyzer'
+
+######################################
+## METHODS
+######################################
+def load_file(path)
+  data = []
+  File.open(path).each do |line|
+    data << line.chomp.split("\t")
+  end
+  return data
+end
 
 ##############################
 #OPTPARSE
@@ -20,11 +30,26 @@ OptionParser.new do |opts|
     options[:input_file] = input_file
   end
 
+  options[:node_file] = nil
+  opts.on("-n", "--node_names_file PATH", "File with node names corresponding to the input matrix, only use when -i is set to bin or matrix.") do |node_file|
+    options[:node_file] = node_file
+  end
+
+  options[:input_format] = 'pair'
+  opts.on("-f", "--input_format STRING", "Input file format: pair (default), bin, matrix") do |input_format|
+    options[:input_format] = input_format
+  end
+
   options[:split_char] = "\t"
   opts.on("-s", "--split_char STRING", "Character for splitting input file. Default: tab") do |split_char|
     options[:split_char] = split_char
   end
 
+  options[:use_pairs] = :conn
+  opts.on("-P", "--use_pairs STRING", "Which pairs must be computed. 'all' means all posible pair node combinations and 'conn' means the pair are truly connected in the network. Default 'conn' ") do |use_pairs|
+    options[:use_pairs] = use_pairs.to_sym
+  end
+
   options[:output_file] = "network2plot"
   opts.on("-o", "--output_file PATH", "Output file name") do |output_file|
     options[:output_file] = output_file
@@ -35,6 +60,11 @@ OptionParser.new do |opts|
     options[:assoc_file] = output_file
   end
 
+  options[:kernel_file] = "kernel_values"
+  opts.on("-K", "--kernel_file PATH", "Output file name for kernel values") do |output_file|
+    options[:kernel_file] = output_file
+  end
+
   options[:performance_file] = "perf_values.txt"
   opts.on("-p", "--performance_file PATH", "Output file name for performance values") do |output_file|
     options[:performance_file] = output_file
@@ -42,8 +72,8 @@ OptionParser.new do |opts|
 
   options[:layers] = [:layer, '-']
   opts.on("-l", "--layers STRING", "Layer definition on network: layer1name,regexp1;layer2name,regexp2...") do |layers|
-	layers_definition = layers.split(";").map{|layer_attr| layer_attr.split(',')}
-	layers_definition.map!{|layer_attr| [layer_attr.first.to_sym, /#{layer_attr.last}/]}
+  	layers_definition = layers.split(";").map{|layer_attr| layer_attr.split(',')}
+	  layers_definition.map!{|layer_attr| [layer_attr.first.to_sym, /#{layer_attr.last}/]}
     options[:layers] = layers_definition
   end
 
@@ -62,28 +92,118 @@ OptionParser.new do |opts|
     options[:output_style] = output_style
   end
 
+  options[:ontologies] = []
+  opts.on("-O", "--ontology STRING", "String that define which ontologies must be used with each layer. String definition:'layer_name1:path_to_obo_file1;layer_name2:path_to_obo_file2'") do |ontologies|
+    options[:ontologies] = ontologies.split(';').map{|pair| pair.split(':')}
+  end
+
   options[:meth] = nil
   opts.on("-m", "--association_method STRING", "Association method to use on network") do |meth|
     options[:meth] = meth.to_sym
   end
 
-  options[:no_autorelations] = FALSE
+  options[:kernel] = nil
+  opts.on("-k", "--kernel_method STRING", "Kernel operation to perform with the adjacency matrix") do |kernel|
+    options[:kernel] = kernel
+  end
+
+  options[:no_autorelations] = false
   opts.on("-N", "--no_autorelations", "Remove association values between nodes os same type") do
-    options[:no_autorelations] = TRUE
+    options[:no_autorelations] = true
   end
 
-end.parse!
+  options[:normalize_kernel] = false
+  opts.on("-z", "--normalize_kernel_values", "Apply cosine normalization to the obtained kernel") do
+    options[:normalize_kernel] = true
+  end
+
+  options[:graph_file] = nil
+  opts.on("-g", "--graph_file PATH", "Build a graphic representation of the network") do |item|
+    options[:graph_file] = item
+  end
+
+  options[:graph_options] = {method: 'el_grapho', layout: 'forcedir', steps: '30'}
+  opts.on("--graph_options STRING", "Set graph parameters as 'NAME1=value1,NAME2=value2,...") do |item|
+    options[:graph_options] = {}
+    item.split(',').each do |pair|
+      fields = pair.split('=')
+      options[:graph_options][fields.first.to_sym] = fields.last 
+    end
+  end
+
+  options[:threads] = 0
+  opts.on( '-T', '--threads INTEGER', 'Number of threads to use in computation, one thread will be reserved as manager.' ) do |opt|
+      options[:threads] = opt.to_i - 1
+  end
+
+  options[:reference_nodes] = []
+  opts.on("-r", "--reference_nodes STRING", "Node ids comma separared") do |item|
+    options[:reference_nodes] = item.split(',')
+  end
 
+  options[:group_nodes] = {}
+  opts.on("-G", "--group_nodes STRING", "File path or groups separated by ';' and group node ids comma separared") do |item|
+    if File.exists?(item)
+      File.open(item).each do |line|
+        groupID, nodeID = line.chomp.split("\t")
+        query = options[:group_nodes][groupID]
+        query.nil? ? options[:group_nodes][groupID] = [nodeID] : query << nodeID
+      end
+    else
+      item.split(';').each_with_index do |group, i| 
+        options[:group_nodes][i] = group.split(',')
+      end
+    end
+  end
+
+  options[:group_metrics] = false
+  opts.on("-M", "--group_metrics", "Perform group group_metrics") do 
+    options[:group_metrics] = true
+  end
+
+  options[:expand_clusters] = nil
+  opts.on("-x", "--expand_clusters STRING", "Method to expand clusters Available methods: sht_path") do |item|
+    options[:expand_clusters] = item
+  end
+
+  options[:get_attributes] = []
+  opts.on("-A", "--attributes STRING", "String separadted by commas with the name of network attribute") do |item|
+    options[:get_attributes] = item.split(',')
+  end
+
+  options[:delete_nodes] = []
+  opts.on("-d", "--delete PATH", "Remove nodes from file. If PATH;r then nodes not included in file are removed") do |item|
+    options[:delete_nodes] = item.split(';')
+  end
+end.parse!
 ##########################
 #MAIN
 ##########################
-
-fullNet = Network.new(options[:layers].map{|layer| layer.first})
-#puts options[:layers].map{|layer| layer.first}.inspect
 puts "Loading network data"
-fullNet.load_network_by_pairs(options[:input_file], options[:layers], options[:splitChar])
+fullNet = Net_parser.load(options)
+fullNet.reference_nodes = options[:reference_nodes]
+fullNet.threads = options[:threads]
+fullNet.group_nodes = options[:group_nodes]
+fullNet.set_compute_pairs(options[:use_pairs], !options[:no_autorelations])
+
+if !options[:delete_nodes].empty?
+  node_list = load_file(options[:delete_nodes].first).flatten
+  options[:delete_nodes].length > 1 ? mode = options[:delete_nodes][1] : 'd'
+  fullNet.delete_nodes(node_list, mode)
+end
 
-#fullNet.plot(options[:output_file], options[:output_style])
+options[:ontologies].each do |layer_name, ontology_file_path|
+  fullNet.link_ontology(ontology_file_path, layer_name.to_sym)
+end
+
+if !options[:get_attributes].empty?
+  node_attributes = fullNet.get_node_attributes(options[:get_attributes])
+  File.open(File.join(File.dirname(options[:output_file]), 'node_attributes.txt'), 'w' ) do |f|
+    node_attributes.each do |attributes|
+      f.puts(attributes.join("\t"))
+    end
+  end
+end
 
 if !options[:meth].nil?
 	puts "Performing association method #{options[:meth]} on network"
@@ -100,31 +220,54 @@ if !options[:meth].nil?
 			options[:use_layers][1].first, 
 			options[:meth])
 	end
-	puts 'Clean autorelations'  if options[:no_autorelations]
-	fullNet.clean_autorelations_on_association_values if options[:no_autorelations]
 	File.open(options[:assoc_file], 'w') do |f|
 		fullNet.association_values[options[:meth]].each do |val|
 			f.puts val.join("\t")
 		end
 	end
+  if !options[:control_file].nil?
+  	puts "Doing validation on association values obtained from method #{options[:meth]}"
+  	control = []
+  	File.open(options[:control_file]).each("\n") do |line|
+  		line.chomp!
+  		control << line.split("\t")
+  	end
+  	Performancer.load_control(control)
+    predictions = fullNet.association_values[options[:meth]]
+  	performance = Performancer.get_pred_rec(predictions)
+  	File.open(options[:performance_file], 'w') do |f|
+  		f.puts %w[cut prec rec meth].join("\t")
+  		performance.each do |item|
+  			item << options[:meth].to_s
+  			f.puts item.join("\t")
+  		end
+  	end
+  end
+  puts "End of analysis: #{options[:meth]}"
 end
 
-if !options[:meth].nil? && !options[:control_file].nil?
-	puts "Doing validation on association values obtained from method #{options[:meth]}"
-	control = []
-	File.open(options[:control_file]).each("\n") do |line|
-		line.chomp!
-		control << line.split("\t")
-	end
-	fullNet.load_control(control)
-	performance = fullNet.get_pred_rec(options[:meth])
-	File.open(options[:performance_file], 'w') do |f|
-		f.puts %w[cut prec rec meth].join("\t")
-		performance.each do |item|
-			item << options[:meth].to_s
-			f.puts item.join("\t")
-		end
-	end
+if !options[:kernel].nil?
+  layer2kernel = options[:use_layers].first # we use only a layer to perform the kernel, so only one item it is selected.
+  fullNet.get_kernel(layer2kernel, options[:kernel], options[:normalize_kernel])
+  fullNet.write_kernel(layer2kernel, options[:kernel_file])
+end
+
+if !options[:graph_file].nil?
+  options[:graph_options][:output_file] = options[:graph_file]
+  fullNet.plot_network(options[:graph_options]) 
 end
 
-puts "End of analysis: #{options[:meth]}"
+if options[:group_metrics]
+  fullNet.compute_group_metrics(File.join(File.dirname(options[:output_file]), 'group_metrics.txt'))
+end
+
+if !options[:expand_clusters].nil?
+  expanded_clusters = fullNet.expand_clusters(options[:expand_clusters])
+  File.open(File.join(File.dirname(options[:output_file]), 'expand_clusters.txt'), 'w' ) do |f|
+    expanded_clusters.each do |cl_id, nodes|
+      nodes.each do |node|
+        f.puts "#{cl_id}\t#{node}"
+      end
+    end
+  end
+end

data/bin/randomize_clustering.rb

@@ -0,0 +1,121 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+
+##############################
+#FUNCTIONS
+##############################
+
+
+def load_clusters(options)
+	clusters = {}
+	File.open(options[:input_file]).each do |line|
+		line = line.chomp.split(options[:column_sep])
+		cluster = line[options[:cluster_index]]
+		clusters[cluster] = [] if clusters[cluster].nil?
+		node = line[options[:node_index]]
+		node = node.split(options[:node_sep]) if !options[:node_sep].nil?
+		clusters[cluster] << node
+		clusters[cluster].flatten!
+	end
+	return clusters
+end
+
+
+def random_sample(nodes, replacement, all_sizes, seed)
+	random_clusters = {}
+	nodes_list = nodes.dup
+	all_sizes.each_with_index do |cluster_size, counter|
+		abort("Not enough nodes to generate clusters. Please activate replacement or change random mode") if cluster_size > nodes_list.size
+		random_nodes = nodes_list.uniq.sample(cluster_size, random: Random.new(seed))
+		if !replacement 
+			nodes_list = nodes_list - random_nodes
+		end
+		random_clusters["#{counter}_random"] = random_nodes
+		seed += 1
+	end
+	return random_clusters
+end
+
+def write_clusters(clusters, output_file, sep)
+	File.open(output_file, 'w') do |outfile|
+		clusters.each do |cluster, nodes|
+			nodes = [nodes.join(sep)] if !sep.nil?
+			nodes.each do |node|
+				outfile.puts [cluster, node].flatten.join("\t")
+			end
+		end		
+	end	
+end
+
+##############################
+#OPTPARSE
+##############################
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{__FILE__} [options]"
+
+  options[:input_file] = nil
+  opts.on("-i", "--input_file PATH", "Input file") do |input_file|
+    options[:input_file] = input_file
+  end
+
+  options[:node_index] = 1
+  opts.on("-N", "--node_column INTEGER", "Number of the nodes column. Default = #{options[:node_index]}") do |node_i|
+    options[:node_index] = node_i.to_i - 1
+  end
+
+  options[:cluster_index] = 0
+  opts.on("-C", "--cluster_column INTEGER", "Number of the clusters column. Default = #{options[:cluster_index]}" ) do |cluster_i|
+    options[:cluster_index] = cluster_i.to_i - 1
+  end
+
+  options[:column_sep] = "\t"
+  opts.on("-S", "--split_char CHARACTER", "Character for splitting input file. Default: tab") do |split_char|
+    options[:column_sep] = split_char
+  end
+
+  options[:node_sep] = nil
+  opts.on("-s", "--node_sep CHARACTER", "Node split character. This option must to be used when input file is aggregated.") do |split_char|
+    options[:node_sep] = split_char
+  end
+
+  options[:random_type] = ["size"]
+  opts.on("-r", "--random_type STRING", "Indicate random mode. 'size' for radomize clusters with the same size as input clusters. 'full_size' same as 'size' but all nodes are repaeted as same as input. 'fixed:n:s' for generate 'n' clusters of 's' nodes. Default = #{options[:output_file]}") do |random_type|
+    options[:random_type] = random_type.split(":")
+  end
+
+  options[:replacement] = false
+  opts.on("-R", "--replacement", "Boolean. Activates ramdom sampling with replacement. Sampling witout replacement will be executed instead.") do 
+    options[:replacement] = true
+  end
+
+  options[:output_file] = "./random_clusters.txt"
+  opts.on("-o", "--output_file FILEPATH", "Output file") do |output_file|
+    options[:output_file] = output_file
+  end
+
+  options[:aggregate_sep] = nil
+  opts.on("-a", "--aggregate_sep CHARACTER", "This option activates aggregation in output. Separator character must be provided") do |split_char|
+    options[:aggregate_sep] = split_char
+  end
+
+end.parse!
+##########################
+#MAIN
+##########################
+
+clusters = load_clusters(options)
+
+nodes = clusters.values.flatten
+nodes = nodes.uniq if !options[:random_type][0] == "full_size"
+
+if options[:random_type][0].include?("size") && options[:random_type].size == 1
+	all_sizes = clusters.map{|cluster, nodes| nodes.size}
+elsif options[:random_type][0] == "fixed" && options[:random_type].size == 3
+	all_sizes = Array.new(options[:random_type][1].to_i, options[:random_type][2].to_i)
+end
+
+random_clusters = random_sample(nodes, options[:replacement], all_sizes, 123)
+write_clusters(random_clusters, options[:output_file], options[:aggregate_sep])

data/bin/randomize_network.rb

@@ -0,0 +1,89 @@
+#! /usr/bin/env ruby
+
+ROOT_PATH = File.dirname(__FILE__)
+$LOAD_PATH.unshift(File.expand_path(File.join(ROOT_PATH, '..', 'lib')))
+require 'optparse'
+require 'benchmark'
+require 'NetAnalyzer'
+
+
+
+##############################
+#OPTPARSE
+##############################
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{__FILE__} [options]"
+
+  options[:input_file] = nil
+  opts.on("-i", "--input_file PATH", "Input file") do |input_file|
+    options[:input_file] = input_file
+  end
+
+  options[:node_file] = nil
+  opts.on("-n", "--node_names_file PATH", "File with node names corresponding to the input matrix, only use when -i is set to bin or matrix.") do |node_file|
+    options[:node_file] = node_file
+  end
+
+  options[:input_format] = 'pair'
+  opts.on("-f", "--input_format STRING", "Input file format: pair (default), bin, matrix") do |input_format|
+    options[:input_format] = input_format
+  end
+
+  options[:split_char] = "\t"
+  opts.on("-s", "--split_char CHARACTER", "Character for splitting input file. Default: tab") do |split_char|
+    options[:split_char] = split_char
+  end
+
+  options[:layers] = [:layer, '-']
+  opts.on("-l", "--layers STRING", "Layer definition on network: layer1name,regexp1;layer2name,regexp2...") do |layers|
+  	layers_definition = layers.split(";").map{|layer_attr| layer_attr.split(',')}
+	  layers_definition.map!{|layer_attr| [layer_attr.first.to_sym, /#{layer_attr.last}/]}
+    options[:layers] = layers_definition
+  end
+
+  options[:type_random] = nil
+  opts.on("-r", "--type_random network", "Randomized basis. 'nodes' Node-baseds randomize or 'links' Links-baseds randomize") do |type_random|
+    options[:type_random] = type_random
+  end
+
+  options[:output_file] = nil
+  opts.on("-o", "--output_file FILEPATH", "Output file") do |output_file|
+    options[:output_file] = output_file
+  end
+
+end.parse!
+
+
+##########################
+#MAIN
+##########################
+fullNet = Network.new(options[:layers].map{|layer| layer.first})
+puts "Loading network data"
+
+if options[:layers].length == 1
+  layerA = layerB = options[:layers][0].first
+elsif  options[:layers].length == 2
+  layerA = options[:layers][0].first
+  layerB = options[:layers][1].first
+end
+
+if options[:input_format] == 'pair'
+  fullNet.load_network_by_pairs(options[:input_file], options[:layers], options[:split_char])
+elsif options[:input_format] == 'bin' && !options[:node_file].nil?
+  fullNet.load_network_by_bin_matrix(options[:input_file], options[:node_file], options[:layers])
+elsif options[:input_format] == 'matrix' && !options[:node_file].nil?
+  fullNet.load_network_by_plain_matrix(options[:input_file], options[:node_file], options[:layers], options[:splitChar])
+else
+  raise("ERROR: The format #{options[:input_format]} is not defined")
+  exit
+end
+
+
+fullNet.randomize_network(options[:type_random])
+
+
+#fullNet.save_adjacency_matrix(layerA, layerB, options[:output_file])
+
+