").append(c.replace(bN,"")).find(g):c)),d&&i.each(d,[c,b,a])}});return this},serialize:function(){return f.param(this.serializeArray())},serializeArray:function(){return this.map(function(){return this.elements?f.makeArray(this.elements):this}).filter(function(){return this.name&&!this.disabled&&(this.checked||bO.test(this.nodeName)||bI.test(this.type))}).map(function(a,b){var c=f(this).val();return c==null?null:f.isArray(c)?f.map(c,function(a,c){return{name:b.name,value:a.replace(bF,"\r\n")}}):{name:b.name,value:c.replace(bF,"\r\n")}}).get()}}),f.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "),function(a,b){f.fn[b]=function(a){return this.on(b,a)}}),f.each(["get","post"],function(a,c){f[c]=function(a,d,e,g){f.isFunction(d)&&(g=g||e,e=d,d=b);return f.ajax({type:c,url:a,data:d,success:e,dataType:g})}}),f.extend({getScript:function(a,c){return f.get(a,b,c,"script")},getJSON:function(a,b,c){return f.get(a,b,c,"json")},ajaxSetup:function(a,b){b?b_(a,f.ajaxSettings):(b=a,a=f.ajaxSettings),b_(a,b);return a},ajaxSettings:{url:bV,isLocal:bJ.test(bW[1]),global:!0,type:"GET",contentType:"application/x-www-form-urlencoded",processData:!0,async:!0,accepts:{xml:"application/xml, text/xml",html:"text/html",text:"text/plain",json:"application/json, text/javascript","*":bX},contents:{xml:/xml/,html:/html/,json:/json/},responseFields:{xml:"responseXML",text:"responseText"},converters:{"* text":a.String,"text html":!0,"text json":f.parseJSON,"text xml":f.parseXML},flatOptions:{context:!0,url:!0}},ajaxPrefilter:bZ(bT),ajaxTransport:bZ(bU),ajax:function(a,c){function w(a,c,l,m){if(s!==2){s=2,q&&clearTimeout(q),p=b,n=m||"",v.readyState=a>0?4:0;var o,r,u,w=c,x=l?cb(d,v,l):b,y,z;if(a>=200&&a<300||a===304){if(d.ifModified){if(y=v.getResponseHeader("Last-Modified"))f.lastModified[k]=y;if(z=v.getResponseHeader("Etag"))f.etag[k]=z}if(a===304)w="notmodified",o=!0;else try{r=cc(d,x),w="success",o=!0}catch(A){w="parsererror",u=A}}else{u=w;if(!w||a)w="error",a<0&&(a=0)}v.status=a,v.statusText=""+(c||w),o?h.resolveWith(e,[r,w,v]):h.rejectWith(e,[v,w,u]),v.statusCode(j),j=b,t&&g.trigger("ajax"+(o?"Success":"Error"),[v,d,o?r:u]),i.fireWith(e,[v,w]),t&&(g.trigger("ajaxComplete",[v,d]),--f.active||f.event.trigger("ajaxStop"))}}typeof a=="object"&&(c=a,a=b),c=c||{};var d=f.ajaxSetup({},c),e=d.context||d,g=e!==d&&(e.nodeType||e instanceof f)?f(e):f.event,h=f.Deferred(),i=f.Callbacks("once memory"),j=d.statusCode||{},k,l={},m={},n,o,p,q,r,s=0,t,u,v={readyState:0,setRequestHeader:function(a,b){if(!s){var c=a.toLowerCase();a=m[c]=m[c]||a,l[a]=b}return this},getAllResponseHeaders:function(){return s===2?n:null},getResponseHeader:function(a){var c;if(s===2){if(!o){o={};while(c=bH.exec(n))o[c[1].toLowerCase()]=c[2]}c=o[a.toLowerCase()]}return c===b?null:c},overrideMimeType:function(a){s||(d.mimeType=a);return this},abort:function(a){a=a||"abort",p&&p.abort(a),w(0,a);return this}};h.promise(v),v.success=v.done,v.error=v.fail,v.complete=i.add,v.statusCode=function(a){if(a){var b;if(s<2)for(b in a)j[b]=[j[b],a[b]];else b=a[v.status],v.then(b,b)}return this},d.url=((a||d.url)+"").replace(bG,"").replace(bL,bW[1]+"//"),d.dataTypes=f.trim(d.dataType||"*").toLowerCase().split(bP),d.crossDomain==null&&(r=bR.exec(d.url.toLowerCase()),d.crossDomain=!(!r||r[1]==bW[1]&&r[2]==bW[2]&&(r[3]||(r[1]==="http:"?80:443))==(bW[3]||(bW[1]==="http:"?80:443)))),d.data&&d.processData&&typeof d.data!="string"&&(d.data=f.param(d.data,d.traditional)),b$(bT,d,c,v);if(s===2)return!1;t=d.global,d.type=d.type.toUpperCase(),d.hasContent=!bK.test(d.type),t&&f.active++===0&&f.event.trigger("ajaxStart");if(!d.hasContent){d.data&&(d.url+=(bM.test(d.url)?"&":"?")+d.data,delete d.data),k=d.url;if(d.cache===!1){var x=f.now(),y=d.url.replace(bQ,"$1_="+x);d.url=y+(y===d.url?(bM.test(d.url)?"&":"?")+"_="+x:"")}}(d.data&&d.hasContent&&d.contentType!==!1||c.contentType)&&v.setRequestHeader("Content-Type",d.contentType),d.ifModified&&(k=k||d.url,f.lastModified[k]&&v.setRequestHeader("If-Modified-Since",f.lastModified[k]),f.etag[k]&&v.setRequestHeader("If-None-Match",f.etag[k])),v.setRequestHeader("Accept",d.dataTypes[0]&&d.accepts[d.dataTypes[0]]?d.accepts[d.dataTypes[0]]+(d.dataTypes[0]!=="*"?", "+bX+"; q=0.01":""):d.accepts["*"]);for(u in d.headers)v.setRequestHeader(u,d.headers[u]);if(d.beforeSend&&(d.beforeSend.call(e,v,d)===!1||s===2)){v.abort();return!1}for(u in{success:1,error:1,complete:1})v[u](d[u]);p=b$(bU,d,c,v);if(!p)w(-1,"No Transport");else{v.readyState=1,t&&g.trigger("ajaxSend",[v,d]),d.async&&d.timeout>0&&(q=setTimeout(function(){v.abort("timeout")},d.timeout));try{s=1,p.send(l,w)}catch(z){if(s<2)w(-1,z);else throw z}}return v},param:function(a,c){var d=[],e=function(a,b){b=f.isFunction(b)?b():b,d[d.length]=encodeURIComponent(a)+"="+encodeURIComponent(b)};c===b&&(c=f.ajaxSettings.traditional);if(f.isArray(a)||a.jquery&&!f.isPlainObject(a))f.each(a,function(){e(this.name,this.value)});else for(var g in a)ca(g,a[g],c,e);return d.join("&").replace(bD,"+")}}),f.extend({active:0,lastModified:{},etag:{}});var cd=f.now(),ce=/(\=)\?(&|$)|\?\?/i;f.ajaxSetup({jsonp:"callback",jsonpCallback:function(){return f.expando+"_"+cd++}}),f.ajaxPrefilter("json jsonp",function(b,c,d){var e=b.contentType==="application/x-www-form-urlencoded"&&typeof b.data=="string";if(b.dataTypes[0]==="jsonp"||b.jsonp!==!1&&(ce.test(b.url)||e&&ce.test(b.data))){var g,h=b.jsonpCallback=f.isFunction(b.jsonpCallback)?b.jsonpCallback():b.jsonpCallback,i=a[h],j=b.url,k=b.data,l="$1"+h+"$2";b.jsonp!==!1&&(j=j.replace(ce,l),b.url===j&&(e&&(k=k.replace(ce,l)),b.data===k&&(j+=(/\?/.test(j)?"&":"?")+b.jsonp+"="+h))),b.url=j,b.data=k,a[h]=function(a){g=[a]},d.always(function(){a[h]=i,g&&f.isFunction(i)&&a[h](g[0])}),b.converters["script json"]=function(){g||f.error(h+" was not called");return g[0]},b.dataTypes[0]="json";return"script"}}),f.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/javascript|ecmascript/},converters:{"text script":function(a){f.globalEval(a);return a}}}),f.ajaxPrefilter("script",function(a){a.cache===b&&(a.cache=!1),a.crossDomain&&(a.type="GET",a.global=!1)}),f.ajaxTransport("script",function(a){if(a.crossDomain){var d,e=c.head||c.getElementsByTagName("head")[0]||c.documentElement;return{send:function(f,g){d=c.createElement("script"),d.async="async",a.scriptCharset&&(d.charset=a.scriptCharset),d.src=a.url,d.onload=d.onreadystatechange=function(a,c){if(c||!d.readyState||/loaded|complete/.test(d.readyState))d.onload=d.onreadystatechange=null,e&&d.parentNode&&e.removeChild(d),d=b,c||g(200,"success")},e.insertBefore(d,e.firstChild)},abort:function(){d&&d.onload(0,1)}}}});var cf=a.ActiveXObject?function(){for(var a in ch)ch[a](0,1)}:!1,cg=0,ch;f.ajaxSettings.xhr=a.ActiveXObject?function(){return!this.isLocal&&ci()||cj()}:ci,function(a){f.extend(f.support,{ajax:!!a,cors:!!a&&"withCredentials"in a})}(f.ajaxSettings.xhr()),f.support.ajax&&f.ajaxTransport(function(c){if(!c.crossDomain||f.support.cors){var d;return{send:function(e,g){var h=c.xhr(),i,j;c.username?h.open(c.type,c.url,c.async,c.username,c.password):h.open(c.type,c.url,c.async);if(c.xhrFields)for(j in c.xhrFields)h[j]=c.xhrFields[j];c.mimeType&&h.overrideMimeType&&h.overrideMimeType(c.mimeType),!c.crossDomain&&!e["X-Requested-With"]&&(e["X-Requested-With"]="XMLHttpRequest");try{for(j in e)h.setRequestHeader(j,e[j])}catch(k){}h.send(c.hasContent&&c.data||null),d=function(a,e){var j,k,l,m,n;try{if(d&&(e||h.readyState===4)){d=b,i&&(h.onreadystatechange=f.noop,cf&&delete ch[i]);if(e)h.readyState!==4&&h.abort();else{j=h.status,l=h.getAllResponseHeaders(),m={},n=h.responseXML,n&&n.documentElement&&(m.xml=n),m.text=h.responseText;try{k=h.statusText}catch(o){k=""}!j&&c.isLocal&&!c.crossDomain?j=m.text?200:404:j===1223&&(j=204)}}}catch(p){e||g(-1,p)}m&&g(j,k,m,l)},!c.async||h.readyState===4?d():(i=++cg,cf&&(ch||(ch={},f(a).unload(cf)),ch[i]=d),h.onreadystatechange=d)},abort:function(){d&&d(0,1)}}}});var ck={},cl,cm,cn=/^(?:toggle|show|hide)$/,co=/^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,cp,cq=[["height","marginTop","marginBottom","paddingTop","paddingBottom"],["width","marginLeft","marginRight","paddingLeft","paddingRight"],["opacity"]],cr;f.fn.extend({show:function(a,b,c){var d,e;if(a||a===0)return this.animate(cu("show",3),a,b,c);for(var g=0,h=this.length;g
=i.duration+this.startTime){this.now=this.end,this.pos=this.state=1,this.update(),i.animatedProperties[this.prop]=!0;for(b in i.animatedProperties)i.animatedProperties[b]!==!0&&(g=!1);if(g){i.overflow!=null&&!f.support.shrinkWrapBlocks&&f.each(["","X","Y"],function(a,b){h.style["overflow"+b]=i.overflow[a]}),i.hide&&f(h).hide();if(i.hide||i.show)for(b in i.animatedProperties)f.style(h,b,i.orig[b]),f.removeData(h,"fxshow"+b,!0),f.removeData(h,"toggle"+b,!0);d=i.complete,d&&(i.complete=!1,d.call(h))}return!1}i.duration==Infinity?this.now=e:(c=e-this.startTime,this.state=c/i.duration,this.pos=f.easing[i.animatedProperties[this.prop]](this.state,c,0,1,i.duration),this.now=this.start+(this.end-this.start)*this.pos),this.update();return!0}},f.extend(f.fx,{tick:function(){var a,b=f.timers,c=0;for(;c-1,k={},l={},m,n;j?(l=e.position(),m=l.top,n=l.left):(m=parseFloat(h)||0,n=parseFloat(i)||0),f.isFunction(b)&&(b=b.call(a,c,g)),b.top!=null&&(k.top=b.top-g.top+m),b.left!=null&&(k.left=b.left-g.left+n),"using"in b?b.using.call(a,k):e.css(k)}},f.fn.extend({position:function(){if(!this[0])return null;var a=this[0],b=this.offsetParent(),c=this.offset(),d=cx.test(b[0].nodeName)?{top:0,left:0}:b.offset();c.top-=parseFloat(f.css(a,"marginTop"))||0,c.left-=parseFloat(f.css(a,"marginLeft"))||0,d.top+=parseFloat(f.css(b[0],"borderTopWidth"))||0,d.left+=parseFloat(f.css(b[0],"borderLeftWidth"))||0;return{top:c.top-d.top,left:c.left-d.left}},offsetParent:function(){return this.map(function(){var a=this.offsetParent||c.body;while(a&&!cx.test(a.nodeName)&&f.css(a,"position")==="static")a=a.offsetParent;return a})}}),f.each(["Left","Top"],function(a,c){var d="scroll"+c;f.fn[d]=function(c){var e,g;if(c===b){e=this[0];if(!e)return null;g=cy(e);return g?"pageXOffset"in g?g[a?"pageYOffset":"pageXOffset"]:f.support.boxModel&&g.document.documentElement[d]||g.document.body[d]:e[d]}return this.each(function(){g=cy(this),g?g.scrollTo(a?f(g).scrollLeft():c,a?c:f(g).scrollTop()):this[d]=c})}}),f.each(["Height","Width"],function(a,c){var d=c.toLowerCase();f.fn["inner"+c]=function(){var a=this[0];return a?a.style?parseFloat(f.css(a,d,"padding")):this[d]():null},f.fn["outer"+c]=function(a){var b=this[0];return b?b.style?parseFloat(f.css(b,d,a?"margin":"border")):this[d]():null},f.fn[d]=function(a){var e=this[0];if(!e)return a==null?null:this;if(f.isFunction(a))return this.each(function(b){var c=f(this);c[d](a.call(this,b,c[d]()))});if(f.isWindow(e)){var g=e.document.documentElement["client"+c],h=e.document.body;return e.document.compatMode==="CSS1Compat"&&g||h&&h["client"+c]||g}if(e.nodeType===9)return Math.max(e.documentElement["client"+c],e.body["scroll"+c],e.documentElement["scroll"+c],e.body["offset"+c],e.documentElement["offset"+c]);if(a===b){var i=f.css(e,d),j=parseFloat(i);return f.isNumeric(j)?j:i}return this.css(d,typeof a=="string"?a:a+"px")}}),a.jQuery=a.$=f,typeof define=="function"&&define.amd&&define.amd.jQuery&&define("jquery",[],function(){return f})})(window);
\ No newline at end of file
diff --git a/lib/networkx.rb b/lib/networkx.rb
deleted file mode 100644
index 142f31d..0000000
--- a/lib/networkx.rb
+++ /dev/null
@@ -1,43 +0,0 @@
-require 'set'
-require 'matrix'
-require 'rb_heap'
-require 'securerandom'
-require_relative 'networkx/version'
-require_relative 'networkx/graph'
-require_relative 'networkx/digraph'
-require_relative 'networkx/multigraph'
-require_relative 'networkx/multidigraph'
-require_relative 'networkx/traversals/bfs'
-require_relative 'networkx/traversals/dfs'
-require_relative 'networkx/traversals/edge_dfs'
-require_relative 'networkx/shortest_path/unweighted'
-require_relative 'networkx/to_matrix'
-require_relative 'networkx/shortest_path/dense'
-require_relative 'networkx/shortest_path/weighted'
-require_relative 'networkx/shortest_path/astar'
-require_relative 'networkx/operators/product'
-require_relative 'networkx/operators/binary'
-require_relative 'networkx/operators/unary'
-require_relative 'networkx/operators/all'
-require_relative 'networkx/flow/utils'
-require_relative 'networkx/flow/edmondskarp'
-require_relative 'networkx/flow/shortestaugmentingpath'
-require_relative 'networkx/flow/capacityscaling'
-require_relative 'networkx/flow/preflowpush'
-require_relative 'networkx/auxillary_functions/cliques'
-require_relative 'networkx/auxillary_functions/dag'
-require_relative 'networkx/auxillary_functions/eccentricity'
-require_relative 'networkx/auxillary_functions/mis'
-require_relative 'networkx/auxillary_functions/mst'
-require_relative 'networkx/auxillary_functions/union_find'
-require_relative 'networkx/auxillary_functions/vitality'
-require_relative 'networkx/auxillary_functions/wiener'
-require_relative 'networkx/auxillary_functions/cycles'
-require_relative 'networkx/link_analysis/hits'
-require_relative 'networkx/link_analysis/pagerank'
-require_relative 'networkx/others/bridges'
-require_relative 'networkx/others/generators'
-require_relative 'networkx/others/grid_2d_graph'
-require_relative 'networkx/others/info'
-require_relative 'networkx/others/number_connected_components'
-require_relative 'networkx/others/reads'
diff --git a/lib/networkx/auxillary_functions/cliques.rb b/lib/networkx/auxillary_functions/cliques.rb
deleted file mode 100644
index 3c60448..0000000
--- a/lib/networkx/auxillary_functions/cliques.rb
+++ /dev/null
@@ -1,62 +0,0 @@
-module NetworkX
- # Returns all cliques in the graph
- #
- # @param graph [Graph, MultiGraph] a graph
- #
- # @return [Array>] Arrays of nodes in the cliques
- def self.find_cliques(graph)
- return nil if graph.nodes(data: true).empty?
-
- q = [nil]
- adj = {}
- graph.nodes(data: true).each_key { |u| adj[u] = [] }
- graph.adj.each { |u, u_edges| u_edges.each_key { |v| adj[u] << v if u != v } }
-
- subg = graph.nodes(data: true).keys
- cand = graph.nodes(data: true).keys
- u = subg.max { |n1, n2| (cand & adj[n1]).length <=> (cand & adj[n2]).length }
- ext_u = cand - adj[u]
- stack = []
- cliques = []
- begin
- loop do
- if ext_u.empty?
- q.pop
- subg, cand, ext_u = stack.pop
- else
- q_elem = ext_u.pop
- cand.delete(q_elem)
- q[-1] = q_elem
- adj_q = adj[q_elem]
- subg_q = subg & adj_q
- if subg_q.empty?
- cliques << q[0..(q.length - 1)]
- else
- cand_q = cand & adj_q
- unless cand_q.empty?
- stack << [subg, cand, ext_u]
- q << nil
- subg = subg_q
- cand = cand_q
- u = subg.max { |n1, n2| (cand & adj[n1]).length <=> (cand & adj[n2]).length }
- ext_u = cand - adj[u]
- end
- end
- end
- end
- rescue NoMethodError
- cliques
- end
- end
-
- # Returns the number of cliques in a graph containing a node
- #
- # @param graph [Graph, MultiGraph] a graph
- # @param node [Object] a node
- #
- # @return [Numeric] Number of cliques containing the given node
- def self.number_of_cliques(graph, node)
- cliques = find_cliques(graph)
- cliques.count { |c| c.include?(node) }
- end
-end
diff --git a/lib/networkx/auxillary_functions/cycles.rb b/lib/networkx/auxillary_functions/cycles.rb
deleted file mode 100644
index f378682..0000000
--- a/lib/networkx/auxillary_functions/cycles.rb
+++ /dev/null
@@ -1,114 +0,0 @@
-module NetworkX
- # Returns all basis cycles in graph
- #
- # @param graph [Graph] a graph
- # @param root [Object, Nil] root for the graph cycles
- #
- # @return [Array>] Arrays of nodes in the cycles
- def self.cycle_basis(graph, root = nil)
- gnodes = graph.nodes(data: true).keys
- cycles = []
- until gnodes.empty?
- root = gnodes.shift if root.nil?
- stack = [root]
- pred = {root => root}
- used = {root => []}
- until stack.empty?
- z = stack.shift
- zused = used[z]
- graph.adj[z].each_key do |u|
- if !used.has_key?(u)
- pred[u] = z
- stack << u
- used[u] = [z]
- elsif u == z
- cycles << [z]
- elsif !zused.include?(u)
- pn = used[u]
- cycle = [u, z]
- p = pred[z]
- until pn.include?(p)
- cycle << p
- p = pred[p]
- end
- cycle << p
- cycles << cycle
- used[u] << z
- used[u] = used[u].uniq
- end
- end
- end
- gnodes -= pred.keys
- root = nil
- end
- cycles
- end
-
- # Returns the cycle containing the given node
- #
- # @param graph [Graph, DiGraph] a graph
- # @param node [Object] node to be included in the cycle
- #
- # @return [Array>] Arrays of nodes in the cycle
- def self.find_cycle(graph, node)
- explored = Set.new
- cycle = []
- final_node = nil
- unless explored.include?(node)
- edges = []
- seen = [node]
- active_nodes = [node]
- previous_head = nil
-
- edge_dfs(graph, node).each do |edge|
- tail, head = edge
- next if explored.include?(head)
-
- if !previous_head.nil? && tail != previous_head
- loop do
- popped_edge = edges.pop
- if popped_edge.nil?
- edges = []
- active_nodes = [tail]
- break
- else
- popped_head = popped_edge[1]
- active_nodes.delete(popped_head)
- end
-
- unless edges.empty?
- last_head = edges[-1][1]
- break if tail == last_head
- end
- end
- end
- edges << edge
-
- if active_nodes.include?(head)
- cycle += edges
- final_node = head
- break
- else
- seen << head
- active_nodes << head
- previous_head = head
- end
- end
- cycle.each_with_index { |edge, i| return cycle[i..(cycle.length - 1)] if final_node == edge[0] }
- end
- raise ArgumentError, 'No cycle found!' if cycle.empty?
- end
-
- # Returns whether the given undirected cycle has cycle.
- #
- # @param undirected_graph [Graph] an undirected graph
- #
- # @return [book] true if the given graph has cycle. otherwise, false.
- def self.cycle?(undirected_graph)
- uf = NetworkX::UnionFind.new
- undirected_graph.edges.each do |x, y|
- uf[x] == uf[y] ? (return [x, y]) : uf.unite(x, y)
- end
- false
- end
-end
diff --git a/lib/networkx/auxillary_functions/dag.rb b/lib/networkx/auxillary_functions/dag.rb
deleted file mode 100644
index e3d4b87..0000000
--- a/lib/networkx/auxillary_functions/dag.rb
+++ /dev/null
@@ -1,59 +0,0 @@
-module NetworkX
- # Returns the descendants of a given node
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param source [Object] node to find descendents of
- #
- # @return [Array] Array of the descendants
- def self.descendants(graph, source)
- raise ArgumentError, 'Source is not present in the graph!' unless graph.node?(source)
-
- des = single_source_shortest_path_length(graph, source).map { |u, _| u }.uniq
- des - [source]
- end
-
- # Returns the ancestors of a given node
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param source [Object] node to find ancestors of
- #
- # @return [Array] Array of the ancestors
- def self.ancestors(graph, source)
- raise ArgumentError, 'Source is not present in the graph!' unless graph.node?(source)
-
- anc = single_source_shortest_path_length(graph.reverse, source).map { |u, _| u }.uniq
- anc - [source]
- end
-
- # Returns the nodes arranged in the topologically sorted fashion
- #
- # @param graph [DiGraph] a graph
- #
- # @return [Array] Array of the nodes
- def self.topological_sort(graph)
- raise ArgumentError, 'Topological Sort not defined on undirected graphs!' unless graph.directed?
-
- nodes = []
- indegree_map = graph.nodes(data: true).each_key.map do |u|
- [u, graph.in_degree(u)] if graph.in_degree(u).positive?
- end.compact.to_h
- zero_indegree = graph.nodes(data: true).each_key.select { |u| graph.in_degree(u).zero? }
-
- until zero_indegree.empty?
- node = zero_indegree.shift
- raise ArgumentError, 'Graph changed during iteration!' unless graph.nodes(data: true).has_key?(node)
-
- graph.adj[node].each_key do |child|
- indegree_map[child] -= 1
- if indegree_map[child].zero?
- zero_indegree << child
- indegree_map.delete(child)
- end
- end
- nodes << node
- end
- raise ArgumentError, 'Graph contains cycle or graph changed during iteration!' unless indegree_map.empty?
-
- nodes
- end
-end
diff --git a/lib/networkx/auxillary_functions/eccentricity.rb b/lib/networkx/auxillary_functions/eccentricity.rb
deleted file mode 100644
index e78b190..0000000
--- a/lib/networkx/auxillary_functions/eccentricity.rb
+++ /dev/null
@@ -1,37 +0,0 @@
-module NetworkX
- # Returns the eccentricity of a particular node or all nodes
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param node [Object] node to find the eccentricity of
- #
- # @return [Array, Numeric] eccentricity/eccentricites of all nodes
- def self.eccentricity(graph, node = nil)
- e = {}
- graph.nodes(data: true).each do |u, _|
- length = single_source_shortest_path_length(graph, u)
- l = length.length
- raise ArgumentError, 'Found infinite path length!' unless l == graph.nodes(data: true).length
-
- e[u] = length.max_by { |a| a[1] }[1]
- end
- node.nil? ? e : e[node]
- end
-
- # Returns the diameter of a graph
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- #
- # @return [Numeric] diameter of the graph
- def self.diameter(graph)
- eccentricity(graph).values.max
- end
-
- # Returns the radius of a graph
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- #
- # @return [Numeric] radius of the graph
- def self.radius(graph)
- eccentricity(graph).values.min
- end
-end
diff --git a/lib/networkx/auxillary_functions/mis.rb b/lib/networkx/auxillary_functions/mis.rb
deleted file mode 100644
index 11b8e4d..0000000
--- a/lib/networkx/auxillary_functions/mis.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-module NetworkX
- # Returns the maximal independent set of a graph
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param nodes [Object] nodes to be considered in the MIS
- #
- # @return [Numeric] radius of the graph
- def self.maximal_independent_set(graph, nodes)
- if (graph.nodes(data: true).keys - nodes).empty?
- raise 'The array containing the nodes should be a subset of the graph!'
- end
-
- neighbours = []
- nodes.each { |u| graph.adj[u].each { |v, _| neighbours |= [v] } }
- raise 'Nodes is not an independent set of graph!' if (neighbours - nodes).empty?
-
- available_nodes = graph.nodes(data: true).keys - (neighbours | nodes)
- until available_nodes.empty?
- node = available_nodes.sample
- nodes << node
- available_nodes -= (graph.adj[node].keys + [node])
- end
- nodes
- end
-end
diff --git a/lib/networkx/auxillary_functions/mst.rb b/lib/networkx/auxillary_functions/mst.rb
deleted file mode 100644
index ad0a11f..0000000
--- a/lib/networkx/auxillary_functions/mst.rb
+++ /dev/null
@@ -1,33 +0,0 @@
-module NetworkX
- # Helper function for the minimum spanning tree
- #
- def self.get_edges_weights(graph)
- edges = []
- graph.adj.each do |u, u_edges|
- u_edges.each do |v, uv_attrs|
- edges << [[u, v], uv_attrs[:weight] || Float::INFINITY]
- end
- end
- edges
- end
-
- # Returns the minimum spanning tree of a graph
- #
- # @param graph [Graph, DiGraph] a graph
- #
- # @return [DiGraph, Graph] a minimum spanning tree of the graph
- def self.minimum_spanning_tree(graph)
- mst = Marshal.load(Marshal.dump(graph))
- mst.clear
- edges = get_edges_weights(graph).sort_by { |a| a[1] }
- union_find = UnionFind.new(graph.nodes(data: true).keys)
- while edges.any? && mst.nodes(data: true).length <= graph.nodes(data: true).length
- edge = edges.shift
- unless union_find.connected?(edge[0][0], edge[0][1])
- union_find.union(edge[0][0], edge[0][1])
- mst.add_edge(edge[0][0], edge[0][1], **graph.adj[edge[0][0]][edge[0][1]])
- end
- end
- mst
- end
-end
diff --git a/lib/networkx/auxillary_functions/union_find.rb b/lib/networkx/auxillary_functions/union_find.rb
deleted file mode 100644
index db8e761..0000000
--- a/lib/networkx/auxillary_functions/union_find.rb
+++ /dev/null
@@ -1,104 +0,0 @@
-module NetworkX
- # Union Find Tree
- #
- # Reference
- # - [ac-library-rb DSU (CC0)](https://github.com/universato/ac-library-rb/blob/main/lib/dsu.rb)
- # - [Python NetworkX UnionFind](https://networkx.org/documentation/stable/_modules/networkx/utils/union_find.html)
- #
- #
- # @attr_reader parents [Hash{ Object => Object }] Return parent of each element
- # @attr_reader weights [Hash{ Object => Integer }] Return weight of each element
- class UnionFind
- attr_accessor :parents, :weights
-
- # Constructor for initializing Union Find Tree
- #
- # @param nodes [?Array[Object]] nodes
- #
- # @return [UnionFind] Union Find Tree
- def initialize(nodes = nil)
- @weights = {}
- @parents = {}
- nodes&.each do |node|
- @weights[node] = 1
- @parents[node] = node
- end
- end
-
- # Return the root of node
- #
- # @param node [Object] node
- #
- # @return [Object] root of node, leader of node
- def [](node)
- if @parents.has_key?(node)
- @parents[node] == node ? node : (@parents[node] = self[@parents[node]])
- else
- @weights[node] = 1
- @parents[node] = node
- end
- end
-
- # Return the root of node
- #
- # @param node [Object] node
- #
- # @return [Object] root of node, leader of node
- def root(node)
- @parents.has_key?(node) or raise ArgumentError.new, "#{node} is not a node"
-
- @parents[node] == node ? node : (@parents[node] = root(@parents[node]))
- end
-
- def each(&block)
- @parents.each_key(&block)
- end
-
- def to_sets
- each.group_by { |node| root(node) }.values
- end
- alias groups to_sets
-
- # Is each root of two nodes the same?
- #
- # @param node1 [Object] node
- # @param node2 [Object] node
- #
- # @return [bool] Is each root of node1 and nodes_2 the same?
- def connected?(node1, node2)
- root(node1) == root(node2)
- end
- alias same? connected?
-
- # Unite nodes.
- #
- # @param nodes [Array[Object]] nodes
- #
- # @return [Object | nil] root of united nodes
- def union(*nodes)
- return merge(*nodes) if nodes.size == 2
-
- roots = nodes.map { |node| self[node] }.uniq
- return if roots.size == 1
-
- roots.sort_by! { |root| @weights[root] }
- root = roots[-1]
- roots[0...-1].each do |r|
- @weights[root] += @weights[r]
- @parents[r] = root
- end
- root
- end
- alias unite union
-
- def merge(node1, node2)
- x = self[node1]
- y = self[node2]
- return if x == y
-
- x, y = y, x if @weights[x] < @weights[y]
- @weights[x] += @weights[y]
- @parents[y] = x
- end
- end
-end
diff --git a/lib/networkx/auxillary_functions/vitality.rb b/lib/networkx/auxillary_functions/vitality.rb
deleted file mode 100644
index fcde5fa..0000000
--- a/lib/networkx/auxillary_functions/vitality.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-module NetworkX
- # Returns the closeness vitality of a node
- #
- # @param graph [Graph, DiGraph] a graph
- # @param node [Object] node to compute closeness vitality of
- #
- # @return [Numeric] closeness vitality of the given node
- def self.closeness_vitality(graph, node)
- before = wiener_index(graph)
- after = wiener_index(graph.subgraph(graph.nodes(data: true).keys - [node]))
- before - after
- end
-end
diff --git a/lib/networkx/auxillary_functions/wiener.rb b/lib/networkx/auxillary_functions/wiener.rb
deleted file mode 100644
index 9cedeb6..0000000
--- a/lib/networkx/auxillary_functions/wiener.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-module NetworkX
- # Returns the wiener index of the graph
- #
- # @param graph [Graph, DiGraph] a graph
- #
- # @return [Numeric] wiener index of the graph
- def self.wiener_index(graph)
- total = all_pairs_shortest_path_length(graph)
- wiener_ind = 0
- total.to_h.each { |_, distances| distances.to_h.each { |_, val| wiener_ind += val } }
- graph.directed? ? wiener_ind : wiener_ind / 2
- end
-end
diff --git a/lib/networkx/converters/to_csv.rb b/lib/networkx/converters/to_csv.rb
deleted file mode 100644
index 9a511af..0000000
--- a/lib/networkx/converters/to_csv.rb
+++ /dev/null
@@ -1,45 +0,0 @@
-module NetworkX
- # Saves the graph in a csv file
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param filename [String] filename of the graph
- def self.graph_to_csv(graph, filename = 'graph.csv')
- CSV.open(filename, 'wb') do |csv|
- csv << [graph.class.name]
- csv << ['graph_values']
- csv << graph.graph.keys
- csv << graph.graph.values
- csv << ['graph_nodes']
- graph.nodes(data: true).each do |u, attrs|
- node_attrs = [u]
- attrs.each do |k, v|
- node_attrs << k
- node_attrs << v
- end
- csv << node_attrs
- end
- csv << ['graph_edges']
- graph.adj.each do |u, u_edges|
- u_edges.each do |v, uv_attrs|
- if graph.multigraph?
- uv_attrs.each do |key, attrs|
- node_attrs = [u, v, key]
- attrs.each do |k, k_attrs|
- node_attrs << k
- node_attrs << k_attrs
- end
- csv << node_attrs
- end
- else
- node_attrs = [u, v]
- uv_attrs.each do |k, vals|
- node_attrs << k
- node_attrs << vals
- end
- csv << node_attrs
- end
- end
- end
- end
- end
-end
diff --git a/lib/networkx/converters/to_json.rb b/lib/networkx/converters/to_json.rb
deleted file mode 100644
index 79d78c2..0000000
--- a/lib/networkx/converters/to_json.rb
+++ /dev/null
@@ -1,37 +0,0 @@
-module NetworkX
- # Returns a JSON object of the given graph
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- #
- # @return [JSON] json encoded graph
- def self.graph_to_json(graph)
- json_hash = {}
- json_hash[:class] = graph.class.name
- json_hash[:graph] = graph.graph
- json_hash[:nodes] = graph.nodes
- json_hash[:adj] = graph.adj
- json_hash.to_json
- end
-
- # Returns a graph from the json encoded graph
- #
- # @param json_str [JSON] json encoded string
- #
- # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] a decoded graph
- def self.json_to_graph(json_str)
- graph_hash = JSON.parse(json_str)
- case json_str['class']
- when 'NetworkX::Graph'
- graph = NetworkX::Graph.new(graph_hash.graph)
- when 'NetworkX::MultiGraph'
- graph = NetworkX::MultiGraph.new(graph_hash.graph)
- when 'NetworkX::DiGraph'
- graph = NetworkX::DiGraph.new(graph_hash.graph)
- when 'NetworkX::MultiDiGraph'
- graph = NetworkX::MultiDiGraph.new(graph_hash.graph)
- end
- graph.adj = graph_hash['adj']
- graph.nodes = graph_hash['nodes']
- graph
- end
-end
diff --git a/lib/networkx/digraph.rb b/lib/networkx/digraph.rb
deleted file mode 100644
index 42e55a1..0000000
--- a/lib/networkx/digraph.rb
+++ /dev/null
@@ -1,234 +0,0 @@
-module NetworkX
- # Describes the class for making Directed Graphs
- #
- # @attr_reader adj [Hash{ Object => Hash{ Object => Hash{ Object => Object } } }]
- # Stores the edges and their attributes in an adjencency list form
- # @attr_reader pred [Hash{ Object => Hash{ Object => Hash{ Object => Object } } }]
- # Stores the reverse edges and their attributes in an adjencency list form
- # @attr_reader nodes [Hash{ Object => Hash{ Object => Object } }] Stores the nodes and their attributes
- # @attr_reader graph [Hash{ Object => Object }] Stores the attributes of the graph
- class DiGraph < Graph
- attr_reader :adj, :graph, :pred
-
- # Constructor for initializing graph
- #
- # @example Initialize a graph with attributes 'type' and 'name'
- # graph = NetworkX::Graph.new(name: "Social Network", type: "undirected")
- #
- # @param graph_attrs [Hash{ Object => Object }] the graph attributes in a hash format
- def initialize(**graph_attrs)
- super(**graph_attrs)
-
- @pred = {}
- end
-
- # Adds the respective edge
- #
- # @example Add an edge with attribute name
- # graph.add_edge(node1, node2, name: "Edge1")
- #
- # @example Add an edge with no attribute
- # graph.add_edge("Bangalore", "Chennai")
- #
- # @param node1 [Object] the first node of the edge
- # @param node2 [Object] the second node of the edge
- # @param edge_attrs [Hash{ Object => Object }] the hash of the edge attributes
- def add_edge(node1, node2, **edge_attrs)
- add_node(node1)
- add_node(node2)
-
- edge_attrs = (@adj[node1][node2] || {}).merge(edge_attrs)
- @adj[node1][node2] = edge_attrs
- @pred[node2][node1] = edge_attrs
- end
-
- # Adds a node and its attributes to the graph
- #
- # @example Add a node with attribute 'type'
- # graph.add_node("Noida", type: "city")
- #
- # @param node [Object] the node object
- # @param node_attrs [Hash{ Object => Object }] the hash of the attributes of the node
- def add_node(node, **node_attrs)
- super(node, **node_attrs)
-
- @pred[node] = {} unless @pred.has_key?(node)
- end
-
- def nodes(data: true)
- data ? @nodes : @nodes.keys
- end
-
- # Removes node from the graph
- #
- # @example
- # graph.remove_node("Noida")
- #
- # @param node [Object] the node to be removed
- def remove_node(node)
- raise KeyError, "Error in deleting node #{node} from Graph." unless @nodes.has_key?(node)
-
- neighbours = @adj[node]
- neighbours.each_key { |k| @pred[k].delete(node) }
- @pred[node].each_key do |k|
- @adj[k].delete(node)
- end
-
- @pred.delete(node)
- @adj.delete(node)
- @nodes.delete(node)
- end
-
- # Removes edge from the graph
- #
- # @example
- # graph.remove_edge('Noida', 'Bangalore')
- #
- # @param node1 [Object] the first node of the edge
- # @param node2 [Object] the second node of the edge
- def remove_edge(node1, node2)
- raise KeyError, "#{node1} is not a valid node." unless @nodes.has_key?(node1)
- raise KeyError, "#{node2} is not a valid node" unless @nodes.has_key?(node2)
- raise KeyError, 'The given edge is not a valid one.' unless @adj[node1].has_key?(node2)
-
- @adj[node1].delete(node2)
- @pred[node2].delete(node1)
- end
-
- # Clears the graph
- #
- # @example
- # graph.clear
- def clear
- super
-
- @pred.clear
- end
-
- # Returns number of edges
- #
- # @example
- # graph.number_of_edges
- def number_of_edges
- @adj.values.map(&:length).sum
- end
-
- # Returns the size of graph
- #
- # @example
- # graph.size(true)
- #
- # @param is_weighted [Bool] if true, method returns sum of weights of all edges
- # else returns number of edges
- def size(is_weighted = false)
- if is_weighted
- graph_size = 0
- @adj.each do |_, hash_val|
- hash_val.each { |_, v| graph_size += v[:weight] if v.has_key?(:weight) }
- end
- return graph_size
- end
- number_of_edges
- end
-
- # Returns in-degree of a given node
- #
- # @example
- # graph.in_degree(node)
- #
- # @param node [Object] the node whose in degree is to be calculated
- def in_degree(node)
- @pred[node].length
- end
-
- # Returns out-degree of a given node
- #
- # @example
- # graph.out_degree(node)
- #
- # @param node [Object] the node whose out degree is to be calculated
- def out_degree(node)
- @adj[node].length
- end
-
- # Returns the reversed version of the graph
- #
- # @example
- # graph.reverse
- def reverse
- new_graph = NetworkX::DiGraph.new(**@graph)
- @nodes.each { |u, attrs| new_graph.add_node(u, **attrs) }
- @adj.each do |u, edges|
- edges.each { |v, attrs| new_graph.add_edge(v, u, **attrs) }
- end
- new_graph
- end
-
- # Returns the undirected version of the graph
- #
- # @example
- # graph.to_undirected
- def to_undirected
- new_graph = NetworkX::Graph.new(**@graph)
- @nodes.each { |u, attrs| new_graph.add_node(u, **attrs) }
- @adj.each do |u, edges|
- edges.each { |v, attrs| new_graph.add_edge(u, v, **attrs) }
- end
- new_graph
- end
-
- # Returns subgraph consisting of given array of nodes
- #
- # @example
- # graph.subgraph(%w[Mumbai Nagpur])
- #
- # @param nodes [Array] the nodes to be included in the subgraph
- def subgraph(nodes)
- case nodes
- when Array, Set
- sub_graph = NetworkX::DiGraph.new(**@graph)
- nodes.each do |u|
- raise KeyError, "#{u} does not exist in the current graph!" unless node?(u)
-
- sub_graph.add_node(u, **@nodes[u])
- @adj[u].each do |v, uv_attrs|
- sub_graph.add_edge(u, v, **uv_attrs) if @adj[u].has_key?(v) && nodes.include?(v)
- end
- end
- sub_graph
- else
- raise ArgumentError, 'Expected Argument to be Array or Set of nodes, ' \
- "received #{nodes.class.name} instead."
- end
- end
-
- # Returns subgraph consisting of given edges
- #
- # @example
- # graph.edge_subgraph([%w[Nagpur Wardha], %w[Nagpur Mumbai]])
- #
- # @param edges [Array] the edges to be included in the subraph
- def edge_subgraph(edges)
- case edges
- when Array, Set
- sub_graph = NetworkX::DiGraph.new(**@graph)
- edges.each do |u, v|
- raise KeyError, "Edge between #{u} and #{v} does not exist in the graph!" unless @nodes.has_key?(u) \
- && @adj[u].has_key?(v)
-
- sub_graph.add_node(u, **@nodes[u])
- sub_graph.add_node(v, **@nodes[v])
- sub_graph.add_edge(u, v, **@adj[u][v])
- end
- sub_graph
- else
- raise ArgumentError, 'Expected Argument to be Array or Set of edges, ' \
- "received #{edges.class.name} instead."
- end
- end
-
- def directed?
- true
- end
- end
-end
diff --git a/lib/networkx/flow/capacityscaling.rb b/lib/networkx/flow/capacityscaling.rb
deleted file mode 100644
index c9ab5ea..0000000
--- a/lib/networkx/flow/capacityscaling.rb
+++ /dev/null
@@ -1,251 +0,0 @@
-module NetworkX
- # Returns a label for unique node
- def self.generate_unique_node
- SecureRandom.uuid
- end
-
- # Finds if there is a negative edge cycle in the graph
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- #
- # @return [Boolean] whether there exists a negative cycle in graph
- def self.negative_edge_cycle(graph)
- newnode = generate_unique_node
- graph.add_edges(graph.nodes(data: true).keys.map { |n| [newnode, n] })
- begin
- bellmanford_predecesor_distance(graph, newnode)
- rescue ArgumentError
- return true
- ensure
- graph.remove_node(newnode)
- end
- false
- end
-
- # Detects the unboundedness in the residual graph
- def self._detect_unboundedness(residual)
- g = NetworkX::DiGraph.new
- g.add_nodes(residual.nodes(data: true).keys.zip(residual.nodes(data: true).values))
- inf = residual.graph[:inf]
-
- residual.nodes(data: true).each do |u, _attr|
- residual.adj[u].each do |v, uv_attrs|
- w = inf
- uv_attrs.each { |_key, edge_attrs| w = [w, edge_attrs[:weight]].min if edge_attrs[:capacity] == inf }
- g.add_edge(u, v, weight: w) unless w == inf
- end
- end
- raise ArgumentError, 'Negative cost cycle of infinite capacity found!' if negative_edge_cycle(g)
- end
-
- # Returns the residual graph of the given graph
- def self._build_residual_network(graph)
- raise ArgumentError, 'Sum of demands should be 0!' \
- unless graph.nodes(data: true).values.map { |attr| attr[:demand] || 0 }.sum.zero?
-
- residual = NetworkX::MultiDiGraph.new(inf: 0)
- residual.add_nodes(graph.nodes(data: true).map { |u, attr| [u, {excess: (attr[:demand] || 0) * -1, potential: 0}] })
- inf = Float::INFINITY
- edge_list = []
-
- # TODO: Selfloop edges check
-
- if graph.multigraph?
- graph.adj.each do |u, u_edges|
- u_edges.each do |v, uv_edges|
- uv_edges.each do |k, attrs|
- edge_list << [u, v, k, e] if u != v && (attrs[:capacity] || inf).positive?
- end
- end
- end
- else
- graph.adj.each do |u, u_edges|
- u_edges.each do |v, attrs|
- edge_list << [u, v, 0, attrs] if u != v && (attrs[:capacity] || inf).positive?
- end
- end
- end
-
- temp_inf = [
- residual.nodes(data: true).map { |_u, attrs| attrs[:excess].abs }.sum,
- edge_list.map {|_, _, _, e| (e.has_key?(:capacity) && e[:capacity] != inf ? e[:capacity] : 0) }.sum * 2
- ].max
-
- inf = temp_inf.zero? ? 1 : temp_inf
-
- edge_list.each do |u, v, k, e|
- r = [e[:capacity] || inf, inf].min
- w = e[:weight] || 0
- residual.add_edge(u, v, temp_key: [k, true], capacity: r, weight: w, flow: 0)
- residual.add_edge(v, u, temp_key: [k, false], capacity: 0, weight: -w, flow: 0)
- end
- residual.graph[:inf] = inf
- _detect_unboundedness(residual)
- residual
- end
-
- # Returns the flowdict of the graph
- def self._build_flow_dict(graph, residual)
- flow_dict = {}
- inf = Float::INFINITY
-
- if graph.multigraph?
- graph.nodes(data: true).each_key do |u|
- flow_dict[u] = {}
- graph.adj[u].each do |v, uv_edges|
- flow_dict[u][v] = uv_edges.transform_values do |e|
- u != v || (e[:capacity] || inf) <= 0 || (e[:weight] || 0) >= 0 ? 0 : e[:capacity]
- end
- end
- residual.adj[u].each do |v, uv_edges|
- flow_dict[u][v].merge!(uv_edges.to_h do |_, val|
- [val[:temp_key][0], val[:flow]] if (val[:flow]).positive?
- end)
- end
- end
- else
- graph.nodes(data: true).each_key do |u|
- flow_dict[u] = graph.adj[u].to_h do |v, e|
- [v, u != v || (e[:capacity] || inf) <= 0 || (e[:weight] || 0) >= 0 ? 0 : e[:capacity]]
- end
- merge_dict = {}
- residual.adj[u].each do |v, uv_edges|
- uv_edges.each_value { |attrs| merge_dict[v] = attrs[:flow] if (attrs[:flow]).positive? }
- end
- flow_dict[u].merge!(merge_dict)
- end
- end
- flow_dict
- end
-
- # Computes max flow using capacity scaling algorithm
- #
- # @param graph [DiGraph, MultiDiGraph] a graph
- #
- # @return [Array Hash{ Object => Numeric } }>]
- # flow cost and flowdict containing all the flow values in the edges
- def self.capacity_scaling(graph)
- residual = _build_residual_network(graph)
- inf = Float::INFINITY
- flow_cost = 0
-
- # TODO: Account cost of self-loof edges
-
- wmax = ([-inf] + residual.adj.each_with_object([]) do |u, arr|
- u[1].each { |_, key_attrs| key_attrs.each { |_, attrs| arr << attrs[:capacity] } }
- end).max
-
- return flow_cost, _build_flow_dict(graph, residual) if wmax == -inf
-
- r_nodes = residual.nodes
- r_adj = residual.adj
-
- delta = 2**Math.log2(wmax).floor
- while delta >= 1
- r_nodes.each do |u, u_attrs|
- p_u = u_attrs[:potential]
- r_adj[u].each do |v, uv_edges|
- uv_edges.each do |_k, e|
- flow = e[:capacity]
- next unless (e[:weight] - p_u + r_nodes[v][:potential]).negative?
-
- flow = e[:capacity] - e[:flow]
- next unless flow >= delta
-
- e[:flow] += flow
- r_adj[v][u].each_key do |val|
- val[:flow] += val[:temp_key][0] == e[:temp_key][0] && val[:temp_key][1] != e[:temp_key][1] ? -flow : 0
- end
- r_nodes[u][:excess] -= flow
- r_nodes[v][:excess] += flow
- end
- end
- end
-
- s_set = Set.new
- t_set = Set.new
-
- residual.nodes(data: true).each do |u, _attrs|
- excess = r_nodes[u][:excess]
- if excess >= delta
- s_set.add(u)
- elsif excess <= -delta
- t_set.add(u)
- end
- end
-
- while !s_set.empty? && !t_set.empty?
- s = arbitrary_element
- t = nil
- d = {}
- pred = {s => nil}
- h = Heap.new { |x, y| x[0] < y[0] || (x[0] == y[0] && x[1] < y[1]) }
- h_dict = {s => 0}
- h << [0, count, s]
- until h.empty?
- d_u, _, u = h.pop
- h_dict.delete(u)
- d[u] = d_u
- if t_set.include?(u)
- t = u
- break
- end
- p_u = r_nodes[u][:potential]
- r_adj[u].each do |v, uv_edges|
- next if d.has_key?(v)
-
- wmin = inf
- uv_edges.each_value do |e|
- next unless e[:capacity] - e[:flow] >= delta
-
- w = e[:weight]
- next unless w < wmin
-
- wmin = w
- end
- next if wmin == inf
-
- d_v = d_u + wmin - p_u + r_nodes[v][:potential]
- next unless h_dict[v] > d_v
-
- h << [d_v, count, v]
- h_dict[v] = d_v
- pred[v] = [u, kmin, emin]
- end
- end
-
- if t.nil?
- s_set.delete(s)
- else
- while u != s
- v = u
- u, k, e = pred[v]
- e[:flow] += delta
- r_adj[v][u].each_key do |val|
- val[:flow] += val[:temp_key][0] == k[0] && val[:temp_key][1] != k[1] ? -delta : 0
- end
- end
- r_nodes[s][:excess] -= delta
- r_nodes[t][:excess] += delta
- s_set.delete(s) if r_nodes[s][:excess] < delta
- t_set.delete(t) if r_nodes[t][:excess] > -delta
- d_t = d[t]
- d.each { |node, d_u_node| r_nodes[node][:potential] -= (d_u_node - d_t) }
- end
- end
- delta = (delta / 2).floor
- end
-
- r_nodes.each_value { |attrs| raise ArgumentError, 'No flow satisfying all demands!' if attrs[:excess] != 0 }
-
- residual.nodes(data: true).each_key do |node|
- residual.adj[node].each_value do |uv_edges|
- uv_edges.each_value do |k_attrs|
- flow = k_attrs[:flow]
- flow_cost += (flow * k_attrs[:weight])
- end
- end
- end
- [flow_cost, _build_flow_dict(graph, residual)]
- end
-end
diff --git a/lib/networkx/flow/edmondskarp.rb b/lib/networkx/flow/edmondskarp.rb
deleted file mode 100644
index a4776fa..0000000
--- a/lib/networkx/flow/edmondskarp.rb
+++ /dev/null
@@ -1,115 +0,0 @@
-module NetworkX
- # Helper function to augment the flow in a residual graph
- def self.augment(residual, inf, path)
- flow = inf
- path_first_elem = path.shift
- u = path_first_elem
- path.each do |v|
- flow = [flow, residual.adj[u][v][:capacity] - residual.adj[u][v][:flow]].min
- u = v
- end
- raise ArgumentError, 'Infinite capacity path!' if flow * 2 > inf
-
- u = path_first_elem
- path.each do |v|
- residual.adj[u][v][:flow] += flow
- residual.adj[v][u][:flow] -= flow
- u = v
- end
- flow
- end
-
- # Helper function for the bidirectional bfs
- def self.bidirectional_bfs(residual, source, target)
- pred, succ = {source => nil}, {target => nil}
- q_s, q_t = [source], [target]
- loop do
- q = []
- if q_s.length <= q_t.length
- q_s.each do |u|
- residual.adj[u].each do |v, uv_attrs|
- next unless !pred.include?(v) && (uv_attrs[:flow] < uv_attrs[:capacity])
-
- pred[v] = u
- return [v, pred, succ] if succ.has_key?(v)
-
- q << v
- end
- end
- return [nil, nil, nil] if q.empty?
-
- q_s = q
- else
- q_t.each do |u|
- residual.pred[u].each do |v, uv_attrs|
- next unless !succ.has_key?(v) && uv_attrs[:flow] < uv_attrs[:capacity]
-
- succ[v] = u
- return [v, pred, succ] if pred.has_key?(v)
-
- q << v
- end
- end
- return [nil, nil, nil] if q.empty?
-
- q_t = q
- end
- end
- end
-
- # Core helper function for the EdmondsKarp algorithm
- def self.edmondskarp_core(residual, source, target, cutoff)
- inf = residual.graph[:inf]
- flow_val = 0
- while flow_val < cutoff
- v, pred, succ = bidirectional_bfs(residual, source, target)
- break if pred.nil?
-
- path = [v]
- u = v
- while u != source
- u = pred[u]
- path << u
- end
- path.reverse!
- u = v
- while u != target
- u = succ[u]
- path << u
- end
- flow_val += augment(residual, inf, path)
- end
- flow_val
- end
-
- # Helper function for the edmondskarp function
- def self.edmondskarp_impl(graph, source, target, residual, cutoff)
- raise ArgumentError, 'Source not in graph!' unless graph.nodes(data: true).has_key?(source)
- raise ArgumentError, 'Target not in graph!' unless graph.nodes(data: true).has_key?(target)
- raise ArgumentError, 'Source and target are same node!' if source == target
-
- res_graph = residual.nil? ? build_residual_network(graph) : residual.clone
- res_graph.adj.each do |u, u_edges|
- u_edges.each do |v, _attrs|
- res_graph.adj[u][v][:flow] = 0
- res_graph.pred[v][u][:flow] = 0
- end
- end
- cutoff = Float::INFINITY if cutoff.nil?
- res_graph.graph[:flow_value] = edmondskarp_core(res_graph, source, target, cutoff)
- res_graph
- end
-
- # Computes max flow using edmonds karp algorithm
- #
- # @param graph [Graph, DiGraph] a graph
- # @param source [Object] source node
- # @param target [Object] target node
- # @param residual [DiGraph, nil] residual graph
- # @param cutoff [Numeric] cutoff for the algorithm
- #
- # @return [DiGraph] a residual graph containing the flow values
- def self.edmondskarp(graph, source, target, residual = nil, cutoff = nil)
- edmondskarp_impl(graph, source, target, residual, cutoff)
- end
-end
diff --git a/lib/networkx/flow/preflowpush.rb b/lib/networkx/flow/preflowpush.rb
deleted file mode 100644
index 7d34b96..0000000
--- a/lib/networkx/flow/preflowpush.rb
+++ /dev/null
@@ -1,249 +0,0 @@
-module NetworkX
- # Helper function to return an arbitrary element from an iterable object
- def self.arbitrary_element(iterable)
- if iterable.is_a?(Hash)
- iterable.first[0]
- elsif iterable.respond_to?(:first)
- iterable.first
- elsif iterable.respond_to?(:[])
- iterable[0]
- end
- end
-
- # Helper function to apply the preflow push algorithm
- def self.preflowpush_impl(graph, source, target, residual, globalrelabel_freq, value_only)
- raise ArgumentError, 'Source not in graph!' unless graph.nodes(data: true).has_key?(source)
- raise ArgumentError, 'Target not in graph!' unless graph.nodes(data: true).has_key?(target)
- raise ArgumentError, 'Source and Target are same!' if source == target
-
- globalrelabel_freq = 0 if globalrelabel_freq.nil?
- raise ArgumentError, 'Global Relabel Freq must be nonnegative!' if globalrelabel_freq.negative?
-
- r_network = residual.nil? ? build_residual_network(graph) : residual
- detect_unboundedness(r_network, source, target)
-
- residual_nodes = r_network.nodes
- residual_adj = r_network.adj
- residual_pred = r_network.pred
-
- residual_nodes.each do |u, u_attrs|
- u_attrs[:excess] = 0
- residual_adj[u].each { |_v, attrs| attrs[:flow] = 0 }
- end
-
- heights = reverse_bfs(target, residual_pred)
-
- unless heights.has_key?(source)
- r_network.graph[:flow_value] = 0
- return r_network
- end
-
- n = r_network.nodes(data: true).length
- max_height = heights.map { |u, h| u == source ? -1 : h }.max
- heights[source] = n
-
- grt = GlobalRelabelThreshold.new(n, r_network.size, globalrelabel_freq)
-
- residual_nodes.each do |u, u_attrs|
- u_attrs[:height] = heights.has_key?(u) ? heights[u] : (n + 1)
- u_attrs[:curr_edge] = CurrentEdge.new(residual_adj[u])
- end
-
- residual_adj[source].each do |u, attr|
- flow = attr[:capacity]
- push(source, u, flow, residual_nodes, residual_adj) if flow.positive?
- end
-
- levels = (0..((2 * n) - 1)).map { |_| Level.new }
- residual_nodes.each do |u, attr|
- if u != source && u != target
- level = levels[attr[:height]]
- (residual_nodes[u][:excess]).positive? ? level.active.add(u) : level.inactive.add(u)
- end
- end
-
- height = max_height
- while height.positive?
- loop do
- level = levels[height]
- if level.active.empty?
- height -= 1
- break
- end
- old_height = height
- old_level = level
- u = arbitrary_element(level.active)
- height = discharge(u, true, residual_nodes, residual_adj, height, levels, grt, source, target)
- if grt.reached?
- height = global_relabel(true, source, target, residual_nodes, n, levels, residual_pred)
- max_height = height
- grt.clear_work
- elsif old_level.active.empty? && old_level.inactive.empty?
- gap_heuristic(old_height, levels, residual_nodes)
- height = old_height - 1
- max_height = height
- else
- max_height = [max_height, height].max
- end
- end
- end
-
- if value_only
- r_network.graph[:flow_value] = residual_nodes[target][:excess]
- return r_network
- end
-
- height = global_relabel(false, source, target, residual_nodes, n, levels, residual_pred)
- grt.clear_work
-
- while height > n
- loop do
- level = levels[height]
- if level.active.empty?
- height -= 1
- break
- end
- u = arbitrary_element(level.active)
- height = discharge(u, false, residual_nodes, residual_adj, height, levels, grt, source, target)
- if grt.reached?
- height = global_relabel(false, source, target, residual_nodes, n, levels, residual_pred)
- grt.clear_work
- end
- end
- end
- r_network.graph[:flow_value] = residual_nodes[target][:excess]
- r_network
- end
-
- # Helper function to move a node from inactive set to active set
- def self.activate(node, source, target, levels, residual_nodes)
- return if node == source || node == target
- return unless level.inactive.include?(node)
-
- level = levels[residual_nodes[node][:height]]
- level.inactive.delete(node)
- level.active.add(node)
- end
-
- # Helper function to relable a node to create a permissible edge
- def self.relabel(u_node, grt, r_adj, _r_nodes, _source, _target, _levels)
- grt.add_work(r_adj[u_node].length)
- r_adj[u_node].map { |v, attr| attr[:flow] < (attr[:capacity] + 1) ? _nodes[v][:height] : Float::INFINITY }.min
- end
-
- # Helper function for discharging a node
- def self.discharge(u_node, is_phase1, residual_nodes, residual_adj, height, levels, grt, source, target)
- height_val = residual_nodes[u_node][:height]
- curr_edge = residual_nodes[u_node][:curr_edge]
- next_height = height_val
- levels[height_val].active.delete(u_node)
-
- loop do
- v, attr = curr_edge.get
- if height_val == residual_nodes[v][:height] + 1 && attr[:flow] < attr[:capacity]
- flow = [residual_nodes[u_node][:excess], attr[:capacity] - attr[:flow]].min
- push(u_node, v, flow, residual_nodes, residual_adj)
- activate(v, source, target, levels, residual_nodes)
- if residual_nodes[u_node][:excess].zero?
- levels[height_val].inactive.add(u_node)
- break
- end
- end
- begin
- curr_edge.move_to_next
- rescue StopIteration
- height_val = relabel(u_node, grt, residual_adj, residual_nodes, source, target, levels)
- if is_phase1 && height_val >= n - 1
- levels[height].active.add(u_node)
- break
- end
- next_height = height_val
- end
- end
- residual_nodes[u_node][:height] = height_val
- next_height
- end
-
- # Helper function for applying gap heuristic
- def self.gap_heuristic(height, levels, residual_nodes)
- ((height + 1)..(max_height)).each do |idx|
- level = levels[idx]
- level.active.each { |u| residual_nodes[u][:height] = n + 1 }
- level.inactive.each { |u| residual_nodes[u][:height] = n + 1 }
- levels[n + 1].active.merge!(level.active)
- level.active.clear
- levels[n + 1].inactive.merge!(level.inactive)
- level.inactive.clear
- end
- end
-
- # Helper function for global relabel heuristic
- def self.global_relabel(from_sink, source, target, residual_nodes, num, levels, residual_pred)
- src = from_sink ? target : source
- heights = reverse_bfs(src, residual_pred)
- heights.delete(target) unless from_sink
- max_height = heights.values.max
- if from_sink
- residual_nodes.each { |u, attr| heights[u] = num + 1 if !heights.has_key?(u) && attr[:height] < num }
- else
- heights.each_key { |u| heights[u] += num }
- max_height += num
- end
- heights.delete(src)
- heights.each do |u, new_height|
- old_height = residual_nodes[u][:height]
- next unless new_height != old_height
-
- if levels[old_height].active.include?(u)
- levels[old_height].active.delete(u)
- levels[new_height].active.add(u)
- else
- levels[old_height].inactive.delete(u)
- levels[new_height].inactive.add(u)
- end
- residual_nodes[u][:height] = new_height
- end
- max_height
- end
-
- # Helper function for augmenting flow
- def self.push(node1, node2, flow, residual_nodes, residual_adj)
- residual_adj[node1][node2][:flow] += flow
- residual_adj[node2][node1][:flow] -= flow
- residual_nodes[node1][:excess] -= flow
- residual_nodes[node2][:excess] += flow
- end
-
- # Helper function for reverse bfs
- def self.reverse_bfs(src, residual_pred)
- heights = {src => 0}
- q = [[src, 0]]
-
- until q.empty?
- u, height = q.shift
- height += 1
- residual_pred[u].each do |v, attr|
- if !heights.has_key?(v) && attr[:flow] < attr[:capacity]
- heights[v] = height
- q << [v, height]
- end
- end
- end
- heights
- end
-
- # Computes max flow using preflow push algorithm
- #
- # @param graph [DiGraph] a graph
- # @param source [Object] source node
- # @param target [Object] target node
- # @param residual [DiGraph, nil] residual graph
- # @param globalrelabel_freq [Numeric] global relabel freq
- # @param value_only [Boolean] if false, compute maximum flow else
- # maximum preflow
- #
- # @return [DiGraph] a residual graph containing the flow values
- def self.preflowpush(graph, source, target, residual = nil, globalrelabel_freq = 1, value_only = false)
- preflowpush_impl(graph, source, target, residual, globalrelabel_freq, value_only)
- end
-end
diff --git a/lib/networkx/flow/shortestaugmentingpath.rb b/lib/networkx/flow/shortestaugmentingpath.rb
deleted file mode 100644
index 113c310..0000000
--- a/lib/networkx/flow/shortestaugmentingpath.rb
+++ /dev/null
@@ -1,154 +0,0 @@
-module NetworkX
- # Helper function for running the shortest augmenting path algorithm
- def self.shortest_augmenting_path_impl(graph, source, target, residual, two_phase, cutoff)
- raise ArgumentError, 'Source is not in the graph!' unless graph.nodes(data: true).has_key?(source)
- raise ArgumentError, 'Target is not in the graph!' unless graph.nodes(data: true).has_key?(target)
- raise ArgumentError, 'Source and Target are the same!' if source == target
-
- residual = residual.nil? ? build_residual_network(graph) : residual
- r_nodes = residual.nodes
- r_pred = residual.pred
- r_adj = residual.adj
-
- r_adj.each_value do |u_edges|
- u_edges.each_value do |attrs|
- attrs[:flow] = 0
- end
- end
-
- heights = {target => 0}
- q = [[target, 0]]
-
- until q.empty?
- u, height = q.shift
- height += 1
- r_pred[u].each do |v, attrs|
- if !heights.has_key?(v) && attrs[:flow] < attrs[:capacity]
- heights[v] = height
- q << [v, height]
- end
- end
- end
-
- unless heights.has_key?(source)
- residual.graph[:flow_value] = 0
- return residual
- end
-
- n = graph.nodes(data: true).length
- m = residual.size / 2
-
- r_nodes.each do |node, attrs|
- attrs[:height] = heights.has_key?(node) ? heights[node] : n
- attrs[:curr_edge] = CurrentEdge.new(r_adj[node])
- end
-
- counts = [0] * (2 * n - 1)
- r_nodes.each_value { |attrs| counts[attrs[:height]] += 1 }
- inf = graph.graph[:inf]
-
- cutoff = Float::INFINITY if cutoff.nil?
- flow_value = 0
- path = [source]
- u = source
- d = two_phase ? n : [m**0.5, 2 * (n**(2./ 3))].min.floor
- done = r_nodes[source][:height] >= d
-
- until done
- height = r_nodes[u][:height]
- curr_edge = r_nodes[u][:curr_edge]
-
- loop do
- v, attr = curr_edge.get
- if height == r_nodes[v][:height] + 1 && attr[:flow] < attr[:capacity]
- path << v
- u = v
- break
- end
- begin
- curr_edge.move_to_next
- rescue StopIteration
- if counts[height].zero?
- residual.graph[:flow_value] = flow_value
- return residual
- end
- height = relabel(u, n, r_adj, r_nodes)
- if u == source && height >= d
- if two_phase
- done = true
- break
- else
- residual.graph[:flow_value] = flow_value
- return residual
- end
- end
- counts[height] += 1
- r_nodes[u][:height] = height
- unless u == source
- path.pop
- u = path[-1]
- break
- end
- end
- end
- next unless u == target
-
- flow_value += augment(path, inf, r_adj)
- if flow_value >= cutoff
- residual.graph[:flow_value] = flow_value
- return residual
- end
- end
- flow_value += edmondskarp_core(residual, source, target, cutoff - flow_value)
- residual.graph[:flow_value] = flow_value
- residual
- end
-
- # Helper function for augmenting flow
- def augment(path, inf, r_adj)
- flow = inf
- temp_path = path.clone
- u = temp_path.shift
- temp_path.each do |v|
- attr = r_adj[u][v]
- flow = [flow, attr[:capacity] - attr[:flow]].min
- u = v
- end
- raise ArgumentError, 'Infinite capacity path!' if flow * 2 > inf
-
- temp_path = path.clone
- u = temp_path.shift
- temp_path.each do |v|
- r_adj[u][v][:flow] += flow
- r_adj[v][u][:flow] -= flow
- u = v
- end
- flow
- end
-
- # Helper function to relable a node to create a permissible edge
- def self.relabel(node, num, r_adj, r_nodes)
- height = num - 1
- r_adj[node].each do |v, attrs|
- height = [height, r_nodes[v][:height]].min if attrs[:flow] < attrs[:capacity]
- end
- height + 1
- end
-
- # Computes max flow using shortest augmenting path algorithm
- #
- # @param graph [DiGraph] a graph
- # @param source [Object] source node
- # @param target [Object] target node
- # @param residual [DiGraph, nil] residual graph
- # @param _value_only [Boolean] if true, compute only the maximum flow value
- # @param two_phase [Boolean] if true, two phase variant is used
- # @param cutoff [Numeric] cutoff value for the algorithm
- #
- # @return [DiGraph] a residual graph containing the flow values
- def self.shortest_augmenting_path(graph, source, target, residual = nil, \
- _value_only = false, two_phase = false, cutoff = nil)
-
- shortest_augmenting_path_impl(graph, source, target, residual, two_phase, cutoff)
- end
-end
diff --git a/lib/networkx/flow/utils.rb b/lib/networkx/flow/utils.rb
deleted file mode 100644
index 2702e59..0000000
--- a/lib/networkx/flow/utils.rb
+++ /dev/null
@@ -1,139 +0,0 @@
-module NetworkX
- # Helper class for preflow push algorithm
- class CurrentEdge
- attr_reader :curr, :edges
-
- def initialize(edges)
- @edges = edges
- @index = {}
- @n = edges.length
- @curr = 0
- edges.each_with_index { |(key, _value), idx| @index[idx] = key }
- end
-
- def get
- [@index[@curr], @edges[@index[@curr]]]
- end
-
- def move_to_next
- @temp = @curr
- @curr = (@curr + 1) % @n
- raise StopIteration if @temp == @n - 1
- end
- end
-
- # Helper class for preflow push algorithm
- class Level
- attr_reader :inactive, :active
-
- def initialize
- @inactive = Set.new
- @active = Set.new
- end
- end
-
- # Helper class for preflow push algorithm
- class GlobalRelabelThreshold
- def initialize(num1, num2, freq)
- freq = freq.nil? ? Float::INFINITY : freq
- @threshold = (num1 + num2) / freq
- @work = 0
- end
-
- def add_work(work)
- @work += work
- end
-
- def reached?
- @work >= @threshold
- end
-
- def clear_work
- @work = 0
- end
- end
-
- # Builds a residual graph from a constituent graph
- #
- # @param graph [DiGraph] a graph
- #
- # @return [DiGraph] residual graph
- def self.build_residual_network(graph)
- raise NotImplementedError, 'MultiGraph and MultiDiGraph not supported!' if graph.multigraph?
-
- r_network = NetworkX::DiGraph.new(inf: 0, flow_value: 0)
- r_network.add_nodes(graph.nodes(data: true).keys)
- inf = Float::INFINITY
- edge_list = []
-
- graph.adj.each do |u, u_edges|
- u_edges.each do |v, uv_attrs|
- edge_list << [u, v, uv_attrs] if (uv_attrs[:capacity] || inf).positive? && u != v
- end
- end
-
- inf_chk = 3 * edge_list.inject(0) do |result, arr|
- arr[2].has_key?(:capacity) && arr[2][:capacity] != inf ? (result + arr[2][:capacity]) : result
- end
- inf = inf_chk.zero? ? 1 : inf_chk
-
- if graph.directed?
- edge_list.each do |u, v, attrs|
- r = [attrs[:capacity] || inf, inf].min
- if r_network.adj[u][v].nil?
- r_network.add_edge(u, v, capacity: r)
- r_network.add_edge(v, u, capacity: 0)
- else
- r_network[u][v][:capacity] = r
- end
- end
- else
- edge_list.each do |u, v, attrs|
- r = [attrs[:capacity] || inf, inf].min
- r_network.add_edge(u, v, capacity: r)
- r_network.add_edge(v, u, capacity: r)
- end
- end
- r_network.graph[:inf] = inf
- r_network
- end
-
- # Detects unboundedness in a graph, raises exception when
- # infinite capacity flow is found
- #
- # @param r_network [DiGraph] a residual graph
- # @param source [Object] source node
- # @param target [Object] target node
- def self.detect_unboundedness(r_network, source, target)
- q = [source]
- seen = Set.new([source])
- inf = r_network.graph[:inf]
- until q.empty?
- u = q.shift
- r_network.adj[u].each do |v, uv_attrs|
- next unless uv_attrs[:capacity] == inf && !seen.include?(v)
- raise ArgumentError, 'Infinite capacity flow!' if v == target
-
- seen << v
- q << v
- end
- end
- end
-
- # Build flow dictionary of a graph from its residual graph
- #
- # @param graph [DiGraph] a graph
- # @param residual [DiGraph] residual graph
- #
- # @return [Hash{ Object => Hash{ Object => Numeric }] flowdict containing all
- # the flow values in the edges
- def self.build_flow_dict(graph, residual)
- flow_dict = {}
- graph.edges.each do |u, u_edges|
- flow_dict[u] = {}
- u_edges.each_key { |v| flow_dict[u][v] = 0 }
- u_edges.each_key { |v| flow_dict[u][v] = residual[u][v][:flow] if (residual[u][v][:flow]).positive? }
- end
- flow_dict
- end
-end
diff --git a/lib/networkx/graph.rb b/lib/networkx/graph.rb
deleted file mode 100644
index cc0873f..0000000
--- a/lib/networkx/graph.rb
+++ /dev/null
@@ -1,447 +0,0 @@
-module NetworkX
- # Describes the class for making Undirected Graphs
- #
- # @attr_reader adj [Hash{ Object => Hash{ Object => Hash{ Object => Object } } }]
- # Stores the edges and their attributes in an adjencency list form
- # @attr_reader graph [Hash{ Object => Object }] Stores the attributes of the graph
- class Graph
- attr_reader :adj, :graph
-
- # Constructor for initializing graph
- #
- # @example Initialize a graph with attributes 'type' and 'name'
- # graph = NetworkX::Graph.new(name: "Social Network", type: "undirected")
- #
- # @param graph_attrs [Hash{ Object => Object }] the graph attributes in a hash format
- def initialize(**graph_attrs)
- @nodes = {}
- @adj = {}
- @graph = graph_attrs
- end
-
- # Adds the respective edges
- #
- # @example Add an edge with attribute name
- # graph.add_edge(node1, node2, name: "Edge1")
- #
- # @example Add an edge with no attribute
- # graph.add_edge("Bangalore", "Chennai")
- #
- # @param node1 [Object] the first node of the edge
- # @param node2 [Object] the second node of the edge
- # @param edge_attrs [Hash{ Object => Object }] the hash of the edge attributes
- def add_edge(node1, node2, **edge_attrs)
- add_node(node1)
- add_node(node2)
-
- edge_attrs = (@adj[node1][node2] || {}).merge(edge_attrs)
- @adj[node1][node2] = edge_attrs
- @adj[node2][node1] = edge_attrs
- end
-
- # Adds multiple edges from an array
- #
- # @example Add multiple edges without any attributes
- # graph.add_edges([['Nagpur', 'Kgp'], ['Noida', 'Kgp']])
- # @param edges [Array]
- def add_edges(edges)
- case edges
- when Array
- edges.each { |node1, node2, attrs| add_edge(node1, node2, **(attrs || {})) }
- else
- raise ArgumentError, 'Expected argument to be an Array of edges, ' \
- "received #{edges.class.name} instead."
- end
- end
-
- def add_edges_from(rng)
- rng.each { |node| add_edge(*node) }
- end
-
- # Adds a node and its attributes to the graph
- #
- # @example Add a node with attribute 'type'
- # graph.add_node("Noida", type: "city")
- #
- # @param node [Object] the node object
- # @param node_attrs [Hash{ Object => Object }] the hash of the attributes of the node
- def add_node(node, **node_attrs)
- if @nodes.has_key?(node)
- @nodes[node].merge!(node_attrs)
- else
- @adj[node] = {}
- @nodes[node] = node_attrs
- end
- end
-
- # Adds multiple nodes to the graph
- #
- # @example Adds multiple nodes with attribute 'type'
- # graph.add_nodes([["Noida", type: "city"], ["Kgp", type: "town"]])
- #
- # @param nodes [Array Object }>] the Array of pair containing nodes and its attributes
- def add_nodes(nodes)
- case nodes
- when Set, Array
- nodes.each { |node, node_attrs| add_node(node, **(node_attrs || {})) }
- when Range
- nodes.each { |node| add_node(node) }
- else
- raise ArgumentError, 'Expected argument to be an Array/Set/Range of nodes, ' \
- "received #{nodes.class.name} instead."
- end
- end
-
- # [TODO][EXPERIMENTAL]
- #
- # @param nodes_for_adding [Array | Range | String] nodes
- def add_nodes_from(nodes_for_adding)
- case nodes_for_adding
- when String
- nodes_for_adding.each_char { |node| add_node(node) }
- else
- nodes_for_adding.each { |node| add_node(node) }
- end
- end
-
- def add_path(paths)
- paths.each_cons(2){|x, y| add_edge(x, y) }
- end
-
- # Removes node from the graph
- #
- # @example
- # graph.remove_node("Noida")
- #
- # @param node [Object] the node to be removed
- def remove_node(node)
- raise KeyError, "Error in deleting node #{node} from Graph." unless @nodes.has_key?(node)
-
- @adj[node].each_key { |k| @adj[k].delete(node) }
- @adj.delete(node)
- @nodes.delete(node)
- end
-
- # Removes multiple nodes from the graph
- #
- # @example
- # graph.remove_nodes(["Noida", "Bangalore"])
- #
- # @param nodes [Array] the array of nodes to be removed
- def remove_nodes(nodes)
- case nodes
- when Set, Array
- nodes.each { |node| remove_node(node) }
- else
- raise ArgumentError, 'Expected argument to be an Array or Set of nodes, ' \
- "received #{nodes.class.name} instead."
- end
- end
- alias remove_nodes_from remove_nodes
-
- # Removes edge from the graph
- #
- # @example
- # graph.remove_edge('Noida', 'Bangalore')
- #
- # @param node1 [Object] the first node of the edge
- # @param node2 [Object] the second node of the edge
- def remove_edge(node1, node2)
- raise KeyError, "#{node1} is not a valid node." unless @nodes.has_key?(node1)
- raise KeyError, "#{node2} is not a valid node" unless @nodes.has_key?(node2)
- raise KeyError, 'The given edge is not a valid one.' unless @adj[node1].has_key?(node2)
-
- @adj[node1].delete(node2)
- @adj[node2].delete(node1) if node1 != node2
- end
-
- # Removes multiple edges from the graph
- #
- # @example
- # graph.remove_edges([%w[Noida Bangalore], %w[Bangalore Chennai]])
- #
- # @param edges [Array] the array of edges to be removed
- def remove_edges(edges)
- case edges
- when Array, Set
- edges.each { |node1, node2| remove_edge(node1, node2) }
- else
- raise ArgumentError, 'Expected Arguement to be Array or Set of edges, ' \
- "received #{edges.class.name} instead."
- end
- end
- alias remove_edges_from remove_edges
-
- # Adds weighted edge
- #
- # @example
- # graph.add_weighted_edge('Noida', 'Bangalore', 1000)
- #
- # @param node1 [Object] the first node of the edge
- # @param node2 [Object] the second node of the edge
- # @param weight [Integer] the weight value
- def add_weighted_edge(node1, node2, weight)
- add_edge(node1, node2, weight: weight)
- end
-
- # Adds multiple weighted edges
- #
- # @example
- # graph.add_weighted_edges([['Noida', 'Bangalore'],
- # ['Noida', 'Nagpur']], [1000, 2000])
- #
- # @param edges [Array] the array of edges
- # @param weights [Array] the array of weights
- def add_weighted_edges(edges, weights)
- raise ArgumentError, 'edges and weights array must have equal number of elements.' \
- unless edges.size == weights.size
- raise ArgumentError, 'edges and weight must be given in an Array.' \
- unless edges.is_a?(Array) && weights.is_a?(Array)
-
- (edges.transpose << weights).transpose.each do |node1, node2, weight|
- add_weighted_edge(node1, node2, weight)
- end
- end
-
- # [TODO][EXPERIMENTAL]
- #
- # @param edges [[Object, Object, Integer|Float]] the weight of edge
- # @param weight [Symbol] weight name key. default key is `:weight``
- def add_weighted_edges_from(edges, weight: :weight)
- edges.each do |s, t, w|
- add_edge(s, t, **{weight => w})
- end
- end
-
- # Return nodes of graph
- #
- # @param data [bool] true if you want data of each edge
- #
- # @return [Hash | Array] if data is true, it returns hash including data.
- # otherwise, simple nodes array.
- def nodes(data: false)
- if data
- @nodes
- else
- @nodes.keys
- end
- end
-
- def each_node(data: false, &block)
- return enum_for(:each_node, data: data) unless block_given?
-
- data ? @nodes.each(&block) : @nodes.each_key(&block)
- end
-
- # [TODO][EXPERIMENTAL]
- #
- # @param data [bool] true if you want data of each edge
- #
- # @return [Array[[Object, Object]]] edges array
- def edges(data: false)
- each_edge(data: data).to_a
- end
-
- # [TODO][EXPERIMENTAL]
- #
- # @param data [bool] true if you want data of each edge
- def each_edge(data: false)
- return enum_for(:each_edge, data: data) unless block_given?
-
- h = {}
- @adj.each do |v, ws|
- ws.each do |w, info|
- next if v > w
-
- h[[v, w, info]] = true
- end
- end
- if data
- h.each { |(v, w, info), _true| yield(v, w, info) }
- else
- h.each { |(v, w, _info), _true| yield(v, w) }
- end
- end
-
- # Clears the graph
- #
- # @example
- # graph.clear
- def clear
- @adj.clear
- @nodes.clear
- @graph.clear
- end
-
- # Checks if a node is present in the graph
- #
- # @example
- # graph.node?(node1)
- #
- # @param node [Object] the node to be checked
- def node?(node)
- @nodes.has_key?(node)
- end
- alias has_node? node?
-
- # Checks if the the edge consisting of two nodes is present in the graph
- #
- # @example
- # graph.edge?(node1, node2)
- #
- # @param node1 [Object] the first node of the edge to be checked
- # @param node2 [Object] the second node of the edge to be checked
- def edge?(node1, node2)
- node?(node1) && @adj[node1].has_key?(node2)
- end
- alias has_edge? edge?
-
- # Gets the node data
- #
- # @example
- # graph.get_node_data(node)
- #
- # @param node [Object] the node whose data is to be fetched
- def get_node_data(node)
- raise ArgumentError, 'No such node exists!' unless node?(node)
-
- @nodes[node]
- end
-
- # Gets the edge data
- #
- # @example
- # graph.get_edge_data(node1, node2)
- #
- # @param node1 [Object] the first node of the edge
- # @param node2 [Object] the second node of the edge
- def get_edge_data(node1, node2)
- raise KeyError, 'No such edge exists!' unless node?(node1) && node?(node2)
-
- @adj[node1][node2]
- end
-
- # Retus a hash of neighbours of a node
- #
- # @example
- # graph.neighbours(node)
- #
- # @param node [Object] the node whose neighbours are to be fetched
- def neighbours(node)
- raise KeyError, 'No such node exists!' unless node?(node)
-
- @adj[node]
- end
-
- # Returns number of nodes
- #
- # @example
- # graph.number_of_nodes
- def number_of_nodes
- @nodes.length
- end
-
- # Returns number of edges
- #
- # @example
- # graph.number_of_edges
- def number_of_edges
- @adj.values.map(&:length).sum / 2
- end
-
- # Returns the size of the graph
- #
- # @example
- # graph.size(true)
- #
- # @param is_weighted [Bool] if true, method returns sum of weights of all edges
- # else returns number of edges
- def size(is_weighted = false)
- if is_weighted
- graph_size = 0
- @adj.each do |_, hash_val|
- hash_val.each { |_, v| graph_size += v[:weight] if v.has_key?(:weight) }
- end
- return graph_size / 2
- end
- number_of_edges
- end
-
- # Returns subgraph consisting of given array of nodes
- #
- # @example
- # graph.subgraph(%w[Mumbai Nagpur])
- #
- # @param nodes [Array] the nodes to be included in the subgraph
- def subgraph(nodes)
- case nodes
- when Array, Set
- sub_graph = NetworkX::Graph.new(**@graph)
- nodes.each do |u, _|
- raise KeyError, "#{u} does not exist in the current graph!" unless @nodes.has_key?(u)
-
- sub_graph.add_node(u, **@nodes[u])
- @adj[u].each do |v, edge_val|
- sub_graph.add_edge(u, v, **edge_val) if @adj[u].has_key?(v) && nodes.include?(v)
- end
- end
- sub_graph
- else
- raise ArgumentError, 'Expected Argument to be Array or Set of nodes, ' \
- "received #{nodes.class.name} instead."
- end
- end
-
- # Returns subgraph conisting of given edges
- #
- # @example
- # graph.edge_subgraph([%w[Nagpur Wardha], %w[Nagpur Mumbai]])
- #
- # @param edges [Array] the edges to be included in the subraph
- def edge_subgraph(edges)
- case edges
- when Array, Set
- sub_graph = NetworkX::Graph.new(**@graph)
- edges.each do |u, v|
- raise KeyError, "Edge between #{u} and #{v} does not exist in the graph!" unless @nodes.has_key?(u) \
- && @adj[u].has_key?(v)
-
- sub_graph.add_node(u, **@nodes[u])
- sub_graph.add_node(v, **@nodes[v])
- sub_graph.add_edge(u, v, **@adj[u][v])
- end
- sub_graph
- else
- raise ArgumentError, 'Expected Argument to be Array or Set of edges, ' \
- "received #{edges.class.name} instead."
- end
- end
-
- # [EXPERIMENTAL]
- def degree(nodes = nil)
- if nodes.nil?
- @adj.transform_values(&:size)
- else
- res = {}
- nodes.each { |node| res[node] = @adj[node].size }
- res
- end
- end
-
- def info
- info = ''
- info << "Type: #{self.class}\n"
- info << "Number of nodes: #{number_of_nodes}\n"
- info << "Number of edges: #{number_of_edges}\n"
- info
- end
-
- def multigraph?
- ['NetworkX::MultiGraph', 'NetworkX::MultiDiGraph'].include?(self.class.name)
- end
-
- def directed?
- ['NetworkX::DiGraph', 'NetworkX::MultiDiGraph'].include?(self.class.name)
- end
- end
-end
diff --git a/lib/networkx/link_analysis/hits.rb b/lib/networkx/link_analysis/hits.rb
deleted file mode 100644
index 5f5a245..0000000
--- a/lib/networkx/link_analysis/hits.rb
+++ /dev/null
@@ -1,59 +0,0 @@
-module NetworkX
- # Computes hits and authority scores for all the graphs
- #
- # @param graph [Graph, DiGraph] a graph
- # @param max_iter [Integer] max iterations to run the hits algorithm
- # @param tol [Numeric] tolerences to cut off the loop
- # @param nstart [Array] starting hub values for the nodes
- #
- # @return [Array] hits and authority scores
- def self.hits(graph, max_iter = 100, tol = 1e-8, nstart)
- return [{}, {}] if graph.nodes(data: true).empty?
-
- h = nstart
- sum = h.values.sum
- h.each_key { |k| h[k] /= (sum * 1.0) }
- i = 0
- a = {}
-
- loop do
- hlast = Marshal.load(Marshal.dump(h))
- h, a = {}, {}
- hlast.each do |k, _v|
- h[k] = 0
- a[k] = 0
- end
- h.each_key { |k| graph.adj[k].each { |nbr, attrs| a[k] += hlast[nbr] * (attrs[:weight] || 1) } }
- h.each_key { |k| graph.adj[k].each { |nbr, attrs| h[k] += a[nbr] * (attrs[:weight] || 1) } }
- smax = h.values.max
- h.each_key { |k| h[k] /= smax }
- smax = a.values.max
- a.each_key { |k| a[k] /= smax }
- break if h.keys.map { |k| (h[k] - hlast[k]).abs }.sum < tol
- raise ArgumentError, 'Power Iteration failed to converge!' if i > max_iter
-
- i += 1
- end
- [h, a]
- end
-
- # Computes authority matrix for the graph
- #
- # @param graph [Graph, DiGraph] a graph
- #
- # @return [Matrix] authority matrix for the graph
- def self.authority_matrix(graph)
- matrix, = to_matrix(graph, 0)
- matrix.transpose * matrix
- end
-
- # Computes hub matrix for the graph
- #
- # @param graph [Graph, DiGraph] a graph
- #
- # @return [Matrix] hub matrix for the graph
- def self.hub_matrix(graph)
- matrix, = to_matrix(graph, 0)
- matrix * matrix.transpose
- end
-end
diff --git a/lib/networkx/link_analysis/pagerank.rb b/lib/networkx/link_analysis/pagerank.rb
deleted file mode 100644
index a995ab7..0000000
--- a/lib/networkx/link_analysis/pagerank.rb
+++ /dev/null
@@ -1,45 +0,0 @@
-module NetworkX
- # Computes pagerank values for the graph
- #
- # @param graph [Graph] a graph
- # @param alpha [Numeric] the alpha value to compute the pagerank
- # @param eps [Numeric] tolerence to check for convergence
- # @param max_iter [Integer] max iterations for the pagerank algorithm to run
- #
- # @return [Hash of Object => Float] pagerank values of the graph
- def self.pagerank(graph, alpha: 0.85, personalization: nil, eps: 1e-6, max_iter: 100)
- n = graph.number_of_nodes
-
- matrix, index_to_node = NetworkX.to_matrix(graph, 0)
-
- index_from_node = index_to_node.invert
-
- probabilities = Array.new(n) do |i|
- total = matrix.row(i).sum
- (matrix.row(i) / total.to_f).to_a
- end
-
- curr = personalization
- unless curr
- curr = Array.new(n)
- graph.each_node{|node| curr[index_from_node[node]] = 1.0 / n }
- end
-
- max_iter.times do
- prev = curr.clone
-
- n.times do |i|
- ip = 0.0
- n.times do |j|
- ip += probabilities[j][i] * prev[j]
- end
- curr[i] = (alpha * ip) + ((1.0 - alpha) / n * 1.0)
- end
-
- err = (0...n).map{|i| (prev[i] - curr[i]).abs }.sum
- return (0...n).map{|i| [index_to_node[i], curr[i]] }.sort.to_h if err < eps
- end
- warn "pagerank() failed within #{max_iter} iterations. Please inclease max_iter: or loosen eps:"
- (0...n).map{|i| [index_to_node[i], curr[i]] }.sort.to_h
- end
-end
diff --git a/lib/networkx/multidigraph.rb b/lib/networkx/multidigraph.rb
deleted file mode 100644
index 7c936e9..0000000
--- a/lib/networkx/multidigraph.rb
+++ /dev/null
@@ -1,249 +0,0 @@
-module NetworkX
- # Describes the class for making MultiDiGraphs
- #
- # @attr_reader adj [Hash{ Object => Hash{ Object => Hash{ Integer => Hash{ Object => Object } } } }]
- # Stores the edges and their attributes in an adjencency list form
- # @attr_reader pred [Hash{ Object => Hash{ Object => Hash{ Integer => Hash{ Object => Object } } } }]
- # Stores the reverse edges and their attributes in an adjencency list form
- # @attr_reader nodes [Hash{ Object => Hash{ Object => Object } }] Stores the nodes and their attributes
- # @attr_reader graph [Hash{ Object => Object }] Stores the attributes of the graph
- class MultiDiGraph < DiGraph
- # Returns a new key
- #
- # @param node1 [Object] the first node of a given edge
- # @param node2 [Object] the second node of a given edge
- def new_edge_key(node1, node2)
- return 0 if @adj[node1][node2].nil?
-
- key = @adj[node1][node2].length
- key += 1 while @adj[node1][node2].has_key?(key)
- key
- end
-
- # Adds the respective edge
- #
- # @example Add an edge with attribute name
- # graph.add_edge(node1, node2, name: "Edge1")
- #
- # @example Add an edge with no attribute
- # graph.add_edge("Bangalore", "Chennai")
- #
- # @param node1 [Object] the first node of the edge
- # @param node2 [Object] the second node of the edge
- # @param edge_attrs [Hash{ Object => Object }] the hash of the edge attributes
- def add_edge(node1, node2, **edge_attrs)
- add_node(node1)
- add_node(node2)
- key = new_edge_key(node1, node2)
- all_edge_attrs = @adj[node1][node2] || {}
- all_edge_attrs[key] = edge_attrs
- @adj[node1][node2] = all_edge_attrs
- @pred[node2][node1] = all_edge_attrs
- end
-
- # Removes edge from the graph
- #
- # @example
- # graph.remove_edge('Noida', 'Bangalore')
- #
- # @param node1 [Object] the first node of the edge
- # @param node2 [Object] the second node of the edge
- def remove_edge(node1, node2, key = nil)
- return super(node1, node2) if key.nil?
-
- raise KeyError, "#{node1} is not a valid node." unless @nodes.has_key?(node1)
- raise KeyError, "#{node2} is not a valid node" unless @nodes.has_key?(node2)
- raise KeyError, 'The given edge is not a valid one.' unless @adj[node1].has_key?(node2)
- if @adj[node1][node2].none? { |_index, data| data[:key] == key }
- raise KeyError, 'The given edge is not a valid one'
- end
-
- @adj[node1][node2].delete_if { |_indx, data| data[:key] == key }
- @pred[node2][node1].delete_if { |_indx, data| data[:key] == key }
- end
-
- # Checks if the the edge consisting of two nodes is present in the graph
- #
- # @example
- # graph.edge?(node1, node2)
- #
- # @param node1 [Object] the first node of the edge to be checked
- # @param node2 [Object] the second node of the edge to be checked
- # @param key [Integer] the key of the given edge
- def edge?(node1, node2, key = nil)
- return super(node1, node2) if key.nil?
-
- node?(node1) && @adj[node1].has_key?(node2) && @adj[node1][node2].has_key?(key)
- end
-
- def has_edge?(node1, node2, key = nil)
- return super(node1, node2) if key.nil?
-
- return false unless node?(node1) && @adj[node1].has_key?(node2)
-
- @adj[node1][node2].any? { |_index, data| data[:key] == key }
- end
-
- # Returns the undirected version of the graph
- #
- # @example
- # graph.to_undirected
- def to_undirected
- graph = NetworkX::Graph.new(**@graph)
- @nodes.each { |node, node_attr| graph.add_node(node, **node_attr) }
- @adj.each do |node1, node1_edges|
- node1_edges.each do |node2, node1_node2|
- edge_attrs = {}
- node1_node2.each { |_key, attrs| edge_attrs.merge!(attrs) }
- graph.add_edge(node1, node2, **edge_attrs)
- end
- end
- graph
- end
-
- # Returns the directed version of the graph
- #
- # @example
- # graph.to_directed
- def to_directed
- graph = NetworkX::DiGraph.new(**@graph)
- @nodes.each { |node, node_attr| graph.add_node(node, **node_attr) }
- @adj.each do |node1, node1_edges|
- node1_edges.each do |node2, node1_node2|
- edge_attrs = {}
- node1_node2.each { |_key, attrs| edge_attrs.merge!(attrs) }
- graph.add_edge(node1, node2, **edge_attrs)
- end
- end
- graph
- end
-
- # Returns the multigraph version of the graph
- #
- # @example
- # graph.to_multigraph
- def to_multigraph
- graph = NetworkX::MultiGraph.new(**@graph)
- @nodes.each { |node, node_attr| graph.add_node(node, **node_attr) }
- @adj.each do |node1, node2_edges|
- node2_edges.each do |node2, edges|
- edges.each { |_key, attrs| graph.add_edge(node1, node2, **attrs) }
- end
- end
- graph
- end
-
- # Returns the reversed version of the graph
- #
- # @example
- # graph.reverse
- def reverse
- new_graph = NetworkX::MultiDiGraph.new(**@graph)
- @nodes.each { |node, attrs| new_graph.add_node(node, **attrs) }
- @adj.each do |u, u_edges|
- u_edges.each { |v, uv_attrs| uv_attrs.each { |_k, edge_attrs| new_graph.add_edge(v, u, **edge_attrs) } }
- end
- new_graph
- end
-
- # Returns in-degree of a given node
- #
- # @example
- # graph.in_degree(node)
- #
- # @param node [Object] the node whose in degree is to be calculated
- def in_degree(node)
- @pred[node].values.map(&:length).sum
- end
-
- # Returns out-degree of a given node
- #
- # @example
- # graph.out_degree(node)
- #
- # @param node [Object] the node whose out degree is to be calculated
- def out_degree(node)
- @adj[node].values.map(&:length).sum
- end
-
- # Returns number of edges
- #
- # @example
- # graph.number_of_edges
- def number_of_edges
- @adj.values.flat_map(&:values).map(&:length).sum
- end
-
- # Returns the size of the graph
- #
- # @example
- # graph.size(true)
- #
- # @param is_weighted [Bool] if true, method returns sum of weights of all edges
- # else returns number of edges
- def size(is_weighted = false)
- if is_weighted
- graph_size = 0
- @adj.each do |_, hash_val|
- hash_val.each { |_, v| v.each { |_, attrs| graph_size += attrs[:weight] if attrs.has_key?(:weight) } }
- end
- return graph_size
- end
- number_of_edges
- end
-
- # Returns subgraph consisting of given array of nodes
- #
- # @example
- # graph.subgraph(%w[Mumbai Nagpur])
- #
- # @param nodes [Array] the nodes to be included in the subgraph
- def subgraph(nodes)
- case nodes
- when Array, Set
- sub_graph = NetworkX::MultiDiGraph.new(**@graph)
- nodes.each do |u, _|
- raise KeyError, "#{u} does not exist in the current graph!" unless @nodes.has_key?(u)
-
- sub_graph.add_node(u, **@nodes[u])
- @adj[u].each do |v, edge_val|
- edge_val.each { |_, keyval| sub_graph.add_edge(u, v, **keyval) if @adj[u].has_key?(v) && nodes.include?(v) }
- end
- end
- sub_graph
- else
- raise ArgumentError, 'Expected Argument to be Array or Set of nodes, ' \
- "received #{nodes.class.name} instead."
- end
- end
-
- # Returns subgraph conisting of given edges
- #
- # @example
- # graph.edge_subgraph([%w[Nagpur Wardha], %w[Nagpur Mumbai]])
- #
- # @param edges [Array] the edges to be included in the subraph
- def edge_subgraph(edges)
- case edges
- when Array, Set
- sub_graph = NetworkX::MultiDiGraph.new(**@graph)
- edges.each do |u, v|
- raise KeyError, "Edge between #{u} and #{v} does not exist in the graph!" unless @nodes.has_key?(u) \
- && @adj[u].has_key?(v)
-
- sub_graph.add_node(u, **@nodes[u])
- sub_graph.add_node(v, **@nodes[v])
- @adj[u][v].each { |_, keyval| sub_graph.add_edge(u, v, **keyval) }
- end
- sub_graph
- else
- raise ArgumentError, 'Expected Argument to be Array or Set of edges, ' \
- "received #{edges.class.name} instead."
- end
- end
-
- def multigraph?
- true
- end
- end
-end
diff --git a/lib/networkx/multigraph.rb b/lib/networkx/multigraph.rb
deleted file mode 100644
index 8a82c7b..0000000
--- a/lib/networkx/multigraph.rb
+++ /dev/null
@@ -1,199 +0,0 @@
-module NetworkX
- # Describes the class for making MultiGraphs
- #
- # @attr_reader adj [Hash{ Object => Hash{ Object => Hash{ Integer => Hash{ Object => Object } } } }]
- # Stores the edges and their attributes in an adjencency list form
- # @attr_reader nodes [Hash{ Object => Hash{ Object => Object } }] Stores the nodes and their attributes
- # @attr_reader graph [Hash{ Object => Object }] Stores the attributes of the gra
- class MultiGraph < Graph
- # Returns a new key
- #
- # @param node1 [Object] the first node of a given edge
- # @param node2 [Object] the second node of a given edge
- def new_edge_key(node1, node2)
- return 0 if @adj[node1][node2].nil?
-
- key = @adj[node1][node2].length
- key += 1 while @adj[node1][node2].has_key?(key)
- key
- end
-
- # Adds the respective edge
- #
- # @example Add an edge with attribute name
- # graph.add_edge(node1, node2, name: "Edge1")
- #
- # @example Add an edge with no attribute
- # graph.add_edge("Bangalore", "Chennai")
- #
- # @param node1 [Object] the first node of the edge
- # @param node2 [Object] the second node of the edge
- # @param edge_attrs [Hash{ Object => Object }] the hash of the edge attributes
- def add_edge(node1, node2, **edge_attrs)
- add_node(node1)
- add_node(node2)
- key = new_edge_key(node1, node2)
- all_edge_attrs = @adj[node1][node2] || {}
- all_edge_attrs[key] = edge_attrs
- @adj[node1][node2] = all_edge_attrs
- @adj[node2][node1] = all_edge_attrs
- end
-
- # Removes edge from the graph
- #
- # @example
- # graph.remove_edge('Noida', 'Bangalore')
- #
- # @param node1 [Object] the first node of the edge
- # @param node2 [Object] the second node of the edge
- def remove_edge(node1, node2, key = nil)
- return super(node1, node2) if key.nil?
-
- raise KeyError, "#{node1} is not a valid node." unless @nodes.has_key?(node1)
- raise KeyError, "#{node2} is not a valid node" unless @nodes.has_key?(node2)
- raise KeyError, 'The given edge is not a valid one.' unless @adj[node1].has_key?(node2)
-
- if @adj[node1][node2].none? { |_index, data| data[:key] == key }
- raise KeyError, 'The given edge is not a valid one'
- end
-
- @adj[node1][node2].delete_if { |_indx, data| data[:key] == key }
- @adj[node2][node1].delete_if { |_indx, data| data[:key] == key }
- end
-
- # Returns the size of the graph
- #
- # @example
- # graph.size(true)
- #
- # @param is_weighted [Bool] if true, method returns sum of weights of all edges
- # else returns number of edges
- def size(is_weighted = false)
- if is_weighted
- graph_size = 0
- @adj.each do |_, hash_val|
- hash_val.each { |_, v| v.each { |_, attrs| graph_size += attrs[:weight] if attrs.has_key?(:weight) } }
- end
- return graph_size / 2
- end
- number_of_edges
- end
-
- # Returns number of edges
- #
- # @example
- # graph.number_of_edges
- def number_of_edges
- @adj.values.flat_map(&:values).map(&:length).sum / 2
- end
-
- # Checks if the the edge consisting of two nodes is present in the graph
- #
- # @example
- # graph.edge?(node1, node2)
- #
- # @param node1 [Object] the first node of the edge to be checked
- # @param node2 [Object] the second node of the edge to be checked
- # @param key [Integer] the key of the given edge
- def edge?(node1, node2, key = nil)
- return super(node1, node2) if key.nil?
-
- node?(node1) && @adj[node1].has_key?(node2) && @adj[node1][node2].has_key?(key)
- end
-
- def has_edge?(node1, node2, key = nil)
- return super(node1, node2) if key.nil?
-
- return false unless node?(node1) && @adj[node1].has_key?(node2)
-
- @adj[node1][node2].any? { |_index, data| data[:key] == key }
- end
-
- def each_edge(data: false)
- return enum_for(:each_edge, data: data) unless block_given?
-
- @adj.each do |v, ws|
- ws.each do |w, key_and_info|
- next if v > w
-
- key_and_info.each do |key, info|
- data ? yield(v, w, key, info) : yield(v, w, key)
- end
- end
- end
- end
-
- # Returns the undirected version of the graph
- #
- # @example
- # graph.to_undirected
- def to_undirected
- graph = NetworkX::Graph.new(**@graph)
- @nodes.each { |node, node_attr| graph.add_node(node, **node_attr) }
- @adj.each do |node1, node1_edges|
- node1_edges.each do |node2, node1_node2|
- edge_attrs = {}
- node1_node2.each { |_key, attrs| edge_attrs.merge!(attrs) }
- graph.add_edge(node1, node2, **edge_attrs)
- end
- end
- graph
- end
-
- # Returns subgraph consisting of given array of nodes
- #
- # @example
- # graph.subgraph(%w[Mumbai Nagpur])
- #
- # @param nodes [Array] the nodes to be included in the subgraph
- def subgraph(nodes)
- case nodes
- when Array, Set
- sub_graph = NetworkX::MultiGraph.new(**@graph)
- nodes.each do |u, _|
- raise KeyError, "#{u} does not exist in the current graph!" unless @nodes.has_key?(u)
-
- sub_graph.add_node(u, **@nodes[u])
- @adj[u].each do |v, edge_val|
- next if u > v
-
- edge_val.each { |_, keyval| sub_graph.add_edge(u, v, **keyval) if @adj[u].has_key?(v) && nodes.include?(v) }
- end
- end
- sub_graph
- else
- raise ArgumentError, 'Expected Argument to be Array or Set of nodes, ' \
- "received #{nodes.class.name} instead."
- end
- end
-
- # Returns subgraph conisting of given edges
- #
- # @example
- # graph.edge_subgraph([%w[Nagpur Wardha], %w[Nagpur Mumbai]])
- #
- # @param edges [Array] the edges to be included in the subraph
- def edge_subgraph(edges)
- case edges
- when Array, Set
- sub_graph = NetworkX::MultiGraph.new(**@graph)
- edges.each do |u, v|
- raise KeyError, "Edge between #{u} and #{v} does not exist in the graph!" unless @nodes.has_key?(u) \
- && @adj[u].has_key?(v)
-
- sub_graph.add_node(u, **@nodes[u])
- sub_graph.add_node(v, **@nodes[v])
- @adj[u][v].each { |_, keyval| sub_graph.add_edge(u, v, **keyval) }
- end
- sub_graph
- else
- raise ArgumentError, 'Expected Argument to be Array or Set of edges, ' \
- "received #{edges.class.name} instead."
- end
- end
-
- def multigraph?
- true
- end
- end
-end
diff --git a/lib/networkx/operators/all.rb b/lib/networkx/operators/all.rb
deleted file mode 100644
index 63a55dc..0000000
--- a/lib/networkx/operators/all.rb
+++ /dev/null
@@ -1,65 +0,0 @@
-module NetworkX
- # Performs the union of many graphs
- #
- # @param graphs [Array, Array, Array, Array] Array of graphs
- #
- # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] union of all the graphs
- def self.union_all(graphs)
- raise ArgumentError, 'Argument array is empty' if graphs.empty?
-
- result = graphs.shift
-
- graphs.each do |graph|
- result = NetworkX.union(result, graph)
- end
- result
- end
-
- # Performs the disjoint union of many graphs
- #
- # @param graphs [Array, Array, Array, Array] Array of graphs
- #
- # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] disjoint union of all the graphs
- def self.disjoint_union_all(graphs)
- raise ArgumentError, 'Argument array is empty' if graphs.empty?
-
- result = graphs.shift
-
- graphs.each do |graph|
- result = NetworkX.disjoint_union(result, graph)
- end
- result
- end
-
- # Performs the intersection of many graphs
- #
- # @param graphs [Array, Array, Array, Array] Array of graphs
- #
- # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] intersection of all the graphs
- def self.intersection_all(graphs)
- raise ArgumentError, 'Argument array is empty' if graphs.empty?
-
- result = graphs.shift
-
- graphs.each do |graph|
- result = NetworkX.intersection(result, graph)
- end
- result
- end
-
- # Performs the composition of many graphs
- #
- # @param graphs [Array, Array, Array, Array] Array of graphs
- #
- # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] composition of all the graphs
- def self.compose_all(graphs)
- raise ArgumentError, 'Argument array is empty' if graphs.empty?
-
- result = graphs.shift
-
- graphs.each do |graph|
- result = NetworkX.compose(result, graph)
- end
- result
- end
-end
diff --git a/lib/networkx/operators/binary.rb b/lib/networkx/operators/binary.rb
deleted file mode 100644
index e4996f4..0000000
--- a/lib/networkx/operators/binary.rb
+++ /dev/null
@@ -1,233 +0,0 @@
-module NetworkX
- # Returns the edges of the graph in an array
- def self.get_edges(graph)
- edges = []
- if graph.is_a?(MultiGraph)
- graph.adj.each do |u, v_keys|
- v_keys.each do |v, key_attrs|
- next if u > v
-
- key_attrs.each do |_key, attributes|
- edges << [u, v, attributes]
- end
- end
- end
- else
- graph.adj.each do |u, u_attrs|
- u_attrs.each do |v, uv_attrs|
- edges << [u, v, uv_attrs]
- end
- end
- end
- edges
- end
-
- # Transforms the labels of the nodes of the graphs
- # so that they are disjoint.
- def self.convert_to_distinct_labels(graph, starting_int = -1)
- new_graph = graph.class.new
-
- idx_dict = graph.nodes(data: true).keys.to_h do |v|
- starting_int += 1
- [v, starting_int]
- end
-
- graph.nodes(data: true).each do |u, attrs|
- new_graph.add_node(u.to_s + idx_dict[u].to_s, **attrs)
- end
-
- graph.adj.each do |u, u_edges|
- u_edges.each do |v, uv_attrs|
- if graph.multigraph?
- uv_attrs.each do |_k, attrs|
- new_graph.add_edge(u.to_s + idx_dict[u].to_s, v.to_s + idx_dict[v].to_s, **attrs)
- end
- else
- new_graph.add_edge(u.to_s + idx_dict[u].to_s, v.to_s + idx_dict[v].to_s, **uv_attrs)
- end
- end
- end
- new_graph
- end
-
- # Performs the intersection of two graphs
- #
- # @param g1 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
- # @param g2 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
- #
- # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] the intersection of the two graphs
- def self.intersection(g1, g2)
- result = g1.class.new
-
- raise ArgumentError, 'Arguments must be both Graphs or MultiGraphs!' unless g1.multigraph? == g2.multigraph?
-
- unless (g1.nodes(data: true).keys - g2.nodes(data: true).keys).empty?
- raise ArgumentError, 'Node sets must be equal!'
- end
-
- g1.nodes(data: true).each { |u, attrs| result.add_node(u, **attrs) }
-
- g1, g2 = g2, g1 if g1.number_of_edges > g2.number_of_edges
- g1.adj.each do |u, u_edges|
- u_edges.each do |v, uv_attrs|
- if g1.multigraph?
- next if u > v && g1.instance_of?(MultiGraph)
-
- uv_attrs.each do |k, attrs|
- result.add_edge(u, v, **attrs) if g2.edge?(u, v, k)
- end
- elsif g2.edge?(u, v)
- result.add_edge(u, v, **uv_attrs)
- end
- end
- end
- result
- end
-
- # Performs the difference of two graphs
- #
- # @param g1 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
- # @param g2 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
- #
- # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] the difference of the two graphs
- def self.difference(g1, g2)
- result = g1.class.new
-
- raise ArgumentError, 'Arguments must be both Graphs or MultiGraphs!' unless g1.multigraph? == g2.multigraph?
-
- unless (g1.nodes(data: true).keys - g2.nodes(data: true).keys).empty?
- raise ArgumentError, 'Node sets must be equal!'
- end
-
- g1.nodes(data: true).each { |u, attrs| result.add_node(u, **attrs) }
-
- g1.adj.each do |u, u_edges|
- u_edges.each do |v, uv_attrs|
- if g1.multigraph?
- next if u > v && g1.instance_of?(MultiGraph)
-
- uv_attrs.each do |k, attrs|
- result.add_edge(u, v, **attrs) unless g2.edge?(u, v, k)
- end
- else
- result.add_edge(u, v, **uv_attrs) unless g2.edge?(u, v)
- end
- end
- end
- result
- end
-
- # Performs the symmetric difference of two graphs
- #
- # @param g1 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
- # @param g2 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
- #
- # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] the symmetric difference of the two graphs
- def self.symmetric_difference(g1, g2)
- result = g1.class.new
-
- raise ArgumentError, 'Arguments must be both Graphs or MultiGraphs!' unless g1.multigraph? == g2.multigraph?
-
- unless (g1.nodes(data: true).keys - g2.nodes(data: true).keys).empty?
- raise ArgumentError, 'Node sets must be equal!'
- end
-
- g1.nodes(data: true).each { |u, attrs| result.add_node(u, **attrs) }
-
- g1.adj.each do |u, u_edges|
- u_edges.each do |v, uv_attrs|
- if g1.multigraph?
- next if u > v && g1.instance_of?(MultiGraph)
-
- uv_attrs.each do |k, attrs|
- result.add_edge(u, v, **attrs) unless g2.edge?(u, v, k)
- end
- else
- result.add_edge(u, v, **uv_attrs) unless g2.edge?(u, v)
- end
- end
- end
-
- g2.adj.each do |u, u_edges|
- u_edges.each do |v, uv_attrs|
- next if u > v && g1.instance_of?(MultiGraph)
-
- if g2.multigraph?
- uv_attrs.each do |k, attrs|
- result.add_edge(u, v, **attrs) unless g1.edge?(u, v, k)
- end
- else
- result.add_edge(u, v, **uv_attrs) unless g1.edge?(u, v)
- end
- end
- end
- result
- end
-
- # Performs the composition of two graphs
- #
- # @param g1 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
- # @param g2 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
- #
- # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] the composition of the two graphs
- def self.compose(g1, g2)
- result = g1.class.new
-
- raise ArgumentError, 'Arguments must be both Graphs or MultiGraphs!' unless g1.multigraph? == g2.multigraph?
-
- result.add_nodes(g1.nodes(data: true).map { |u, attrs| [u, attrs] })
- result.add_nodes(g2.nodes(data: true).map { |u, attrs| [u, attrs] })
-
- if g1.multigraph?
- g1.adj.each { |u, e| e.each { |v, uv_edges| uv_edges.each_value { |attrs| result.add_edge(u, v, **attrs) } } }
- g2.adj.each { |u, e| e.each { |v, uv_edges| uv_edges.each_value { |attrs| result.add_edge(u, v, **attrs) } } }
- else
- g1.adj.each { |u, u_edges| u_edges.each { |v, attrs| result.add_edge(u, v, **attrs) } }
- g2.adj.each { |u, u_edges| u_edges.each { |v, attrs| result.add_edge(u, v, **attrs) } }
- end
- result
- end
-
- # Performs the union of two graphs
- #
- # @param g1 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
- # @param g2 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
- #
- # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] the union of the two graphs
- def self.union(g1, g2)
- raise ArgumentError, 'Arguments must be both Graphs or MultiGraphs!' unless g1.multigraph? == g2.multigraph?
-
- new_graph = g1.class.new
- new_graph.graph.merge!(g1.graph)
- new_graph.graph.merge!(g2.graph)
-
- unless (g1.nodes(data: true).keys & g2.nodes(data: true).keys).empty?
- raise ArgumentError, 'Graphs must be disjoint!'
- end
-
- g1_edges = get_edges(g1)
- g2_edges = get_edges(g2)
-
- new_graph.add_nodes(g1.nodes(data: true).keys)
- new_graph.add_edges(g1_edges)
- new_graph.add_nodes(g2.nodes(data: true).keys)
- new_graph.add_edges(g2_edges)
-
- new_graph
- end
-
- # Performs the disjoint union of two graphs
- #
- # @param g1 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
- # @param g2 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
- #
- # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] the disjoint union of the two graphs
- def self.disjoint_union(g1, g2)
- new_g1 = convert_to_distinct_labels(g1)
- new_g2 = convert_to_distinct_labels(g2)
- result = union(new_g1, new_g2)
- result.graph.merge!(g1.graph)
- result.graph.merge!(g2.graph)
- result
- end
-end
diff --git a/lib/networkx/operators/product.rb b/lib/networkx/operators/product.rb
deleted file mode 100644
index 89bfdb9..0000000
--- a/lib/networkx/operators/product.rb
+++ /dev/null
@@ -1,201 +0,0 @@
-module NetworkX
- # Returns the edges of the graph in an array
- def self.edges_in_array(graph)
- edge_array = []
- if graph.multigraph?
- graph.adj.each do |u, u_edges|
- u_edges.each do |v, uv_edges|
- uv_edges.each do |_k, attrs|
- edge_array << [u, v, attrs]
- end
- end
- end
- else
- graph.adj.each do |u, u_edges|
- u_edges.each do |v, attrs|
- edge_array << [u, v, attrs]
- end
- end
- end
- edge_array
- end
-
- # Returns the hash product of two hashes
- def self.hash_product(hash1, hash2)
- (hash1.keys | hash2.keys).to_h { |n| [n, [hash1[n], hash2[n]]] }
- end
-
- # Returns the node product of nodes of two graphs
- def self.node_product(g1, g2)
- n_product = []
- g1.nodes(data: true).each do |k1, attrs1|
- g2.nodes(data: true).each do |k2, attrs2|
- n_product << [[k1, k2], hash_product(attrs1, attrs2)]
- end
- end
- n_product
- end
-
- # Returns the product of directed edges with edges
- def self.directed_edges_cross_edges(g1, g2)
- result = []
- edges_in_array(g1).each do |u, v, c|
- edges_in_array(g2).each do |x, y, d|
- result << [[u, x], [v, y], hash_product(c, d)]
- end
- end
- result
- end
-
- # Returns the product of undirected edges with edges
- def self.undirected_edges_cross_edges(g1, g2)
- result = []
- edges_in_array(g1).each do |u, v, c|
- edges_in_array(g2).each do |x, y, d|
- result << [[v, x], [u, y], hash_product(c, d)]
- end
- end
- result
- end
-
- # Returns the product of edges with edges
- def self.edges_cross_nodes(g1, g2)
- result = []
- edges_in_array(g1).each do |u, v, d|
- g2.nodes(data: true).each_key do |x|
- result << [[u, x], [v, x], d]
- end
- end
- result
- end
-
- # Returns the product of directed nodes with edges
- def self.nodes_cross_edges(g1, g2)
- result = []
- g1.nodes(data: true).each_key do |x|
- edges_in_array(g2).each do |u, v, d|
- result << [[x, u], [x, v], d]
- end
- end
- result
- end
-
- # Returns the product of edges with pairs of nodes
- def self.edges_cross_nodes_and_nodes(g1, g2)
- result = []
- edges_in_array(g1).each do |u, v, d|
- g2.nodes(data: true).each_key do |x|
- g2.nodes(data: true).each_key do |y|
- result << [[u, x], [v, y], d]
- end
- end
- end
- result
- end
-
- # Initializes the product graph
- def self.init_product_graph(g1, g2)
- raise ArgumentError, 'Arguments must be both directed or undirected!' unless g1.directed? == g2.directed?
-
- g = if g1.multigraph? || g2.multigraph?
- NetworkX::MultiGraph.new
- else
- NetworkX::Graph.new
- end
- g = g.to_directed if g.directed?
- g
- end
-
- # Returns the tensor product of two graphs
- #
- # @param g1 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
- # @param g2 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
- #
- # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] the tensor product of the two graphs
- def self.tensor_product(g1, g2)
- g = init_product_graph(g1, g2)
- g.add_nodes(node_product(g1, g2))
- g.add_edges(directed_edges_cross_edges(g1, g2))
- g.add_edges(undirected_edges_cross_edges(g1, g2)) unless g.directed?
- g
- end
-
- # Returns the cartesian product of two graphs
- #
- # @param g1 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
- # @param g2 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
- #
- # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] the cartesian product of the two graphs
- def self.cartesian_product(g1, g2)
- g = init_product_graph(g1, g2)
- g.add_nodes(node_product(g1, g2))
- g.add_edges(edges_cross_nodes(g1, g2))
- g.add_edges(nodes_cross_edges(g1, g2))
- g
- end
-
- # Returns the lexicographic product of two graphs
- #
- # @param g1 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
- # @param g2 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
- #
- # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] the lexicographic product of the two graphs
- def self.lexicographic_product(g1, g2)
- g = init_product_graph(g1, g2)
- g.add_nodes(node_product(g1, g2))
- g.add_edges(edges_cross_nodes_and_nodes(g1, g2))
- g.add_edges(nodes_cross_edges(g1, g2))
- g
- end
-
- # Returns the strong product of two graphs
- #
- # @param g1 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
- # @param g2 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
- #
- # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] the strong product of the two graphs
- def self.strong_product(g1, g2)
- g = init_product_graph(g1, g2)
- g.add_nodes(node_product(g1, g2))
- g.add_edges(nodes_cross_edges(g1, g2))
- g.add_edges(edges_cross_nodes(g1, g2))
- g.add_edges(directed_edges_cross_edges(g1, g2))
- g.add_edges(undirected_edges_cross_edges(g1, g2)) unless g.directed?
- g
- end
-
- # Returns the specified power of the graph
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
- # @param pow [Numeric] the power to which to raise the graph to
- #
- # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] the power of the graph
- def self.power(graph, pow)
- raise ArgumentError, 'Power must be a positive quantity!' if pow <= 0
-
- result = NetworkX::Graph.new
- result.add_nodes(graph.nodes(data: true).map { |n, attrs| [n, attrs] })
- graph.nodes(data: true).each do |n, _attrs|
- seen = {}
- level = 1
- next_level = graph.adj[n]
- until next_level.empty?
- this_level = next_level
- next_level = {}
- this_level.each do |v, _attrs|
- next if v == n
-
- unless seen.has_key?(v)
- seen[v] = level
- next_level.merge!(graph.adj[v])
- end
- end
- break if pow <= level
-
- level += 1
- end
- result.add_edges(seen.map { |v, _| [n, v] })
- end
- result
- end
-end
diff --git a/lib/networkx/operators/unary.rb b/lib/networkx/operators/unary.rb
deleted file mode 100644
index a0fe098..0000000
--- a/lib/networkx/operators/unary.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-module NetworkX
- # Performs the complement operation on the graph
- #
- # @param [Graph, DiGraph, MultiGraph, MultiDiGraph] graph
- #
- # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] the complement of the graph
- def self.complement(graph)
- result = Marshal.load(Marshal.dump(graph))
- result.clear
-
- result.add_nodes(graph.nodes(data: true).map { |u, attrs| [u, attrs] })
- graph.adj.each do |u, u_edges|
- graph.nodes(data: true).each { |v, attrs| result.add_edge(u, v, **attrs) if !u_edges.has_key?(v) && u != v }
- end
- result
- end
-end
diff --git a/lib/networkx/others/bridges.rb b/lib/networkx/others/bridges.rb
deleted file mode 100644
index c616c59..0000000
--- a/lib/networkx/others/bridges.rb
+++ /dev/null
@@ -1,30 +0,0 @@
-require_relative '../auxillary_functions/union_find'
-
-module NetworkX
- # @return [[Object, Object]] bridges
- #
- # @param graph [Graph] Graph
- def self.bridges(graph)
- each_bridge(graph).to_a
- end
-
- # @param graph [Graph] Graph
- def self.each_bridge(graph)
- return enum_for(:each_bridge, graph) unless block_given?
-
- graph.each_edge.with_index do |(s_i, t_i), i|
- uf = UnionFind.new(1..graph.number_of_nodes)
- graph.each_edge.with_index do |(s_j, t_j), j|
- uf.unite(s_j, t_j) if i != j
- end
- yield [s_i, t_i] unless uf.same?(s_i, t_i)
- end
- end
-
- # @return [Integer] the number of bridges
- #
- # @param graph [Graph] Graph
- def self.number_of_bridges(graph)
- bridges(graph).size
- end
-end
diff --git a/lib/networkx/others/generators.rb b/lib/networkx/others/generators.rb
deleted file mode 100644
index d15991b..0000000
--- a/lib/networkx/others/generators.rb
+++ /dev/null
@@ -1,237 +0,0 @@
-require_relative '../../networkx'
-
-module NetworkX
- class Graph
- # private class method
- def self.complete_edges(n)
- n = (0...n) if n.is_a?(Integer)
-
- edges = []
- n.each do |i|
- n.each do |j|
- edges << [i, j] if i < j
- end
- end
- edges
- end
-
- def self.balanced_tree(r, h)
- edges = []
- q = [0]
- i = 0
- h.times do
- t = q.dup
- q.clear
- t.each do |v|
- r.times do
- i += 1
- edges << [v, i]
- q << i
- end
- end
- end
- graph = new(name: "balanced_tree(#{r}, #{h})")
- graph.add_edges(edges)
- graph
- end
-
- def self.barbell_graph(m1, m2)
- edges = complete_edges(m1)
- edges.concat((m1..m2 + m1).map { |k| [k - 1, k] })
- edges.concat complete_edges(m1 + m2...m1 + m2 + m1)
-
- graph = new(name: "barbell_graph(#{m1}, #{m2})")
- graph.add_edges(edges)
- graph
- end
-
- def self.complete_graph(n)
- n = (0...n) if n.is_a?(Integer)
-
- edges = []
- n.each do |i|
- n.each do |j|
- edges << [i, j] if i < j
- end
- end
-
- graph = new(name: "complete_graph(#{n})")
- graph.add_edges(edges)
- graph
- end
-
- def self.circular_ladder_graph(n)
- edges = (0...n - 1).map { |v| [v, v + 1] }
- edges << [n - 1, 0]
- edges.concat((n...2 * n - 1).map { |v| [v, v + 1] })
- edges << [2 * n - 1, n]
- edges.concat((0...n).map { |v| [v, v + n] })
-
- graph = new(name: "circular_ladder_graph(#{n})")
- graph.add_edges(edges)
- graph
- end
-
- def self.cycle_graph(n)
- edges = (0...n - 1).map { |v| [v, v + 1] }
- edges << [n - 1, 0]
-
- graph = new(name: "cycle_graph(#{n})")
- graph.add_edges(edges)
- graph
- end
-
- def self.empty_graph(number_of_nodes)
- empty_graph = new(name: "empty_graph#{number_of_nodes}")
- empty_graph.add_nodes_from(0...number_of_nodes)
- empty_graph
- end
-
- def self.ladder_graph(n)
- edges = (0...n - 1).map { |k| [k, k + 1] }
- edges.concat((n...2 * n - 1).map { |k| [k, k + 1] })
- edges.concat((0...n).map { |k| [k, k + n] })
-
- graph = new(name: "ladder_graph(#{n})")
- graph.add_edges(edges)
- graph
- end
-
- def self.lollipop_graph(m, n)
- edges = complete_edges(m)
- edges.concat((m - 1...m - 1 + n).map { |v| [v, v + 1] })
-
- graph = new(name: "lollipop_graph(#{m}, #{n})")
- graph.add_edges(edges)
- graph
- end
-
- def self.null_graph
- new(name: 'null_graph')
- end
-
- def self.path_graph(n)
- edges = (0...n - 1).map { |v| [v, v + 1] }
-
- graph = new(name: "path_graph(#{n})")
- graph.add_edges(edges)
- graph
- end
-
- def self.star_graph(n)
- edges = (1..n).map { |i| [0, i] }
-
- graph = new(name: "star_graph(#{n})")
- graph.add_edges(edges)
- graph
- end
-
- def self.trivial_graph
- trivial_graph = new(name: 'trivial_grpph')
- trivial_graph.add_node(0)
- trivial_graph
- end
-
- def self.wheel_graph(n)
- edges = (1..n - 1).map { |i| [0, i] }
- edges.concat((1...n - 1).map { |i| [i, i + 1] })
- edges << [1, n - 1]
-
- graph = new(name: "wheel_graph(#{n})")
- graph.add_edges(edges)
- graph
- end
-
- def self.bull_graph
- edges = [[0, 1], [1, 2], [2, 0], [1, 3], [2, 4]]
- graph = new(name: 'bull_graph')
- graph.add_edges(edges)
- graph
- end
-
- def self.cubical_graph
- graph = circular_ladder_graph(4)
- graph.graph[:name] = 'cubical_graph'
- graph
- end
-
- def self.diamond_graph
- edges = [[0, 1], [0, 2], [1, 2], [1, 3], [2, 3]]
- graph = new(name: 'diamond_graph')
- graph.add_edges(edges)
- graph
- end
-
- # 12
- def self.dodecahedral_graph
- edges = (0...19).map { |k| [k, k + 1] }
- edges.concat [[0, 19], [0, 10], [1, 8], [2, 6], [3, 19], [4, 17], [5, 15], [7, 14], [9, 13], [11, 18], [12, 16]]
- graph = new(name: 'dodecahedral_graph')
- graph.add_edges(edges)
- graph
- end
-
- def self.heawood_graph
- edges = (0...13).map { |k| [k, k + 1] }
- edges << [13, 0]
- edges.concat [[0, 5], [1, 10], [2, 7], [3, 12], [4, 9], [6, 11], [8, 13]]
- graph = new(name: 'heawood_graph')
- graph.add_edges(edges)
- graph
- end
-
- def self.house_graph
- edges = [[0, 1], [0, 2], [1, 3], [2, 3], [2, 4], [3, 4]]
- graph = new(name: 'house_graph')
- graph.add_edges(edges)
- graph
- end
-
- def self.house_x_graph
- edges = (0...4).map { |k| [k, k + 1] }
- edges.concat [[0, 2], [0, 3], [1, 3], [2, 4], [3, 4]]
- graph = new(name: 'house_x_graph')
- graph.add_edges(edges)
- graph
- end
-
- def self.moebius_kantor_graph
- edges = (0...15).map { |k| [k, k + 1] }
- edges << [15, 0]
- edges.concat [[0, 5], [1, 12], [2, 7], [4, 9], [3, 14], [6, 11], [8, 13], [10, 15]]
- graph = new(name: 'moebius_kantor_graph')
- graph.add_edges(edges)
- graph
- end
-
- # 8: 6 nodes, 12 edges
- def self.octahedral_graph
- edges = []
- 6.times do |i|
- 6.times do |j|
- edges << [i, j] if i != j && i + j != 5
- end
- end
- graph = new(name: 'octahedral_graph')
- graph.add_edges(edges)
- graph
- end
-
- def self.tetrahedral_graph
- graph = complete_graph(4)
- graph.graph[:name] = 'tetrahedral_graph'
- graph
- end
-
- # Experimental For debug.
- #
- # @return data for https://hello-world-494ec.firebaseapp.com/
- def put_graph_x2
- output = <<~"OUTPUT"
- #{number_of_nodes} #{number_of_edges}
- #{edges.map { |edge| edge.join(' ') }.join("\n")}
- OUTPUT
- puts output
- end
- end
-end
diff --git a/lib/networkx/others/grid_2d_graph.rb b/lib/networkx/others/grid_2d_graph.rb
deleted file mode 100644
index 292d98f..0000000
--- a/lib/networkx/others/grid_2d_graph.rb
+++ /dev/null
@@ -1,38 +0,0 @@
-require_relative '../graph'
-
-class Array
- include Comparable
-end
-
-# Reference: https://networkx.org/documentation/stable/_modules/networkx/generators/lattice.html#grid_2d_graph
-module NetworkX
- # @param m [Integer] the number of rows
- # @param n [Integer] the number of columns
- # @param create_using [Class] graph class. this is optional. default is `NetworkX::Graph`.
- def self.grid_2d_graph(m, n, periodic: false, create_using: NetworkX::Graph)
- warn('sorry, periodic is not done yet') if periodic
-
- m.is_a?(Integer) or raise(ArgumentError, "[NetworkX] argument m: Integer, not #{m.class}")
- n.is_a?(Integer) or raise(ArgumentError, "[NetworkX] argument n: Integer, not #{n.class}")
- create_using.is_a?(Class) \
- or raise(ArgumentError, "[NetworkX] argument create_using: `Graph` class or children, not #{create_using.class}")
-
- g = create_using.new
-
- a = []
- m.times { |i| n.times { |j| a << [i, j] } }
- g.add_nodes_from(a)
-
- e1 = []
- (m - 1).times { |i| n.times { |j| e1 << [[i, j], [i + 1, j]] } }
- g.add_edges_from(e1)
-
- e2 = []
- m.times { |i| (n - 1).times { |j| e2 << [[i, j], [i, j + 1]] } }
- g.add_edges_from(e2)
-
- g.add_edges_from(g.edges.map { |i, j| [j, i] }) if g.directed?
-
- g
- end
-end
diff --git a/lib/networkx/others/info.rb b/lib/networkx/others/info.rb
deleted file mode 100644
index babfb1c..0000000
--- a/lib/networkx/others/info.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-require_relative '../graph'
-
-module NetworkX
- def self.info(graph)
- info = ''
- info << "Type: #{graph.class}\n"
- info << "Number of nodes: #{graph.number_of_nodes}\n"
- info << "Number of edges: #{graph.number_of_edges}\n"
- info
- end
-end
diff --git a/lib/networkx/others/number_connected_components.rb b/lib/networkx/others/number_connected_components.rb
deleted file mode 100644
index c03ce98..0000000
--- a/lib/networkx/others/number_connected_components.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-require_relative '../graph'
-require_relative '../auxillary_functions/union_find'
-
-module NetworkX
- # @param [NetworkX::Graph] graph
- #
- # @return [Integer] the number of connected components on graph
- def self.number_connected_components(graph)
- uf = NetworkX::UnionFind.new(graph.nodes(data: false))
- graph.each_edge { |x, y| uf.unite(x, y) }
- uf.groups.size
- end
-
- class << self
- alias number_of_connected_components number_connected_components
- end
-end
diff --git a/lib/networkx/others/reads.rb b/lib/networkx/others/reads.rb
deleted file mode 100644
index 1b128bb..0000000
--- a/lib/networkx/others/reads.rb
+++ /dev/null
@@ -1,52 +0,0 @@
-require_relative '../../networkx'
-
-module NetworkX
- class Graph
- class << self
- def read_edgelist(path, comment: '#', delimiter: nil)
- edges = File.readlines(path).filter_map do |line|
- line.sub!(/#{comment}.+/, '')
- line.strip.split(delimiter) if line.strip.size > 0
- end
-
- edges.each{|edge| edge.map!{|node| NetworkX.to_number_if_possible(node) } }
-
- graph = new
- graph.add_edges(edges)
- graph
- end
- alias read_edges read_edgelist
-
- def read_weighted_edgelist(path, comment: '#', delimiter: nil)
- edges = File.readlines(path).filter_map do |line|
- line.sub!(/#{comment}.+/, '')
- line.strip.split(delimiter) if line.strip.size > 0
- end
-
- edges.map! do |x, y, weight|
- [
- NetworkX.to_number_if_possible(x),
- NetworkX.to_number_if_possible(y),
- {weight: NetworkX.to_number_if_possible(weight)}
- ]
- end
-
- graph = new
- graph.add_edges(edges)
- graph
- end
- alias read_weighted_edges read_weighted_edgelist
- end
- end
-
- def self.to_number_if_possible(str)
- case str
- when /^[+-]?[0-9]+$/
- str.to_i
- when /^([+-]?\d*\.\d*)|(\d*[eE][+-]?\d+)$/
- str.to_f
- else
- str
- end
- end
-end
diff --git a/lib/networkx/shortest_path/astar.rb b/lib/networkx/shortest_path/astar.rb
deleted file mode 100644
index 24305a1..0000000
--- a/lib/networkx/shortest_path/astar.rb
+++ /dev/null
@@ -1,73 +0,0 @@
-module NetworkX
- # Returns path using astar algorithm between source and target
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param source [Object] a node to start astar from
- # @param target [Object] a node to end astar
- # @param heuristic [] a lambda to compute heuristic b/w two nodes
- #
- # @return [Array] an array of nodes forming a path between source
- # and target
- def self.astar_path(graph, source, target, heuristic = nil)
- warn 'A* is not implemented for MultiGraph and MultiDiGraph' if graph.is_a?(MultiGraph) || graph.is_a?(MultiDiGraph)
-
- raise ArgumentError, 'Either source or target is not in graph' unless graph.node?(source) && graph.node?(target)
-
- count = ->(i) { i + 1 }
- i = -1
- heuristic ||= (->(_u, _v) { 0 })
- heap = Heap.new { |x, y| x[0] < y[0] || (x[0] == y[0] && x[1] < y[1]) }
- heap << [0, count.call(i), source, 0, nil]
- enqueued, explored = {}, {}
-
- until heap.empty?
- _, _, curnode, dist, parent = heap.pop
- if curnode == target
- path = [curnode]
- node = parent
- until node.nil?
- path << node
- node = explored[node]
- end
- path.reverse
- return path
- end
-
- next if explored.has_key?(curnode)
-
- explored[curnode] = parent
-
- graph.adj[curnode].each do |u, attrs|
- next if explored.has_key?(u)
-
- ncost = dist + (attrs[:weight] || 1)
- if enqueued.has_key?(u)
- qcost, = enqueued[u]
- next if qcost <= ncost
- else
- h = heuristic.call(u, target)
- enqueued[u] = ncost, h
- heap << [ncost + h, count.call(i), u, ncost, curnode]
- end
- end
- end
- raise ArgumentError, 'Target not reachable!'
- end
-
- # Returns astar path length b/w source and target
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param source [Object] a node to start astar from
- # @param target [Object] a node to end astar
- # @param heuristic [] a lambda to compute heuristic b/w two nodes
- #
- # @return [Numeric] the length of the path
- def self.astar_path_length(graph, source, target, heuristic = nil)
- raise ArgumentError, 'Either source or target is not in graph' unless graph.node?(source) && graph.node?(target)
-
- path = astar_path(graph, source, target, heuristic)
- path_length = 0
- (1..(path.length - 1)).each { |i| path_length += (graph.adj[path[i - 1]][path[i]][:weight] || 1) }
- path_length
- end
-end
diff --git a/lib/networkx/shortest_path/dense.rb b/lib/networkx/shortest_path/dense.rb
deleted file mode 100644
index 5af37cf..0000000
--- a/lib/networkx/shortest_path/dense.rb
+++ /dev/null
@@ -1,29 +0,0 @@
-module NetworkX
- # Returns the all pair distance between all the nodes
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- #
- # @return [Hash{ Object => { Object => { Numeric }}}] a hash containing distances
- # b/w all pairs of nodes
- def self.floyd_warshall(graph)
- a, index = to_matrix(graph, Float::INFINITY, 'min')
- nodelen = graph.nodes(data: true).length
- (0..(nodelen - 1)).each { |i| a[i, i] = 0 }
- (0..(nodelen - 1)).each do |k|
- (0..(nodelen - 1)).each do |i|
- (0..(nodelen - 1)).each do |j|
- a[i, j] = [a[i, j], a[i, k] + a[k, j]].min
- end
- end
- end
-
- as_hash = {}
- (0..(nodelen - 1)).each do |i|
- (0..(nodelen - 1)).each do |j|
- as_hash[index[i]] = {} unless as_hash.has_key?(index[i])
- as_hash[index[i]][index[j]] = a[i, j]
- end
- end
- as_hash
- end
-end
diff --git a/lib/networkx/shortest_path/unweighted.rb b/lib/networkx/shortest_path/unweighted.rb
deleted file mode 100644
index 11c14a8..0000000
--- a/lib/networkx/shortest_path/unweighted.rb
+++ /dev/null
@@ -1,136 +0,0 @@
-module NetworkX
- # Helper function for single source shortest path length
- def self.help_single_shortest_path_length(adj, firstlevel, cutoff)
- Enumerator.new do |e|
- seen = {}
- level = 0
- nextlevel = firstlevel
-
- while !nextlevel.empty? && cutoff >= level
- thislevel = nextlevel
- nextlevel = {}
- thislevel.each do |u, _attrs|
- next if seen.has_key?(u)
-
- seen[u] = level
- nextlevel.merge!(adj[u])
- e.yield [u, level]
- end
- level += 1
- end
- seen.clear
- end
- end
-
- # Computes shortest path values to all nodes from a given node
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param source [Object] source to compute path length from
- # @param cutoff [Numeric, nil] cutoff for the shortest path algorithm
- #
- # @return [Array] path lengths for all nodes
- def self.single_source_shortest_path_length(graph, source, cutoff = nil)
- raise ArgumentError, 'Source not found in the Graph!' unless graph.node?(source)
-
- cutoff = Float::INFINITY if cutoff.nil?
- nextlevel = {source => 1}
- help_single_shortest_path_length(graph.adj, nextlevel, cutoff).take(graph.nodes(data: true).length)
- end
-
- # Computes shortest path values to all nodes from all nodes
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param cutoff [Numeric, nil] cutoff for the shortest path algorithm
- #
- # @return [Array>] path lengths for all nodes from all nodes
- def self.all_pairs_shortest_path_length(graph, cutoff = nil)
- shortest_paths = []
- graph.nodes(data: true).each_key { |n| shortest_paths << [n, single_source_shortest_path_length(graph, n, cutoff)] }
- shortest_paths
- end
-
- # Helper function for finding single source shortest path
- def self.help_single_shortest_path(adj, firstlevel, paths, cutoff)
- level = 0
- nextlevel = firstlevel
- while !nextlevel.empty? && cutoff > level
- thislevel = nextlevel
- nextlevel = {}
- thislevel.each_key do |u|
- adj[u].each_key do |v|
- unless paths.has_key?(v)
- paths[v] = paths[u] + [v]
- nextlevel[v] = 1
- end
- end
- end
- level += 1
- end
- paths
- end
-
- # Computes single source shortest path from a node to every other node
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param source [Object] source from which shortest paths are needed
- # @param cutoff [Numeric, nil] cutoff for the shortest path algorithm
- #
- # @return [Array>>] path lengths for all nodes from all nodes
- def self.single_source_shortest_path(graph, source, cutoff = nil)
- raise ArgumentError, 'Source not found in the Graph!' unless graph.node?(source)
-
- cutoff = Float::INFINITY if cutoff.nil?
- nextlevel = {source => 1}
- paths = {source => [source]}
- help_single_shortest_path(graph.adj, nextlevel, paths, cutoff)
- end
-
- # Computes shortest paths to all nodes from all nodes
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param cutoff [Numeric, nil] cutoff for the shortest path algorithm
- #
- # @return [Array Array }>] paths for all nodes from all nodes
- def self.all_pairs_shortest_path(graph, cutoff = nil)
- shortest_paths = []
- graph.nodes(data: true).each_key { |n| shortest_paths << [n, single_source_shortest_path(graph, n, cutoff)] }
- shortest_paths
- end
-
- # Computes shortest paths to all nodes from all nodes
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param source [Object] source for which predecessors are needed
- # @param cutoff [Numeric, nil] cutoff for finding predecessor
- # @param return_seen [Boolean] if true, returns seen dict
- #
- # @return [Array Array }, Hash{ Object => Numeric }>,
- # Hash{ Object => Array }]
- # predecessors of a given node and/or seen dict
- def self.predecessor(graph, source, cutoff = nil, return_seen = false)
- raise ArgumentError, 'Source not found in the Graph!' unless graph.node?(source)
-
- level = 0
- nextlevel = [source]
- seen = {source => level}
- pred = {source => []}
- until nextlevel.empty?
- level += 1
- thislevel = nextlevel
- nextlevel = []
- thislevel.each do |u|
- graph.adj[u].each_key do |v|
- if !seen.has_key?(v)
- pred[v] = [u]
- seen[v] = level
- nextlevel << v
- elsif seen[v] == level
- pred[v] << u
- end
- end
- end
- break if cutoff.nil? && cutoff <= level
- end
- return_seen ? [pred, seen] : pred
- end
-end
diff --git a/lib/networkx/shortest_path/weighted.rb b/lib/networkx/shortest_path/weighted.rb
deleted file mode 100644
index fe42680..0000000
--- a/lib/networkx/shortest_path/weighted.rb
+++ /dev/null
@@ -1,417 +0,0 @@
-module NetworkX
- # Helper function to extract weight from a adjecency hash
- def self.get_weight(graph)
- lambda do |_, _, attrs|
- return attrs[:weight] || 1 unless graph.multigraph?
-
- attrs.group_by { |_k, vals| vals[:weight] || 1 }.keys.max
- end
- end
-
- # Helper function for multisource dijkstra
- def self.help_multisource_dijkstra(graph, sources, weight, pred = nil, paths = nil, cutoff = nil, target = nil)
- count = ->(i) { i + 1 }
- i = -1
- dist = {}
- seen = {}
- fringe = Heap.new { |x, y| x[0] < y[0] || (x[0] == y[0] && x[1] < y[1]) }
- sources.each do |s|
- seen[s] = 0
- fringe << [0, count.call(i), s]
- end
-
- until fringe.empty?
- d, _, v = fringe.pop
- next if dist.has_key?(v)
-
- dist[v] = d
- break if v == target
-
- graph.adj[v].each do |u, attrs|
- cost = weight.call(v, u, attrs)
- next if cost.nil?
-
- vu_dist = dist[v] + cost
- next if !cutoff.nil? && vu_dist > cutoff
-
- if dist.has_key?(u)
- raise ValueError, 'Contradictory weights found!' if vu_dist < dist[u]
- elsif !seen.has_key?(u) || vu_dist < seen[u]
- seen[u] = vu_dist
- fringe << [vu_dist, count.call(i), u]
- paths[u] = paths[v] + [u] unless paths.nil?
- pred[u] = [v] unless pred.nil?
- elsif vu_dist == seen[u]
- pred[u] << v unless pred.nil?
- end
- end
- end
- dist
- end
-
- # Helper function for single source dijkstra
- def self.help_dijkstra(graph, source, weight, pred = nil, paths = nil, cutoff = nil, target = nil)
- help_multisource_dijkstra(graph, [source], weight, pred, paths, cutoff, target)
- end
-
- # Computes shortest paths and path lengths to a target from one of the nodes
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param sources [Array] Array of sources
- # @param target [Object, nil] target node for the dijkstra algorithm
- # @param cutoff [Numeric, nil] cutoff for the dijkstra algorithm
- #
- # @return [Numeric, Array] path lengths for all nodes
- def self.multisource_dijkstra(graph, sources, target = nil, cutoff = nil)
- raise ValueError, 'Sources cannot be empty' if sources.empty?
- return [0, [target]] if sources.include?(target)
-
- paths = {}
- weight = get_weight(graph)
- sources.each { |source| paths[source] = [source] }
- dist = help_multisource_dijkstra(graph, sources, weight, nil, paths, cutoff, target)
- return [dist, paths] if target.nil?
- raise KeyError, "No path to #{target}!" unless dist.has_key?(target)
-
- [dist[target], paths[target]]
- end
-
- # Computes shortest path lengths to any from the given nodes
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param sources [Array] Array of sources
- # @param cutoff [Numeric, nil] cutoff for the dijkstra algorithm
- #
- # @return [Hash{ Object => Numeric }] path lengths for any nodes from given nodes
- def self.multisource_dijkstra_path_length(graph, sources, cutoff = nil)
- raise ValueError, 'Sources cannot be empty' if sources.empty?
-
- weight = get_weight(graph)
- help_multisource_dijkstra(graph, sources, weight, nil, nil, cutoff)
- end
-
- # Computes shortest paths to any from the given nodes
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param sources [Array] Array of sources
- # @param cutoff [Numeric, nil] cutoff for the dijkstra algorithm
- #
- # @return [Hash{ Object => Array }] paths for any nodes from given nodes
- def self.multisource_dijkstra_path(graph, sources, cutoff = nil)
- _, path = multisource_dijkstra(graph, sources, nil, cutoff)
- path
- end
-
- # Computes shortest paths and path distances to all nodes/target from the given node
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param source [Object] source
- # @param target [Object] target
- # @param cutoff [Numeric, nil] cutoff for the dijkstra algorithm
- #
- # @return [Hash{ Object => Array }, Array] paths for all nodes/target node from given node
- def self.singlesource_dijkstra(graph, source, target = nil, cutoff = nil)
- multisource_dijkstra(graph, [source], target, cutoff)
- end
-
- # Computes shortest path lengths to all nodes from the given node
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param source [Object] source
- # @param cutoff [Numeric, nil] cutoff for the dijkstra algorithm
- #
- # @return [Hash{ Object => Numeric }] path lengths for all nodes from given node
- def self.singlesource_dijkstra_path_length(graph, source, cutoff = nil)
- multisource_dijkstra_path_length(graph, [source], cutoff)
- end
-
- # Computes shortest paths to all nodes from the given node
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param source [Object] source
- # @param cutoff [Numeric, nil] cutoff for the dijkstra algorithm
- #
- # @return [Hash{ Object => Array }] paths for all nodes from given node
- def self.singlesource_dijkstra_path(graph, source, cutoff = nil)
- multisource_dijkstra_path(graph, [source], cutoff)
- end
-
- # Computes shortest path length to target from the given node
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param source [Object] source
- # @param target [Object] target
- #
- # @return [Numeric] path length for target node from given node
- def self.dijkstra_path_length(graph, source, target)
- return 0 if source == target
-
- weight = get_weight(graph)
- length = help_dijkstra(graph, source, weight, nil, nil, nil, target)
- raise KeyError, 'Node not reachable!' unless length.has_key?(target)
-
- length[target]
- end
-
- # Computes shortest path to target from the given node
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param source [Object] source
- # @param target [Object] target
- #
- # @return [Numeric] path for target node from given node
- def self.dijkstra_path(graph, source, target)
- _, path = singlesource_dijkstra(graph, source, target)
- path
- end
-
- # Computes weighted shortest path length and predecessors
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param source [Object] source
- # @param cutoff [Numeric, nil] cutoff for the dijkstra algorithm
- #
- # @return [ Array }, Hash{ Object => Numeric }>]
- # predcessor hash and distance hash
- def self.dijkstra_predecessor_distance(graph, source, cutoff = nil)
- weight = get_weight(graph)
- pred = {source => []}
- [pred, help_dijkstra(graph, source, weight, pred, nil, cutoff)]
- end
-
- # Finds shortest weighted paths and lengths between all nodes
- #
- # @param graph [Graph, DiGrhelp_dijkaph, MultiGraph, MultiDiGraph] a graph
- # @param cutoff [Numeric, nil] cutoff for the dijkstra algorithm
- #
- # @return [Array Numeric }, Hash{ Object => Array }>>]
- # paths and path lengths between all nodes
- def self.all_pairs_dijkstra(graph, cutoff = nil)
- path = []
- graph.nodes(data: true).each_key { |n| path << [n, singlesource_dijkstra(graph, n, nil, cutoff)] }
- path
- end
-
- # Finds shortest weighted path length between all nodes
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param cutoff [Numeric, nil] cutoff for the dijkstra algorithm
- #
- # @return [Array Numeric }>] path lengths between all nodes
- def self.all_pairs_dijkstra_path_length(graph, cutoff = nil)
- path_lengths = []
- graph.nodes(data: true).each_key { |n| path_lengths << [n, singlesource_dijkstra_path_length(graph, n, cutoff)] }
- path_lengths
- end
-
- # Finds shortest weighted paths between all nodes
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param cutoff [Numeric, nil] cutoff for the dijkstra algorithm
- #
- # @return [Array Array }>] path lengths between all nodes
- def self.all_pairs_dijkstra_path(graph, cutoff = nil)
- paths = []
- graph.nodes(data: true).each_key { |n| paths << singlesource_dijkstra_path(graph, n, cutoff) }
- paths
- end
-
- # Helper function for bellman ford
- def self.help_bellman_ford(graph, sources, weight, pred = nil, paths = nil, dist = nil, cutoff = nil, target = nil)
- pred = sources.product([[]]).to_h if pred.nil?
- dist = sources.product([0]).to_h if dist.nil?
-
- inf, n, count, q, in_q = Float::INFINITY, graph.nodes(data: true).length, {}, sources.clone, Set.new(sources)
- until q.empty?
- u = q.shift
- in_q.delete(u)
- skip = false
- pred[u].each { |k| skip = true if in_q.include?(k) }
- next if skip
-
- dist_u = dist[u]
- graph.adj[u].each do |v, e|
- dist_v = dist_u + weight.call(u, v, e)
- next if !cutoff.nil? && dist_v > cutoff
- next if !target.nil? && dist_v > (dist[target] || inf)
-
- if dist_v < (dist[v] || inf)
- unless in_q.include?(v)
- q << v
- in_q.add(v)
- count_v = (count[v] || 0) + 1
- raise ArgumentError, 'Negative edge cycle detected!' if count_v == n
-
- count[v] = count_v
- end
- dist[v] = dist_v
- pred[v] = [u]
- elsif dist.has_key?(v) && dist_v == dist[v]
- pred[v] << u
- end
- end
- end
- unless paths.nil?
- dsts = pred
- dsts.each_key do |dst|
- path, cur = [dst], dst
- until pred[cur][0].nil?
- cur = pred[cur][0]
- path << cur
- end
- path.reverse
- paths[dst] = path
- end
- end
- dist
- end
-
- # Finds shortest weighted path lengths and predecessors on shortest paths
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param source [Object] source
- # @param target [Object, nil] target
- # @param cutoff [Numeric, nil] cutoff for the dijkstra algorithm
- #
- # @return [Array Array }, Hash{ Object => Numeric }>] predecessors and distances
- def self.bellmanford_predecesor_distance(graph, source, target = nil, cutoff = nil)
- raise ArgumentError, 'Node not found!' unless graph.node?(source)
-
- weight = get_weight(graph)
- # TODO: Detection of selfloop edges
- dist = {source => 0}
- pred = {source => []}
- return [pred, dist] if graph.nodes(data: true).length == 1
-
- dist = help_bellman_ford(graph, [source], weight, pred, nil, dist, cutoff, target)
- [pred, dist]
- end
-
- def self.singlesource_bellmanford(graph, source, target = nil, cutoff = nil)
- return [0, [source]] if source == target
-
- weight = get_weight(graph)
- paths = {source => [source]}
- dist = help_bellman_ford(graph, [source], weight, nil, paths, nil, cutoff, target)
- return [dist, paths] if target.nil?
- raise ArgumentError, 'Node not reachable!' unless dist.has_key?(target)
-
- [dist[target], paths[target]]
- end
-
- # Length of shortest path from source to target using Bellman Ford algorithm
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param source [Object] source
- # @param target [Object] target
- #
- # @return [Numeric] distance between source and target
- def self.bellmanford_path_length(graph, source, target)
- return 0 if source == target
-
- weight = get_weight(graph)
- length = help_bellman_ford(graph, [source], weight, nil, nil, nil, nil, target)
- raise ArgumentError, 'Node not reachable!' unless length.has_key?(target)
-
- length[target]
- end
-
- # Shortest path from source to target using Bellman Ford algorithm
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param source [Object] source
- # @param target [Object] target
- #
- # @return [Array] path from source to target
- def self.bellmanford_path(graph, source, target)
- _, path = singlesource_bellmanford(graph, source, target)
- path
- end
-
- # Shortest path from source to all nodes using Bellman Ford algorithm
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param source [Object] source
- # @param cutoff [Numeric, nil] cutoff for Bellman Ford algorithm
- #
- # @return [Hash{ Object => Array }] path from source to all nodes
- def self.singlesource_bellmanford_path(graph, source, cutoff = nil)
- _, path = singlesource_bellmanford(graph, source, cutoff)
- path
- end
-
- # Shortest path length from source to all nodes using Bellman Ford algorithm
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param source [Object] source
- # @param cutoff [Numeric, nil] cutoff for Bellman Ford algorithm
- #
- # @return [Hash{ Object => Numeric }] path lengths from source to all nodes
- def self.singlesource_bellmanford_path_length(graph, source, cutoff = nil)
- weight = get_weight(graph)
- help_bellman_ford(graph, [source], weight, nil, nil, nil, cutoff)
- end
-
- # Shortest path lengths between all nodes using Bellman Ford algorithm
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param cutoff [Numeric, nil] cutoff for Bellman Ford algorithm
- #
- # @return [Array Numeric }>] path lengths from source to all nodes
- def self.allpairs_bellmanford_path_length(graph, cutoff = nil)
- path_lengths = []
- graph.nodes(data: true).each_key { |n| path_lengths << [n, singlesource_bellmanford_path_length(graph, n, cutoff)] }
- path_lengths
- end
-
- # Shortest paths between all nodes using Bellman Ford algorithm
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param cutoff [Numeric, nil] cutoff for Bellman Ford algorithm
- #
- # @return [Array Array }>] path lengths from source to all nodes
- def self.allpairs_bellmanford_path(graph, cutoff = nil)
- paths = []
- graph.nodes(data: true).each_key { |n| paths << [n, singlesource_bellmanford_path(graph, n, cutoff)] }
- paths
- end
-
- # Helper function to get sources
- def self.get_sources(graph)
- graph.nodes(data: true).collect { |k, _v| k }
- end
-
- # Helper function to get distances
- def self.dist_path_lambda(_graph, _new_weight)
- lambda do |graph, v, new_weight|
- paths = {v => [v]}
- _ = help_dijkstra(graph, v, new_weight, nil, paths)
- paths
- end
- end
-
- # Helper function to set path lengths for Johnson algorithm
- def self.set_path_lengths_johnson(graph, dist_path, new_weight)
- path_lengths = []
- graph.nodes(data: true).each_key { |n| path_lengths << [n, dist_path.call(graph, n, new_weight)] }
- path_lengths
- end
-
- # Returns shortest path between all pairs of nodes
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- #
- # @return [Array Array }] shortest paths between all pairs of nodes
- def self.johnson(graph)
- dist, pred = {}, {}
- sources = get_sources(graph)
- graph.nodes(data: true).each_key do |n|
- dist[n], pred[n] = 0, []
- end
- weight = get_weight(graph)
- dist_bellman = help_bellman_ford(graph, sources, weight, pred, nil, dist)
- new_weight = ->(u, v, d) { weight.call(u, v, d) + dist_bellman[u] - dist_bellman[v] }
- dist_path = dist_path_lambda(graph, new_weight)
- set_path_lengths_johnson(graph, dist_path, new_weight)
- end
-end
diff --git a/lib/networkx/to_matrix.rb b/lib/networkx/to_matrix.rb
deleted file mode 100644
index 4a55f1d..0000000
--- a/lib/networkx/to_matrix.rb
+++ /dev/null
@@ -1,51 +0,0 @@
-module NetworkX
- def self.to_matrix(graph, val, multigraph_weight = 'sum')
- is_undirected = !graph.directed?
- is_multigraph = graph.multigraph?
- nodelen = graph.nodes(data: true).length
-
- m = Matrix.build(nodelen) { val }
- index = {}
- inv_index = {}
- ind = 0
-
- graph.nodes(data: true).each do |u, _|
- index[u] = ind
- inv_index[ind] = u
- ind += 1
- end
-
- if is_multigraph
- graph.adj.each do |u, edge_hash|
- edge_hash.each do |v, keys|
- all_weights = []
- keys.each do |_key, attrs|
- all_weights << attrs[:weight]
- end
-
- edge_attr = 0
-
- case multigraph_weight
- when 'sum'
- edge_attr = all_weights.sum
- when 'max'
- edge_attr = all_weights.max
- when 'min'
- edge_attr = all_weights.min
- end
-
- m[index[u], index[v]] = edge_attr
- m[index[v], index[u]] = edge_attr || 1 if is_undirected
- end
- end
- else
- graph.adj.each do |u, edge_hash|
- edge_hash.each do |v, attrs|
- m[index[u], index[v]] = (attrs[:weight] || 1)
- m[index[v], index[u]] = (attrs[:weight] || 1) if is_undirected
- end
- end
- end
- [m, inv_index]
- end
-end
diff --git a/lib/networkx/traversals/bfs.rb b/lib/networkx/traversals/bfs.rb
deleted file mode 100644
index 949b7b1..0000000
--- a/lib/networkx/traversals/bfs.rb
+++ /dev/null
@@ -1,110 +0,0 @@
-module NetworkX
- # Returns edges of the graph travelled in breadth first fashion
- #
- # @example
- # NetworkX.bfs_edges(graph, source)
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param source [Object] node to start bfs from
- def self.bfs_edges(graph, source)
- raise KeyError, "There exists no node names #{source} in the given graph." unless graph.node?(source)
-
- bfs_edges = []
- visited = [source]
- queue = Queue.new.push([source, graph.neighbours(source)])
- until queue.empty?
- parent, children = queue.pop
- children.each_key do |child|
- next if visited.include?(child)
-
- bfs_edges << [parent, child]
- visited << child
- queue.push([child, graph.neighbours(child)])
- end
- end
- bfs_edges
- end
-
- # Returns parent successor pair of the graph travelled in breadth first fashion
- #
- # @example
- # NetworkX.bfs_successors(graph, source)
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param source [Object] node to start bfs from
- def self.bfs_successors(graph, source)
- bfs_edges = bfs_edges(graph, source)
- successors = {}
- bfs_edges.each do |u, v|
- successors[u] = [] if successors[u].nil?
- successors[u] << v
- end
- successors
- end
-
- # Returns predecessor child pair of the graph travelled in breadth first fashion
- #
- # @example
- # NetworkX.bfs_predecessors(graph, source)
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param source [Object] node to start bfs from
- def self.bfs_predecessors(graph, source)
- bfs_edges = bfs_edges(graph, source)
- predecessors = {}
- bfs_edges.each { |u, v| predecessors[v] = u }
- predecessors
- end
-
- class Graph
- def bfs_nodes(root)
- each_bfs_node(root).to_a
- end
-
- def each_bfs_node(root)
- return enum_for(:each_bfs_node, root) unless block_given?
-
- queue = [root]
- dist = {root => 0}
- while (v = queue.shift)
- yield v
- d = dist[v]
- @adj[v].each do |u, _data|
- next if dist[u]
-
- dist[u] = d + 1
- queue << u
- end
- end
- end
-
- # [EXPERIMENTAL]
- #
- # @param [Object] node which is root, start ,source
- def bfs_edges(node)
- each_bfs_edge(node).to_a
- end
-
- # [EXPERIMENTAL]
- #
- # @param [Object] node which is root, start ,source
- def each_bfs_edge(node)
- return enum_for(:each_bfs_edge, node) unless block_given?
-
- que = [node]
- used = {node => true}
- while que[0]
- node = que.shift
-
- @adj[node].each do |v, _data|
- next if used[v]
-
- used[v] = true
-
- yield(node, v)
- que << v
- end
- end
- end
- end
-end
diff --git a/lib/networkx/traversals/dfs.rb b/lib/networkx/traversals/dfs.rb
deleted file mode 100644
index 853a1e4..0000000
--- a/lib/networkx/traversals/dfs.rb
+++ /dev/null
@@ -1,135 +0,0 @@
-module NetworkX
- # Returns edges of the graph travelled in depth first fashion
- #
- # @example
- # NetworkX.dfs_edges(graph, source)
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param source [Object] node to start dfs from
- # @param depth_limit [Integer, nil] the depth limit of dfs
- def self.dfs_edges(graph, source, depth_limit = nil)
- raise KeyError, "There exists no node names #{source} in the given graph." unless graph.node?(source)
-
- depth_limit += 1 if depth_limit
- depth_limit = graph.nodes(data: true).length if depth_limit.nil?
- dfs_edges = []
- visited = [source]
- stack = [[-1, source, depth_limit, graph.neighbours(source)]]
- until stack.empty?
- earlier_node, parent, depth_now, children = stack.pop
- dfs_edges << [earlier_node, parent]
- children.each_key do |child|
- unless visited.include?(child)
- visited << child
- stack.push([parent, child, depth_now - 1, graph.neighbours(child)]) if depth_now > 1
- end
- end
- end
- dfs_edges.shift
- dfs_edges
- end
-
- # Returns dfs tree of the graph
- #
- # @example
- # NetworkX.dfs_tree(graph, source)
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param source [Object] node to start dfs from
- # @param depth_limit [Integer, nil] the depth limit of dfs
- def self.dfs_tree(graph, source, depth_limit = nil)
- t = NetworkX::DiGraph.new
- t.add_node(source)
- t.add_edges_from(dfs_edges(graph, source, depth_limit))
- t
- end
-
- # Returns parent successor pair of the graph travelled in depth first fashion
- #
- # @example
- # NetworkX.dfs_successors(graph, source)
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param source [Object] node to start dfs from
- # @param depth_limit [Integer, nil] the depth limit of dfs
- def self.dfs_successors(graph, source, depth_limit = nil)
- dfs_edges = dfs_edges(graph, source, depth_limit)
- successors = {}
- dfs_edges.each do |u, v|
- successors[u] = [] if successors[u].nil?
- successors[u] << v
- end
- successors
- end
-
- # Returns predecessor child pair of the graph travelled in depth first fashion
- #
- # @example
- # NetworkX.dfs_predecessors(graph, source)
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param source [Object] node to start dfs from
- # @param depth_limit [Integer, nil] the depth limit of dfs
- def self.dfs_predecessors(graph, source, depth_limit = nil)
- dfs_edges = dfs_edges(graph, source, depth_limit)
- predecessors = {}
- dfs_edges.each { |u, v| predecessors[v] = u }
- predecessors
- end
-
- class Graph
- # [EXPERIMENTAL]
- #
- # @param root [Object] node which is root, start, source
- #
- # @return [Array[Object]] nodes
- def dfs_preorder_nodes(root)
- each_dfs_preorder_node(root).to_a
- end
-
- # [EXPERIMENTAL]
- #
- # @param root [Object] node which is root, start, source
- def each_dfs_preorder_node(root)
- return enum_for(:each_dfs_preorder_node, root) unless block_given?
-
- st = [root]
- used = {root => true}
- while st[-1]
- node = st.pop
- yield(node)
- @adj[node].reverse_each do |v, _data|
- next if used[v]
-
- used[v] = node
- st << v
- end
- end
- end
-
- # [EXPERIMENTAL]
- #
- # @param root [Object] node which is root, start, source
- #
- # @return [Array[Object]] array of dfs postorder nodes
- def dfs_postorder_nodes(root, used = {root => true})
- res = []
- @adj[root].each do |v, _data|
- next if used[v]
-
- used[v] = true
- res.concat dfs_postorder_nodes(v, used)
- end
-
- res << root
- res
- end
-
- # @param root [Object] node which is root, start, source
- def each_dfs_postorder_node(root, &block)
- return enum_for(:each_dfs_postorder_node, root) unless block_given?
-
- dfs_postorder_nodes(root).each(&block)
- end
- end
-end
diff --git a/lib/networkx/traversals/edge_dfs.rb b/lib/networkx/traversals/edge_dfs.rb
deleted file mode 100644
index 6c174c7..0000000
--- a/lib/networkx/traversals/edge_dfs.rb
+++ /dev/null
@@ -1,114 +0,0 @@
-module NetworkX
- # Helper function for edge_dfs
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param node [Object] a node in the graph
- def self.out_edges(graph, node)
- edges = []
- visited = {}
- case graph.class.name
- when 'NetworkX::Graph', 'NetworkX::DiGraph'
- graph.adj[node].each do |v, _|
- if graph.instance_of?(::NetworkX::DiGraph) || visited[[v, node]].nil?
- visited[[node, v]] = true
- edges << [node, v]
- end
- end
- else
- graph.adj[node].each do |v, uv_keys|
- uv_keys.each_key do |k|
- if graph.instance_of?(::NetworkX::MultiDiGraph) || visited[[v, node, k]].nil?
- visited[[node, v, k]] = true
- edges << [node, v, k]
- end
- end
- end
- end
- edges
- end
-
- # Helper function of edge_dfs
- def self.edge_id(graph, edge)
- return edge if graph.directed?
- return Set.new([edge, (edge[0..1].reverse << edge[2])]) if graph.multigraph?
-
- Set.new([edge, edge.reverse])
- end
-
- # Performs edge dfs on the graph
- # Orientation :ignore, directed edges can be
- # travelled in both fashions
- # Orientation reverse, directed edges can be travelled
- # in reverse fashion
- # Orientation :nil, the graph is not meddled with
- #
- # @example
- # NetworkX.edge_dfs(graph, source, 'ignore')
- #
- # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
- # @param start [Object] node to start dfs from
- # @param orientation [:ignore, :reverse', nil] the orientation of edges of graph
- def self.edge_dfs(graph, start, orientation = nil)
- case orientation
- when :reverse
- graph = graph.reverse if graph.instance_of?(::NetworkX::DiGraph) || graph.instance_of?(::NetworkX::MultiDiGraph)
- when :ignore
- graph = graph.to_undirected if graph.instance_of?(::NetworkX::DiGraph)
- graph = graph.to_multigraph if graph.instance_of?(::NetworkX::MultiDiGraph)
- end
-
- visited_edges = []
- visited_nodes = []
- stack = [start]
- current_edges = {}
-
- e = Enumerator.new do |yield_var|
- until stack.empty?
- current = stack.last
- unless visited_nodes.include?(current)
- current_edges[current] = out_edges(graph, current)
- visited_nodes << current
- end
-
- edge = current_edges[current].shift
- if edge.nil?
- stack.pop
- else
- unless visited_edges.include?(edge_id(graph, edge))
- visited_edges << edge_id(graph, edge)
- stack << edge[1]
- yield_var.yield edge
- end
- end
- end
- end
- e.take(graph.number_of_edges)
- end
-
- class Graph
- def dfs_edges(node)
- each_dfs_edge(node).to_a
- end
-
- def each_dfs_edge(node)
- return enum_for(:each_dfs_edge, node) unless block_given?
-
- st = [node]
- used = {}
- parents = {}
- while st[-1]
- node = st.pop
-
- yield(parents[node], node) if parents[node]
-
- used[node] = true
- @adj[node].reverse_each do |v, _data|
- next if used[v]
-
- parents[v] = node
- st << v unless used[v]
- end
- end
- end
- end
-end
diff --git a/lib/networkx/version.rb b/lib/networkx/version.rb
deleted file mode 100644
index 48dbb27..0000000
--- a/lib/networkx/version.rb
+++ /dev/null
@@ -1,3 +0,0 @@
-module NetworkX
- VERSION = '0.4.0'.freeze
-end
diff --git a/method_list.html b/method_list.html
new file mode 100644
index 0000000..844cd99
--- /dev/null
+++ b/method_list.html
@@ -0,0 +1,2307 @@
+
+
+
+ Method List
+ = 2.0'
- spec.add_development_dependency 'rake', '>= 13.0'
- spec.add_development_dependency 'rspec', '>= 3.0'
- spec.add_development_dependency 'rspec-its', '>= 1.0'
- spec.add_development_dependency 'rubocop', '>= 1.0'
- spec.add_development_dependency 'rubocop-rake', '>= 0.6'
- spec.add_development_dependency 'rubocop-rspec', '>= 2.0'
- spec.add_development_dependency 'rubygems-tasks', '>= 0.2'
- spec.add_development_dependency 'saharspec', '>= 0.0'
- spec.add_development_dependency 'simplecov', '>= 0.21'
- spec.add_development_dependency 'yard', '>= 0.9'
-
- spec.add_runtime_dependency 'matrix', '>= 0.4'
- spec.add_runtime_dependency 'rb_heap', '>= 1.0'
-
- spec.metadata['rubygems_mfa_required'] = 'true'
-end
diff --git a/spec/network_x/auxillary_functions/digraph_dag_spec.rb b/spec/network_x/auxillary_functions/digraph_dag_spec.rb
deleted file mode 100644
index 120a377..0000000
--- a/spec/network_x/auxillary_functions/digraph_dag_spec.rb
+++ /dev/null
@@ -1,32 +0,0 @@
-RSpec.describe NetworkX::DiGraph do
- subject { graph }
-
- let(:graph) { described_class.new }
-
- before do
- graph.add_edge(1, 2)
- graph.add_edge(2, 4)
- graph.add_edge(1, 4)
- graph.add_edge(5, 6)
- graph.add_edge(7, 6)
- graph.add_edge(5, 7)
- end
-
- context 'when ancestors is called' do
- subject { NetworkX.ancestors(graph, 4) }
-
- it { is_expected.to eq([1, 2]) }
- end
-
- context 'when descendants is called' do
- subject { NetworkX.descendants(graph, 1) }
-
- it { is_expected.to eq([2, 4]) }
- end
-
- context 'when topological_sort is called' do
- subject { NetworkX.topological_sort(graph) }
-
- it { is_expected.to eq([1, 5, 2, 7, 4, 6]) }
- end
-end
diff --git a/spec/network_x/auxillary_functions/graph_cliques_spec.rb b/spec/network_x/auxillary_functions/graph_cliques_spec.rb
deleted file mode 100644
index 0d66539..0000000
--- a/spec/network_x/auxillary_functions/graph_cliques_spec.rb
+++ /dev/null
@@ -1,31 +0,0 @@
-RSpec.describe NetworkX::Graph do
- subject { graph }
-
- let(:graph) { described_class.new }
-
- before do
- graph.add_edge(1, 2)
- graph.add_edge(2, 4)
- graph.add_edge(1, 4)
- graph.add_edge(5, 6)
- graph.add_edge(7, 6)
- graph.add_edge(5, 7)
- end
-
- context 'when cliques is called' do
- subject { NetworkX.find_cliques(graph) }
-
- it { is_expected.to eq([[7, 5, 6], [1, 2, 4]]) }
- end
-
- it 'number of cliques' do
- graph = NetworkX::Graph.new
- graph.add_edges([[1, 2], [1, 5], [2, 3], [2, 5], [3, 4], [4, 5], [4, 6]])
- expect(NetworkX.number_of_cliques(graph, 1)).to be 1
- expect(NetworkX.number_of_cliques(graph, 2)).to be 2
- expect(NetworkX.number_of_cliques(graph, 3)).to be 2
- expect(NetworkX.number_of_cliques(graph, 4)).to be 3
- expect(NetworkX.number_of_cliques(graph, 5)).to be 2
- expect(NetworkX.number_of_cliques(graph, 6)).to be 1
- end
-end
diff --git a/spec/network_x/auxillary_functions/graph_cycles_spec.rb b/spec/network_x/auxillary_functions/graph_cycles_spec.rb
deleted file mode 100644
index 670cecb..0000000
--- a/spec/network_x/auxillary_functions/graph_cycles_spec.rb
+++ /dev/null
@@ -1,54 +0,0 @@
-RSpec.describe NetworkX::Graph do
- subject { graph }
-
- let(:graph) { described_class.new }
-
- before do
- graph.add_edge(1, 2)
- graph.add_edge(2, 4)
- graph.add_edge(4, 1)
- graph.add_edge(1, 3)
- graph.add_edge(3, 10)
- graph.add_edge(1, 10)
- graph.add_edge(5, 6)
- graph.add_edge(6, 7)
- graph.add_edge(7, 5)
- end
-
- context 'when cycle_basis is called' do
- subject { NetworkX.cycle_basis(graph, 1) }
-
- it { is_expected.to eq([[4, 2, 1], [10, 3, 1], [7, 6, 5]]) }
- end
-
- context 'when find_cycle is called' do
- subject { NetworkX.find_cycle(graph, 1) }
-
- it { is_expected.to eq([[1, 2], [2, 4], [4, 1]]) }
- end
-
- it 'when find_cycle occures ArgumentError' do
- empty_graph = NetworkX::Graph.empty_graph(3)
- expect{ NetworkX.find_cycle(empty_graph, 0) }.to raise_error(ArgumentError)
-
- null_graph = NetworkX::Graph.null_graph
- expect{ NetworkX.find_cycle(null_graph, 0) }.to raise_error(ArgumentError)
-
- tree = NetworkX::Graph.balanced_tree(3, 2)
- expect{ NetworkX.find_cycle(tree, 0) }.to raise_error(ArgumentError)
- end
-
- it 'cycle? only for Undirected Graph' do
- undirected_graph = NetworkX::Graph.new
- expect(NetworkX.cycle?(undirected_graph)).to be false
-
- undirected_graph.add_edge(0, 1)
- expect(NetworkX.cycle?(undirected_graph)).to be false
-
- undirected_graph.add_edge(1, 2)
- expect(NetworkX.cycle?(undirected_graph)).to be false
-
- undirected_graph.add_edge(2, 0)
- expect(NetworkX.cycle?(undirected_graph)).to be_truthy
- end
-end
diff --git a/spec/network_x/auxillary_functions/graph_eccentricity_spec.rb b/spec/network_x/auxillary_functions/graph_eccentricity_spec.rb
deleted file mode 100644
index 6b21b78..0000000
--- a/spec/network_x/auxillary_functions/graph_eccentricity_spec.rb
+++ /dev/null
@@ -1,28 +0,0 @@
-RSpec.describe NetworkX::Graph do
- subject { graph }
-
- let(:graph) { described_class.new }
-
- before do
- graph.add_edge(1, 2)
- graph.add_edge(2, 4)
- end
-
- context 'when eccentricity is called' do
- subject { NetworkX.eccentricity(graph, 1) }
-
- it { is_expected.to eq(2) }
- end
-
- context 'when diameter is called' do
- subject { NetworkX.diameter(graph) }
-
- it { is_expected.to eq(2) }
- end
-
- context 'when radius is called' do
- subject { NetworkX.radius(graph) }
-
- it { is_expected.to eq(1) }
- end
-end
diff --git a/spec/network_x/auxillary_functions/graph_mis_spec.rb b/spec/network_x/auxillary_functions/graph_mis_spec.rb
deleted file mode 100644
index 72b2a22..0000000
--- a/spec/network_x/auxillary_functions/graph_mis_spec.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-RSpec.describe NetworkX::Graph do
- subject { graph }
-
- let(:graph) { described_class.new }
-
- before do
- graph.add_edge(1, 2)
- graph.add_edge(2, 4)
- graph.add_edge(1, 4)
- graph.add_edge(5, 2)
- end
-
- context 'when mis is called' do
- subject { NetworkX.maximal_independent_set(graph, [1]) }
-
- it { is_expected.to eq([1, 5]) }
- end
-end
diff --git a/spec/network_x/auxillary_functions/graph_mst_spec.rb b/spec/network_x/auxillary_functions/graph_mst_spec.rb
deleted file mode 100644
index f5ca8c0..0000000
--- a/spec/network_x/auxillary_functions/graph_mst_spec.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-RSpec.describe NetworkX::Graph do
- subject { graph }
-
- let(:graph) { described_class.new }
-
- before do
- graph.add_edge(1, 2)
- graph.add_edge(2, 4)
- graph.add_edge(1, 4)
- graph.add_edge(5, 2)
- end
-
- context 'when mst is called' do
- subject { NetworkX.minimum_spanning_tree(graph) }
-
- its('adj') { is_expected.to eq(1 => {2 => {}, 4 => {}}, 2 => {1 => {}, 5 => {}}, 4 => {1 => {}}, 5 => {2 => {}}) }
- end
-end
diff --git a/spec/network_x/auxillary_functions/graph_vitality_spec.rb b/spec/network_x/auxillary_functions/graph_vitality_spec.rb
deleted file mode 100644
index a67f16a..0000000
--- a/spec/network_x/auxillary_functions/graph_vitality_spec.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-RSpec.describe NetworkX::Graph do
- subject { graph }
-
- let(:graph) { described_class.new }
-
- before do
- graph.add_edge(1, 2)
- graph.add_edge(2, 4)
- graph.add_edge(1, 4)
- graph.add_edge(5, 2)
- end
-
- context 'when vitality is called' do
- subject { NetworkX.closeness_vitality(graph, 1) }
-
- it { is_expected.to eq(4) }
- end
-end
diff --git a/spec/network_x/auxillary_functions/graph_wiener_spec.rb b/spec/network_x/auxillary_functions/graph_wiener_spec.rb
deleted file mode 100644
index 8740c72..0000000
--- a/spec/network_x/auxillary_functions/graph_wiener_spec.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-RSpec.describe NetworkX::Graph do
- subject { graph }
-
- let(:graph) { described_class.new }
-
- before do
- graph.add_edge(1, 2)
- graph.add_edge(2, 4)
- graph.add_edge(1, 4)
- graph.add_edge(5, 2)
- end
-
- context 'when wiener_index is called' do
- subject { NetworkX.wiener_index(graph) }
-
- it { is_expected.to eq(8) }
- end
-end
diff --git a/spec/network_x/auxillary_functions/union_find_spec.rb b/spec/network_x/auxillary_functions/union_find_spec.rb
deleted file mode 100644
index 7f567d1..0000000
--- a/spec/network_x/auxillary_functions/union_find_spec.rb
+++ /dev/null
@@ -1,81 +0,0 @@
-RSpec.describe NetworkX::Graph do
- it 'test empty' do
- uf = NetworkX::UnionFind.new
- expect(uf.parents).to eq({})
- expect(uf.weights).to eq({})
- end
-
- it 'test simple' do
- uf = NetworkX::UnionFind.new([0, 1])
- expect(uf.connected?(0, 1)).to be false
-
- uf.union(0, 1)
- expect(uf.connected?(0, 1)).to be true
- end
-
- it 'test []' do
- uf = NetworkX::UnionFind.new([0, 1])
- expect(uf[0] == uf[1]).to be false
- expect(uf[3] == uf[0]).to be false
-
- uf.union(0, 1)
- uf.union(3, 1)
- expect(uf[0] == uf[1]).to be true
- expect(uf[3] == uf[0]).to be true
- expect(uf[5] == uf[3]).to be false
- end
-
- it 'test each' do
- uf = NetworkX::UnionFind.new(('a'..'e'))
- uf.union('a', 'd')
- uf.union('d', 'c')
- expect(uf.each.to_a).to eq ('a'..'e').to_a
- end
-
- it 'test groups' do
- uf = NetworkX::UnionFind.new((0...4))
- groups = uf.groups.map(&:sort).sort
- expect(groups.size).to eq 4
- expect(groups).to eq [[0], [1], [2], [3]]
-
- uf.union(0, 1)
- uf.union(2, 3)
- groups = uf.groups.map(&:sort).sort
- expect(groups.size).to eq 2
- expect(groups[0]).to eq [0, 1]
- expect(groups[1]).to eq [2, 3]
-
- uf.union(0, 2)
- groups = uf.groups.map(&:sort).sort
- expect(groups.size).to eq 1
- expect(groups[0]).to eq [0, 1, 2, 3]
- end
-
- it 'test groups (symbol case)' do
- uf = NetworkX::UnionFind.new([:a, :b, :c, :d, :e, :f])
- expect(uf.groups.size).to eq 6
-
- uf.unite(:a, :b)
- expect(uf.groups.size).to eq 5
-
- uf.unite(:b, :d, :e)
- expect(uf.groups.size).to eq 3
- end
-
- it 'test multiple unite' do
- uf = NetworkX::UnionFind.new((6..15))
- expect(uf[11] == uf[9]).to be false
- expect(uf[9] == uf[10]).to be false
- expect(uf[7] == uf[15]).to be false
- uf.union(9, 6, 15, 10, 8)
- expect(uf[9] == uf[10]).to be true
- uf.union(7, 6, 8)
- expect(uf[7] == uf[15]).to be true
- expect(uf[11] == uf[9]).to be false
- end
-
- it 'test UnionFind Error node' do
- uf = NetworkX::UnionFind.new(%w[a b c])
- expect { uf.root('x') }.to raise_error(ArgumentError, 'x is not a node')
- end
-end
diff --git a/spec/network_x/di_graph_spec.rb b/spec/network_x/di_graph_spec.rb
deleted file mode 100644
index 6586693..0000000
--- a/spec/network_x/di_graph_spec.rb
+++ /dev/null
@@ -1,232 +0,0 @@
-RSpec.describe NetworkX::DiGraph do
- subject { graph }
-
- let(:graph) { described_class.new(name: 'Cities', type: 'directed') }
-
- before do
- graph.add_nodes(%w[Nagpur Mumbai])
- graph.add_edge('Nagpur', 'Mumbai')
- graph.add_edges([%w[Nagpur Chennai], %w[Chennai Bangalore]])
- graph.add_node('Kolkata')
- end
-
- context 'when graph has been assigned attributes' do
- its('graph') { is_expected.to eq(name: 'Cities', type: 'directed') }
- end
-
- context 'when a new node/s has/have been created' do
- its('nodes') do
- is_expected.to eq('Kolkata' => {},
- 'Nagpur' => {},
- 'Mumbai' => {},
- 'Chennai' => {},
- 'Bangalore' => {})
- end
- end
-
- context 'when a new edge/s has/have been added' do
- its('adj') do
- is_expected.to eq('Nagpur' => {'Mumbai' => {}, 'Chennai' => {}},
- 'Bangalore' => {},
- 'Chennai' => {'Bangalore' => {}},
- 'Mumbai' => {}, 'Kolkata' => {})
- end
-
- its('pred') do
- is_expected.to eq('Nagpur' => {},
- 'Bangalore' => {'Chennai' => {}},
- 'Chennai' => {'Nagpur' => {}},
- 'Mumbai' => {'Nagpur' => {}}, 'Kolkata' => {})
- end
- end
-
- it 'node' do
- graph = NetworkX::DiGraph.new
- graph.add_edges([[1, 2], [5, 6]])
- graph.add_node(10, name: 'ten')
- expect(graph.nodes(data: false).sort).to eq([1, 2, 5, 6, 10])
- expect(graph.nodes(data: true)).to eq({1 => {}, 2 => {}, 5 => {}, 6 => {}, 10 => {name: 'ten'}})
- end
-
- context 'when node/s is/are removed' do
- before do
- graph.remove_node('Nagpur')
- graph.remove_nodes(%w[Chennai Mumbai])
- end
-
- its('nodes') { is_expected.to eq('Kolkata' => {}, 'Bangalore' => {}) }
- its('adj') { is_expected.to eq('Kolkata' => {}, 'Bangalore' => {}) }
- end
-
- context 'when edge/s is/are removed' do
- before do
- graph.remove_edge('Nagpur', 'Mumbai')
- graph.remove_edges([%w[Nagpur Chennai], %w[Chennai Bangalore]])
- end
-
- its('adj') do
- is_expected.to eq('Kolkata' => {}, 'Bangalore' => {}, \
- 'Nagpur' => {}, 'Chennai' => {}, 'Mumbai' => {})
- end
- end
-
- it 'tests DiGraph#clear' do
- graph = NetworkX::DiGraph.new(name: 'test')
- graph.add_edge(:x, :y, key: 'first')
- graph.add_edge(:x, :y, key: 'second')
- graph.clear
- expect(graph.number_of_edges).to be 0
- expect(graph.number_of_nodes).to be 0
- expect(graph.graph).to eq({})
- expect(graph.adj).to eq({})
- end
-
- context 'when weighted edge/s is/are added' do
- before do
- graph.add_weighted_edge('Nagpur', 'Mumbai', 15)
- graph.add_weighted_edges([%w[Nagpur Kolkata]], [10])
- end
-
- its('adj') do
- is_expected.to eq('Bangalore' => {},
- 'Chennai' => {'Bangalore' => {}},
- 'Kolkata' => {},
- 'Mumbai' => {},
- 'Nagpur' => {'Mumbai' => {weight: 15}, 'Chennai' => {}, 'Kolkata' => {weight: 10}})
- end
- end
-
- context 'when number of edges are calculated' do
- its('number_of_edges') do
- is_expected.to eq 3
- end
- end
-
- it 'test number_of_edges of empty graph returns 0' do
- empty_graph = NetworkX::DiGraph.new
- expect(empty_graph.number_of_edges).to be 0
- end
-
- it 'test indegree & out_degree of MultiDiGraph with no edge' do
- graph = NetworkX::DiGraph.new
- graph.add_node(0)
- graph.add_node(1)
-
- expect(graph.in_degree(0)).to be 0
- expect(graph.in_degree(1)).to be 0
- expect(graph.out_degree(0)).to be 0
- expect(graph.out_degree(1)).to be 0
- end
-
- it 'test indegree & out_degree of simple MultiDiGraph' do
- graph = NetworkX::DiGraph.new
- graph.add_edges([[0, 1], [1, 2], [2, 3], [3, 4]])
-
- expect(graph.in_degree(0)).to be 0
- expect(graph.in_degree(1)).to be 1
- expect(graph.in_degree(2)).to be 1
- expect(graph.in_degree(3)).to be 1
- expect(graph.in_degree(4)).to be 1
-
- expect(graph.out_degree(0)).to be 1
- expect(graph.out_degree(1)).to be 1
- expect(graph.out_degree(2)).to be 1
- expect(graph.out_degree(3)).to be 1
- expect(graph.out_degree(4)).to be 0
- end
-
- context 'when size is called' do
- subject { graph.size(true) }
-
- before do
- graph.add_weighted_edge('Nagpur', 'Mumbai', 15)
- end
-
- it do
- is_expected.to eq 15
- end
- end
-
- it 'test size' do
- graph = NetworkX::DiGraph.new
- expect(graph.size).to be 0
- expect(graph.size(true)).to be 0
-
- graph.add_edge(:s, :t, weight: 10)
- expect(graph.size).to be 1
- expect(graph.size(true)).to be 10
- end
-
- context 'when subgraph is called' do
- subject { graph.subgraph(%w[Nagpur Mumbai]) }
-
- its('nodes') do
- is_expected.to eq('Nagpur' => {}, 'Mumbai' => {})
- end
-
- its('adj') do
- is_expected.to eq('Nagpur' => {'Mumbai' => {}}, 'Mumbai' => {})
- end
- end
-
- it 'test `subgraph` method' do
- g = NetworkX::DiGraph.new
- g.add_nodes_from(0...4)
- g.add_edges([[0, 1], [1, 2], [1, 3]])
-
- h = g.subgraph([0, 1, 2])
-
- expect(h.number_of_nodes).to eq 3
- expect(h.edges).to eq [[0, 1], [1, 2]]
- end
-
- context 'when edges_subgraph is called' do
- subject { graph.edge_subgraph([%w[Nagpur Mumbai], %w[Nagpur Chennai]]) }
-
- its('nodes') do
- is_expected.to eq('Nagpur' => {}, 'Mumbai' => {}, 'Chennai' => {})
- end
-
- its('adj') do
- is_expected.to eq('Nagpur' => {'Chennai' => {}, 'Mumbai' => {}}, 'Mumbai' => {}, 'Chennai' => {})
- end
- end
-
- it 'tests error of subgraph & edge_subgraph' do
- g = NetworkX::DiGraph.new
- expect { g.subgraph(nil) }.to raise_error(ArgumentError)
- expect { g.edge_subgraph(nil) }.to raise_error(ArgumentError)
- end
-
- context 'when reverse is called' do
- subject { graph.reverse }
-
- its('adj') do
- is_expected.to eq('Nagpur' => {},
- 'Bangalore' => {'Chennai' => {}},
- 'Chennai' => {'Nagpur' => {}},
- 'Mumbai' => {'Nagpur' => {}}, 'Kolkata' => {})
- end
- end
-
- it 'to_undirected' do
- directed_graph = NetworkX::DiGraph.new(name: 'Di')
- directed_graph.add_edges([[:a, :b], [:c, :d]])
-
- undirected_graph = directed_graph.to_undirected
- expect(undirected_graph.class).to eq NetworkX::Graph
- expect(undirected_graph.graph[:name]).to eq 'Di'
- expect(undirected_graph.number_of_edges).to be 2
- expect(undirected_graph.number_of_nodes).to be 4
- end
-
- it 'directed?' do
- directed_graph = NetworkX::DiGraph.new
- expect(directed_graph.directed?).to be true
- end
-
- it 'multigraph?' do
- directed_graph = NetworkX::DiGraph.new
- expect(directed_graph.multigraph?).to be false
- end
-end
diff --git a/spec/network_x/flow/digraph_capacityscaling_spec.rb b/spec/network_x/flow/digraph_capacityscaling_spec.rb
deleted file mode 100644
index 3ae395f..0000000
--- a/spec/network_x/flow/digraph_capacityscaling_spec.rb
+++ /dev/null
@@ -1,23 +0,0 @@
-RSpec.describe NetworkX::DiGraph do
- subject { graph }
-
- let(:graph) { described_class.new }
-
- before do
- graph.add_edge(1, 2)
- graph.add_edge(2, 4)
- end
-
- context 'when capacity_scaling is called' do
- subject { NetworkX.capacity_scaling(graph) }
-
- it { is_expected.to eq([0, {1 => {2 => 0}, 2 => {4 => 0}, 4 => {}}]) }
- end
-
- it 'negative_edge_cycle when Argument Error in this method' do
- graph = NetworkX::Graph.new
- graph.add_weighted_edges([[:a, :b], [:b, :a]], [9, -10])
-
- expect(NetworkX.negative_edge_cycle(graph)).to be_truthy
- end
-end
diff --git a/spec/network_x/flow/digraph_edmondskarp_spec.rb b/spec/network_x/flow/digraph_edmondskarp_spec.rb
deleted file mode 100644
index 6621b4e..0000000
--- a/spec/network_x/flow/digraph_edmondskarp_spec.rb
+++ /dev/null
@@ -1,50 +0,0 @@
-RSpec.describe NetworkX::DiGraph do
- subject { graph }
-
- let(:graph) { described_class.new }
-
- before do
- graph.add_edge(1, 2, capacity: 1)
- graph.add_edge(2, 4, capacity: 1)
- end
-
- context 'when edmondskarp is called' do
- subject { NetworkX.edmondskarp(graph, 1, 4) }
-
- its('adj') do
- is_expected.to eq(1 => {2 => {capacity: 1, flow: 1}},
- 2 => {1 => {capacity: 0, flow: -1},
- 4 => {capacity: 1, flow: 1}},
- 4 => {2 => {capacity: 0, flow: -1}})
- end
- end
-
- it 'when edmondskarp is called for DiGraph with no capacity' do
- graph = NetworkX::DiGraph.new
- graph.add_edge(1, 2)
- graph.add_edge(2, 4)
- expect{ NetworkX.edmondskarp(graph, 1, 4) }.to raise_error(ArgumentError)
- end
-
- it 'when edmondskarp is called for simple DiGraph' do
- graph = NetworkX::DiGraph.new
- graph.add_edge(1, 2, capacity: 1)
- graph.add_edge(2, 4, capacity: 1)
- r = NetworkX.edmondskarp(graph, 1, 4)
- expect(r.graph[:flow_value]).to be 1
- end
-
- it 'edmond_carp' do
- g = NetworkX::DiGraph.new
- g.add_edge('x', 'a', capacity: 3.0)
- g.add_edge('x', 'b', capacity: 1.0)
- g.add_edge('a', 'c', capacity: 3.0)
- g.add_edge('b', 'c', capacity: 5.0)
- g.add_edge('b', 'd', capacity: 4.0)
- g.add_edge('d', 'e', capacity: 2.0)
- g.add_edge('c', 'y', capacity: 2.0)
- g.add_edge('e', 'y', capacity: 3.0)
- r = NetworkX.edmondskarp(g, 'x', 'y')
- expect(r.graph[:flow_value]).to be 3.0
- end
-end
diff --git a/spec/network_x/flow/digraph_preflowpush_spec.rb b/spec/network_x/flow/digraph_preflowpush_spec.rb
deleted file mode 100644
index dad7a3d..0000000
--- a/spec/network_x/flow/digraph_preflowpush_spec.rb
+++ /dev/null
@@ -1,20 +0,0 @@
-RSpec.describe NetworkX::DiGraph do
- subject { graph }
-
- let(:graph) { described_class.new }
-
- before do
- graph.add_edge(1, 2, capacity: 1)
- graph.add_edge(2, 4, capacity: 3)
- end
-
- context 'when preflowpush is called' do
- subject { NetworkX.preflowpush(graph, 1, 4) }
-
- its('adj') do
- is_expected.to eq(1 => {2 => {capacity: 1, flow: 1}},
- 2 => {1 => {capacity: 0, flow: -1}, 4 => {capacity: 3, flow: 1}},
- 4 => {2 => {capacity: 0, flow: -1}})
- end
- end
-end
diff --git a/spec/network_x/flow/digraph_shortestaugmentingpath_spec.rb b/spec/network_x/flow/digraph_shortestaugmentingpath_spec.rb
deleted file mode 100644
index 9617d69..0000000
--- a/spec/network_x/flow/digraph_shortestaugmentingpath_spec.rb
+++ /dev/null
@@ -1,42 +0,0 @@
-RSpec.describe NetworkX::DiGraph do
- subject { graph }
-
- let(:graph) { described_class.new }
-
- before do
- graph.add_edge(1, 2, capacity: 1)
- graph.add_edge(2, 4, capacity: 1)
- end
-
- context 'when shortest_augmenting_path is called' do
- subject { NetworkX.shortest_augmenting_path(graph, 1, 4) }
-
- its('adj') do
- is_expected.to eq(1 => {2 => {capacity: 1, flow: 1}},
- 2 => {1 => {capacity: 0, flow: -1},
- 4 => {capacity: 1, flow: 1}},
- 4 => {2 => {capacity: 0, flow: -1}})
- end
- end
-
- it 'shortest_augmenting_path for DiGraph with no capacity' do
- graph = NetworkX::DiGraph.new
- graph.add_edge(1, 2)
- graph.add_edge(2, 4)
- expect{ NetworkX.shortest_augmenting_path(graph, 1, 4) }.to raise_error(ArgumentError)
- end
-
- it 'shortes augmeting path' do
- g = NetworkX::DiGraph.new
- g.add_edge('x', 'a', capacity: 3.0)
- g.add_edge('x', 'b', capacity: 1.0)
- g.add_edge('a', 'c', capacity: 3.0)
- g.add_edge('b', 'c', capacity: 5.0)
- g.add_edge('b', 'd', capacity: 4.0)
- g.add_edge('d', 'e', capacity: 2.0)
- g.add_edge('c', 'y', capacity: 2.0)
- g.add_edge('e', 'y', capacity: 3.0)
- r = NetworkX.shortest_augmenting_path(g, 'x', 'y')
- expect(r.graph[:flow_value]).to be 3.0
- end
-end
diff --git a/spec/network_x/flow/others_spec.rb b/spec/network_x/flow/others_spec.rb
deleted file mode 100644
index ecdb81c..0000000
--- a/spec/network_x/flow/others_spec.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-RSpec.describe NetworkX do
- it 'test arbitrary_element method' do
- expect(NetworkX.arbitrary_element(Set[-1, -2, -3])).to eq(-1)
- expect(NetworkX.arbitrary_element([10, 20, 30])).to eq 10
- expect(NetworkX.arbitrary_element('xyz')).to eq 'x'
- expect(NetworkX.arbitrary_element({s: 99, t: 100})).to eq :s
- expect(NetworkX.arbitrary_element(80..90)).to eq 80
- end
-end
diff --git a/spec/network_x/graph_spec.rb b/spec/network_x/graph_spec.rb
deleted file mode 100644
index 19db6d1..0000000
--- a/spec/network_x/graph_spec.rb
+++ /dev/null
@@ -1,277 +0,0 @@
-RSpec.describe NetworkX::Graph do
- subject { graph }
-
- let(:graph) { described_class.new(name: 'Cities', type: 'undirected') }
-
- before do
- graph.add_nodes(%w[Nagpur Mumbai])
- graph.add_edge('Nagpur', 'Mumbai')
- graph.add_edges([%w[Nagpur Chennai], %w[Chennai Bangalore]])
- graph.add_node('Kolkata')
- end
-
- context 'when graph has been assigned attributes' do
- its('graph') { is_expected.to eq(name: 'Cities', type: 'undirected') }
- end
-
- context 'when a new node/s has/have been created' do
- its('nodes') do
- is_expected.to eq(%w[Nagpur Mumbai Chennai Bangalore Kolkata])
- end
- end
-
- context 'when a new edge/s has/have been added' do
- its('adj') do
- is_expected.to eq('Nagpur' => {'Mumbai' => {}, 'Chennai' => {}},
- 'Bangalore' => {'Chennai' => {}},
- 'Chennai' => {'Nagpur' => {}, 'Bangalore' => {}},
- 'Mumbai' => {'Nagpur' => {}}, 'Kolkata' => {})
- end
- end
-
- it 'nodes' do
- graph = NetworkX::Graph.new
- graph.add_edges([[:x, :y], [:y, :z]])
- expect(graph.nodes(data: false).sort).to eq([:x, :y, :z])
- expect(graph.nodes(data: true)).to eq({x: {}, y: {}, z: {}})
- end
-
- it 'each_node' do
- graph = NetworkX::Graph.new
- graph.add_edges([[:x, :y], [:y, :z]])
- expect(graph.each_node.to_a).to eq([:x, :y, :z])
- expect(graph.each_node(data: true).to_a).to eq([[:x, {}], [:y, {}], [:z, {}]])
- end
-
- it 'add_path' do
- graph = NetworkX::Graph.new
- graph.add_path(%i[a b c])
- expect(graph.number_of_nodes).to be 3
- expect(graph.number_of_edges).to be 2
- expect(graph.edges).to eq [[:a, :b], [:b, :c]]
- end
-
- context 'when node/s is/are removed' do
- before do
- graph.remove_node('Nagpur')
- graph.remove_nodes(%w[Chennai Mumbai])
- end
-
- its('nodes') { is_expected.to eq(%w[Bangalore Kolkata]) }
- its('adj') { is_expected.to eq('Kolkata' => {}, 'Bangalore' => {}) }
- end
-
- context 'when edge/s is/are removed' do
- before do
- graph.remove_edge('Nagpur', 'Mumbai')
- graph.remove_edges([%w[Nagpur Chennai], %w[Chennai Bangalore]])
- end
-
- its('adj') do
- is_expected.to eq('Kolkata' => {}, 'Bangalore' => {}, \
- 'Nagpur' => {}, 'Chennai' => {}, 'Mumbai' => {})
- end
- end
-
- context 'when weighted edge/s is/are added' do
- before do
- graph.add_weighted_edge('Nagpur', 'Mumbai', 15)
- graph.add_weighted_edges([%w[Nagpur Kolkata]], [10])
- end
-
- its('adj') do
- is_expected.to eq('Bangalore' => {'Chennai' => {}},
- 'Chennai' => {'Nagpur' => {}, 'Bangalore' => {}},
- 'Kolkata' => {'Nagpur' => {weight: 10}},
- 'Mumbai' => {'Nagpur' => {weight: 15}},
- 'Nagpur' => {'Mumbai' => {weight: 15}, 'Chennai' => {}, 'Kolkata' => {weight: 10}})
- end
- end
-
- context 'when number of edges are calculated' do
- its('number_of_edges') do
- is_expected.to eq 3
- end
- end
-
- it 'test number_of_edges of empty graph returns 0' do
- empty_graph = NetworkX::Graph.new
- expect(empty_graph.number_of_edges).to be 0
- end
-
- it 'when size is called' do
- graph.add_weighted_edge('Nagpur', 'Mumbai', 15)
- expect(graph.size).to be 3
- expect(graph.size(true)).to eq 15
- end
-
- context 'when subgraph is called' do
- subject { graph.subgraph(%w[Nagpur Mumbai]) }
-
- its('nodes') do
- is_expected.to eq(%w[Nagpur Mumbai])
- end
-
- its('adj') do
- is_expected.to eq('Nagpur' => {'Mumbai' => {}}, 'Mumbai' => {'Nagpur' => {}})
- end
- end
-
- context 'when edges_subgraph is called' do
- subject { graph.edge_subgraph([%w[Nagpur Mumbai], %w[Nagpur Chennai]]) }
-
- its('nodes') do
- is_expected.to eq(%w[Nagpur Mumbai Chennai])
- end
-
- its('adj') do
- is_expected.to eq('Nagpur' => {'Chennai' => {}, 'Mumbai' => {}}, \
- 'Mumbai' => {'Nagpur' => {}}, 'Chennai' => {'Nagpur' => {}})
- end
- end
-
- it 'test `subgraph` method' do
- g = NetworkX::Graph.new
- g.add_nodes_from(0...4)
- g.add_edges([[0, 1], [1, 2], [1, 3]])
-
- h = g.subgraph([0, 1, 2])
-
- expect(h.nodes(data: false)).to eq [0, 1, 2]
- expect(h.edges).to eq [[0, 1], [1, 2]]
- end
-
- it 'test errors' do
- g = NetworkX::Graph.new
- expect { g.add_edges('abc') }.to raise_error(ArgumentError)
- expect { g.add_nodes(nil) }.to raise_error(ArgumentError)
- expect { g.remove_nodes('wwww') }.to raise_error(ArgumentError)
- expect { g.remove_edges('css') }.to raise_error(ArgumentError)
- expect { g.get_edge_data('yes', 'no') }.to raise_error(KeyError, 'No such edge exists!')
- expect { g.subgraph('xxx') }.to raise_error(ArgumentError)
- expect { g.edge_subgraph('xxx') }.to raise_error(ArgumentError)
- end
-
- it 'test get_node_data' do
- g = NetworkX::Graph.new
- g.add_node('Tokyo', country: 'Japan')
- expect(g.get_node_data('Tokyo')).to eq({country: 'Japan'})
- end
-
- it 'test get_edge_data' do
- g = NetworkX::Graph.new
- g.add_edge('New York', 'Tokyo', time_diff: 14)
- expect(g.get_edge_data('New York', 'Tokyo')).to eq({time_diff: 14})
- end
-
- # [EXPERIMENTAL]
- it 'test `add_edges_from`' do
- g = NetworkX::Graph.new
- g.add_nodes_from(0...10)
- g.add_edges_from([[0, 1], [1, 2], [3, 2], [5, 3], [6, 9], [7, 1]])
- expect(g.number_of_nodes).to be 10
- expect(g.number_of_edges).to be 6
- end
-
- it 'test add_nodes(Range)' do
- g = NetworkX::Graph.new
- g.add_nodes(0...10)
- expect(g.number_of_nodes).to be 10
- end
-
- # test experimental methods: `add_nodes_from`
- it 'test add_nodes_from(String)' do
- g = NetworkX::Graph.new
- g.add_nodes_from('Hello')
- expect(g.number_of_nodes).to be 4
- expect(g.node?('l')).to be true
- expect(g.node?('h')).to be false
- expect(g.node?('o')).to be true
- expect(g.node?('x')).to be false
- end
-
- it 'test degree' do
- graph = NetworkX::Graph.new
- graph.add_edges([[0, 1], [1, 2], [2, 3]])
- expect(graph.degree[0]).to be 1
- expect(graph.degree[1]).to be 2
- expect(graph.degree[2]).to be 2
- expect(graph.degree[3]).to be 1
-
- expect(graph.degree([1, 3, 2])).to eq({1 => 2, 3 => 1, 2 => 2})
- end
-
- # test experimental methods: `add_nodes_from`, `add_weighted_edges_from`, `each_edge`, `edges`
- # https://atcoder.jp/contests/abc051/tasks/abc051_d
- it 'ABC051 D: example 1' do
- n, _m = 3, 3
- edges = [[1, 2, 1], [1, 3, 1], [2, 3, 3]]
-
- g = NetworkX::Graph.new
- g.add_nodes_from(1..n)
- g.add_weighted_edges_from(edges)
-
- expect(g.number_of_nodes).to be 3
- expect(g.number_of_edges).to be 3
- expect(g.adj[1][2][:weight]).to be 1
- expect(g.adj[3][1][:weight]).to be 1
- expect(g.adj[2][3][:weight]).to be 3
-
- expect(g.edges).to eq [[1, 2], [1, 3], [2, 3]]
-
- fw = NetworkX.floyd_warshall(g)
- expect(fw[1][2]).to be 1
- expect(fw[1][3]).to be 1
- expect(fw[2][1]).to be 1
- expect(fw[2][3]).to be 2
- expect(fw[3][1]).to be 1
- expect(fw[3][2]).to be 2
- end
-
- # test experimental methods: `add_nodes_from`, `add_weighted_edges_from`, `each_edge`, `edges`
- # https://atcoder.jp/contests/abc051/tasks/abc051_d
- it 'ABC051 D: example 2' do
- n, _m = 3, 2
- edges = [[1, 2, 1], [2, 3, 1]]
-
- g = NetworkX::Graph.new
- g.add_nodes_from(1..n)
- g.add_weighted_edges_from(edges)
-
- expect(g.number_of_nodes).to be 3
- expect(g.number_of_edges).to be 2
- expect(g.adj[1][2][:weight]).to be 1
- expect(g.adj[3][2][:weight]).to be 1
-
- expect(g.edges).to eq [[1, 2], [2, 3]]
- expect(g.edges(data: true)).to eq [[1, 2, {weight: 1}], [2, 3, {weight: 1}]]
-
- fw = NetworkX.floyd_warshall(g)
- expect(fw[1][2]).to be 1
- expect(fw[1][3]).to be 2
- expect(fw[2][1]).to be 1
- expect(fw[2][3]).to be 1
- expect(fw[3][1]).to be 2
- expect(fw[3][2]).to be 1
- end
-
- it 'test info method' do
- output = <<~'OUTPUT'
- Type: NetworkX::Graph
- Number of nodes: 0
- Number of edges: 0
- OUTPUT
- graph = NetworkX::Graph.new
- expect(graph.info).to eq(output)
- end
-
- it 'directed?' do
- directed_graph = NetworkX::Graph.new
- expect(directed_graph.directed?).to be false
- end
-
- it 'multigraph?' do
- directed_graph = NetworkX::Graph.new
- expect(directed_graph.multigraph?).to be false
- end
-end
diff --git a/spec/network_x/link_analysis/graph_hits_spec.rb b/spec/network_x/link_analysis/graph_hits_spec.rb
deleted file mode 100644
index b25dbc0..0000000
--- a/spec/network_x/link_analysis/graph_hits_spec.rb
+++ /dev/null
@@ -1,28 +0,0 @@
-RSpec.describe NetworkX::Graph do
- subject { graph }
-
- let(:graph) { described_class.new }
-
- before do
- graph.add_edge(1, 2)
- graph.add_edge(2, 4)
- end
-
- context 'when hits is called' do
- subject { NetworkX.hits(graph, 1 => 0.333, 2 => 0.333, 4 => 0.333) }
-
- it { is_expected.to eq([{1 => 1.0, 2 => 1.0, 4 => 1.0}, {1 => 0.5, 2 => 1.0, 4 => 0.5}]) }
- end
-
- context 'when authority_matrix is called' do
- subject { NetworkX.authority_matrix(graph) }
-
- it { is_expected.to eq(Matrix[[1, 0, 1], [0, 2, 0], [1, 0, 1]]) }
- end
-
- context 'when hub_matrix is called' do
- subject { NetworkX.hub_matrix(graph) }
-
- it { is_expected.to eq(Matrix[[1, 0, 1], [0, 2, 0], [1, 0, 1]]) }
- end
-end
diff --git a/spec/network_x/link_analysis/graph_pagerank_spec.rb b/spec/network_x/link_analysis/graph_pagerank_spec.rb
deleted file mode 100644
index a072a64..0000000
--- a/spec/network_x/link_analysis/graph_pagerank_spec.rb
+++ /dev/null
@@ -1,28 +0,0 @@
-RSpec.describe NetworkX::Graph do
- it 'Digraph#pagerank' do
- graph = NetworkX::DiGraph.new
- graph.add_edges([[1, 2], [1, 3], [2, 4], [3, 4], [3, 5], [4, 5], [5, 1]])
- pagerank = NetworkX.pagerank(graph, alpha: 0.95, max_iter: 1000)
- expect(pagerank[1]).to be_within(1e-6).of(0.26261029498162486)
- expect(pagerank[2]).to be_within(1e-6).of(0.13473989208216358)
- expect(pagerank[3]).to be_within(1e-6).of(0.13473989208216358)
- expect(pagerank[4]).to be_within(1e-6).of(0.20200434638512804)
- expect(pagerank[5]).to be_within(1e-6).of(0.2659055744689199)
- end
-
- it 'pagerank' do
- graph = NetworkX::Graph.new
- graph.add_edges([[1, 2], [2, 4]])
- pagerank = NetworkX.pagerank(graph)
- expect(pagerank[1]).to be_within(1e-6).of(0.25675675672536513)
- expect(pagerank[2]).to be_within(1e-6).of(0.4864864865492695)
- expect(pagerank[4]).to be_within(1e-6).of(0.25675675672536513)
- end
-
- it 'pagerank(alpha: 0)' do
- graph = NetworkX::Graph.new
- graph.add_edges([[:a, :b], [:b, :c], [:c, :d], [:d, :a]])
- pagerank = NetworkX.pagerank(graph, alpha: 0)
- expect(pagerank).to eq({a: 0.25, b: 0.25, c: 0.25, d: 0.25})
- end
-end
diff --git a/spec/network_x/multi_di_graph_spec.rb b/spec/network_x/multi_di_graph_spec.rb
deleted file mode 100644
index 12d6b58..0000000
--- a/spec/network_x/multi_di_graph_spec.rb
+++ /dev/null
@@ -1,277 +0,0 @@
-RSpec.describe NetworkX::MultiDiGraph do
- subject { graph }
-
- let(:graph) { described_class.new(name: 'Cities', type: 'directed') }
-
- before do
- graph.add_nodes(%w[Nagpur Mumbai])
- graph.add_edge('Nagpur', 'Mumbai')
- graph.add_edges([%w[Nagpur Chennai], %w[Chennai Bangalore]])
- graph.add_node('Kolkata')
- end
-
- context 'when graph has been assigned attributes' do
- its('graph') { is_expected.to eq(name: 'Cities', type: 'directed') }
- end
-
- context 'when a new node/s has/have been created' do
- its('nodes') do
- is_expected.to eq('Kolkata' => {},
- 'Nagpur' => {},
- 'Mumbai' => {},
- 'Chennai' => {},
- 'Bangalore' => {})
- end
- end
-
- context 'when a new edge/s has/have been added' do
- its('adj') do
- is_expected.to eq('Nagpur' => {'Mumbai' => {0 => {}}, 'Chennai' => {0 => {}}},
- 'Bangalore' => {},
- 'Chennai' => {'Bangalore' => {0 => {}}},
- 'Mumbai' => {}, 'Kolkata' => {})
- end
-
- its('pred') do
- is_expected.to eq('Nagpur' => {},
- 'Bangalore' => {'Chennai' => {0 => {}}},
- 'Chennai' => {'Nagpur' => {0 => {}}},
- 'Mumbai' => {'Nagpur' => {0 => {}}}, 'Kolkata' => {})
- end
- end
-
- context 'when node/s is/are removed' do
- before do
- graph.remove_node('Nagpur')
- graph.remove_nodes(%w[Chennai Mumbai])
- end
-
- its('nodes') { is_expected.to eq('Kolkata' => {}, 'Bangalore' => {}) }
- its('adj') { is_expected.to eq('Kolkata' => {}, 'Bangalore' => {}) }
- end
-
- context 'when edge/s is/are removed' do
- before do
- graph.remove_edge('Nagpur', 'Mumbai')
- graph.remove_edges([%w[Nagpur Chennai], %w[Chennai Bangalore]])
- end
-
- its('adj') do
- is_expected.to eq('Kolkata' => {}, 'Bangalore' => {}, \
- 'Nagpur' => {}, 'Chennai' => {}, 'Mumbai' => {})
- end
- end
-
- it 'test remove_edge' do
- graph = NetworkX::MultiDiGraph.new
- graph.add_edge(:s, :t, key: 'first')
- graph.add_edge(:s, :t, key: 'second')
- graph.add_edge(:s, :t, key: 'third')
- expect(graph.number_of_edges).to be 3
-
- graph.remove_edge(:s, :t, 'second')
- expect(graph.number_of_edges).to be 2
-
- expect { graph.remove_edge(:s, :t, '1st') }.to raise_error(KeyError)
- end
-
- context 'when weighted edge/s is/are added' do
- before do
- graph.remove_nodes(%w[Chennai Bangalore])
- graph.add_weighted_edge('Nagpur', 'Mumbai', 15)
- graph.add_weighted_edges([%w[Nagpur Kolkata]], [10])
- end
-
- its('adj') do
- is_expected.to eq('Kolkata' => {},
- 'Mumbai' => {},
- 'Nagpur' => {'Mumbai' => {0 => {}, 1 => {weight: 15}},
- 'Kolkata' => {0 => {weight: 10}}})
- end
- end
-
- context 'when number of edges are calculated' do
- its('number_of_edges') do
- is_expected.to eq 3
- end
- end
-
- it 'test number_of_edges of empty graph returns 0' do
- empty_graph = NetworkX::MultiDiGraph.new
- expect(empty_graph.number_of_edges).to be 0
- end
-
- it 'test indegree & out_degree of MultiDiGraph with no edge' do
- graph = NetworkX::MultiDiGraph.new
- graph.add_node(0)
- graph.add_node(1)
-
- expect(graph.in_degree(0)).to be 0
- expect(graph.in_degree(1)).to be 0
- expect(graph.out_degree(0)).to be 0
- expect(graph.out_degree(1)).to be 0
- end
-
- it 'test indegree & out_degree of simple MultiDiGraph' do
- graph = NetworkX::MultiDiGraph.new
- graph.add_edges([[0, 1], [1, 2], [2, 3], [3, 4]])
-
- expect(graph.in_degree(0)).to be 0
- expect(graph.in_degree(1)).to be 1
- expect(graph.in_degree(2)).to be 1
- expect(graph.in_degree(3)).to be 1
- expect(graph.in_degree(4)).to be 1
-
- expect(graph.out_degree(0)).to be 1
- expect(graph.out_degree(1)).to be 1
- expect(graph.out_degree(2)).to be 1
- expect(graph.out_degree(3)).to be 1
- expect(graph.out_degree(4)).to be 0
- end
-
- it 'tests edge?' do
- graph = NetworkX::MultiDiGraph.new
- expect(graph.has_edge?(:x, :y)).to be_falsy
-
- graph.add_edge(:x, :y)
- expect(graph.has_edge?(:x, :y)).to be_truthy
- expect(graph.has_edge?(:y, :x)).to be_falsy
- end
-
- it 'tests edge? with key' do
- graph = NetworkX::MultiDiGraph.new
- expect(graph.has_edge?(:x, :y, 'first')).to be_falsy
-
- graph.add_edge(:x, :y, key: 'first')
- expect(graph.has_edge?(:x, :y, 'first')).to be_truthy
- expect(graph.has_edge?(:x, :y, 'second')).to be_falsy
- end
-
- context 'when size is called' do
- subject { graph.size(true) }
-
- before do
- graph.add_weighted_edge('Nagpur', 'Mumbai', 15)
- end
-
- it do
- is_expected.to eq 15
- end
- end
-
- it 'test size' do
- graph = NetworkX::MultiDiGraph.new
- expect(graph.size).to be 0
- expect(graph.size(true)).to be 0
-
- graph.add_edge(:s, :t, weight: 10)
- expect(graph.size).to be 1
- expect(graph.size(true)).to be 10
- end
-
- context 'when subgraph is called' do
- subject { graph.subgraph(%w[Nagpur Mumbai]) }
-
- its('nodes') do
- is_expected.to eq('Nagpur' => {}, 'Mumbai' => {})
- end
-
- its('adj') do
- is_expected.to eq('Nagpur' => {'Mumbai' => {0 => {}}}, 'Mumbai' => {})
- end
- end
-
- it 'test `subgraph` method' do
- g = NetworkX::MultiDiGraph.new
- g.add_nodes_from(0...4)
- g.add_edges([[0, 1], [1, 2], [1, 3]])
-
- h = g.subgraph([0, 1, 2])
-
- expect(h.number_of_nodes).to eq 3
- expect(h.edges).to eq [[0, 1], [1, 2]]
- end
-
- context 'when edges_subgraph is called' do
- subject { graph.edge_subgraph([%w[Nagpur Mumbai], %w[Nagpur Chennai]]) }
-
- its('nodes') do
- is_expected.to eq('Nagpur' => {}, 'Mumbai' => {}, 'Chennai' => {})
- end
-
- its('adj') do
- is_expected.to eq('Nagpur' => {'Chennai' => {0 => {}}, 'Mumbai' => {0 => {}}}, 'Mumbai' => {}, 'Chennai' => {})
- end
- end
-
- it 'tests error from subgraph and edge_subgraph' do
- g = NetworkX::MultiDiGraph.new
- expect { g.subgraph(nil) }.to raise_error(ArgumentError)
- expect { g.edge_subgraph(nil) }.to raise_error(ArgumentError)
- end
-
- it 'nodes' do
- graph = NetworkX::MultiDiGraph.new
- graph.add_edges([[:x, :y], [:y, :z]])
- expect(graph.nodes(data: false)).to eq([:x, :y, :z])
- expect(graph.nodes(data: true)).to eq({x: {}, y: {}, z: {}})
- end
-
- context 'when reverse is called' do
- subject { graph.reverse }
-
- its('adj') do
- is_expected.to eq('Nagpur' => {},
- 'Bangalore' => {'Chennai' => {0 => {}}},
- 'Chennai' => {'Nagpur' => {0 => {}}},
- 'Mumbai' => {'Nagpur' => {0 => {}}}, 'Kolkata' => {})
- end
- end
-
- it 'to_undirected' do
- multi_directed_graph = NetworkX::MultiDiGraph.new(name: 'MultiDi')
- multi_directed_graph.add_edges([[:a, :b], [:c, :d]])
-
- undirected_graph = multi_directed_graph.to_undirected
- expect(undirected_graph.class).to eq NetworkX::Graph
- expect(undirected_graph.graph[:name]).to eq 'MultiDi'
- expect(undirected_graph.number_of_edges).to be 2
- expect(undirected_graph.number_of_nodes).to be 4
- end
-
- it 'to_directed' do
- multi_directed_graph = NetworkX::MultiDiGraph.new(name: 'MultiDi')
- multi_directed_graph.add_edges([[:a, :b], [:a, :b]])
- expect(multi_directed_graph.number_of_edges).to be 2
- expect(multi_directed_graph.number_of_nodes).to be 2
-
- undirected_graph = multi_directed_graph.to_directed
- expect(undirected_graph.class).to eq NetworkX::DiGraph
- expect(undirected_graph.graph[:name]).to eq 'MultiDi'
- expect(undirected_graph.number_of_edges).to be 1
- expect(undirected_graph.number_of_nodes).to be 2
- end
-
- it 'to_multidirected' do
- multi_directed_graph = NetworkX::MultiDiGraph.new(name: 'MultiDi')
- multi_directed_graph.add_edges([[:a, :b], [:a, :b]])
- expect(multi_directed_graph.number_of_edges).to be 2
- expect(multi_directed_graph.number_of_nodes).to be 2
-
- multi_graph = multi_directed_graph.to_multigraph
- expect(multi_graph.class).to eq NetworkX::MultiGraph
- expect(multi_graph.graph[:name]).to eq 'MultiDi'
- expect(multi_graph.number_of_edges).to be 2
- expect(multi_graph.number_of_nodes).to be 2
- end
-
- it 'directed?' do
- directed_graph = NetworkX::MultiDiGraph.new
- expect(directed_graph.directed?).to be true
- end
-
- it 'multigraph?' do
- directed_graph = NetworkX::MultiDiGraph.new
- expect(directed_graph.multigraph?).to be true
- end
-end
diff --git a/spec/network_x/multi_graph_spec.rb b/spec/network_x/multi_graph_spec.rb
deleted file mode 100644
index f3ba2b0..0000000
--- a/spec/network_x/multi_graph_spec.rb
+++ /dev/null
@@ -1,218 +0,0 @@
-RSpec.describe NetworkX::MultiGraph do
- subject { graph }
-
- let(:graph) { described_class.new(name: 'Cities', type: 'undirected') }
-
- before do
- graph.add_nodes(%w[Nagpur Mumbai])
- graph.add_edge('Nagpur', 'Mumbai')
- graph.add_edges([%w[Nagpur Chennai], %w[Chennai Bangalore]])
- graph.add_node('Kolkata')
- end
-
- context 'when graph has been assigned attributes' do
- its('graph') { is_expected.to eq(name: 'Cities', type: 'undirected') }
- end
-
- context 'when a new node/s has/have been created' do
- its('nodes') do
- is_expected.to eq(%w[Nagpur Mumbai Chennai Bangalore Kolkata])
- end
- end
-
- context 'when a new edge/s has/have been added' do
- its('adj') do
- is_expected.to eq('Nagpur' => {'Mumbai' => {0 => {}}, 'Chennai' => {0 => {}}},
- 'Bangalore' => {'Chennai' => {0 => {}}},
- 'Chennai' => {'Nagpur' => {0 => {}}, 'Bangalore' => {0 => {}}},
- 'Mumbai' => {'Nagpur' => {0 => {}}}, 'Kolkata' => {})
- end
- end
-
- it 'nodes' do
- graph = NetworkX::MultiGraph.new
- graph.add_edges([[:x, :y], [:y, :z]])
- expect(graph.nodes(data: false).sort).to eq([:x, :y, :z])
- expect(graph.nodes(data: true)).to eq({x: {}, y: {}, z: {}})
- end
-
- context 'when node/s is/are removed' do
- before do
- graph.remove_node('Nagpur')
- graph.remove_nodes(%w[Chennai Mumbai])
- end
-
- its('nodes') { is_expected.to eq(%w[Bangalore Kolkata]) }
- its('adj') { is_expected.to eq('Kolkata' => {}, 'Bangalore' => {}) }
- end
-
- context 'when edge/s is/are removed' do
- before do
- graph.remove_edge('Nagpur', 'Mumbai')
- graph.remove_edges([%w[Nagpur Chennai], %w[Chennai Bangalore]])
- end
-
- its('adj') do
- is_expected.to eq('Kolkata' => {}, 'Bangalore' => {}, \
- 'Nagpur' => {}, 'Chennai' => {}, 'Mumbai' => {})
- end
- end
-
- it 'tests `remove_edge` with key' do
- graph = NetworkX::MultiGraph.new
- graph.add_edge(:a, :b, key: 'first')
- graph.add_edge(:a, :b, key: 'second')
- expect(graph.number_of_nodes).to be 2
- expect(graph.number_of_edges).to be 2
-
- graph.remove_edge(:a, :b, 'first')
- expect(graph.number_of_nodes).to be 2
- expect(graph.number_of_edges).to be 1
-
- expect { graph.remove_edge(:a, :b, 'third') }.to raise_error(KeyError)
- end
-
- context 'when weighted edge/s is/are added' do
- before do
- graph.remove_nodes(%w[Chennai Bangalore])
- graph.add_weighted_edge('Nagpur', 'Mumbai', 15)
- graph.add_weighted_edges([%w[Nagpur Kolkata]], [10])
- end
-
- its('adj') do
- is_expected.to eq('Kolkata' => {'Nagpur' => {0 => {weight: 10}}},
- 'Mumbai' => {'Nagpur' => {1 => {weight: 15}, 0 => {}}},
- 'Nagpur' => {'Mumbai' => {1 => {weight: 15}, 0 => {}},
- 'Kolkata' => {0 => {weight: 10}}})
- end
- end
-
- context 'when number of edges are calculated' do
- before do
- graph.add_edge('Nagpur', 'Mumbai')
- end
-
- its('number_of_edges') do
- is_expected.to eq 4
- end
- end
-
- it 'test number_of_edges of empty graph returns 0' do
- empty_graph = NetworkX::MultiGraph.new
- expect(empty_graph.number_of_edges).to be 0
- end
-
- it 'tests edge?' do
- graph = NetworkX::MultiGraph.new
- expect(graph.has_edge?(:x, :y)).to be_falsy
- expect(graph.has_edge?(:y, :x)).to be_falsy
-
- graph.add_edge(:x, :y)
- expect(graph.has_edge?(:x, :y)).to be_truthy
- expect(graph.has_edge?(:y, :x)).to be_truthy
- end
-
- it 'tests edge? with key' do
- graph = NetworkX::MultiGraph.new
- expect(graph.has_edge?(:x, :y, 'first')).to be_falsy
-
- graph.add_edge(:x, :y, key: 'first')
- expect(graph.has_edge?(:x, :y, 'first')).to be_truthy
- expect(graph.has_edge?(:y, :x, 'first')).to be_truthy
- expect(graph.has_edge?(:y, :x, 'second')).to be_falsy
- end
-
- it 'each_edges' do
- graph = NetworkX::MultiGraph.new
- graph.add_edge(1, 2, key: 'first')
- graph.add_edge(1, 2, key: 'second')
- expect(graph.each_edge.to_a).to eq [[1, 2, 0], [1, 2, 1]]
- end
-
- context 'when size is called' do
- subject { graph.size(true) }
-
- before do
- graph.add_weighted_edge('Nagpur', 'Mumbai', 15)
- end
-
- it do
- is_expected.to eq 15
- end
- end
-
- it 'test size' do
- graph = NetworkX::MultiGraph.new
- expect(graph.size).to be 0
- expect(graph.size(true)).to be 0
-
- graph.add_edge(:s, :t, weight: 10)
- expect(graph.size).to be 1
- expect(graph.size(true)).to be 10
- end
-
- context 'when subgraph is called' do
- subject { graph.subgraph(%w[Nagpur Mumbai]) }
-
- its('nodes') do
- is_expected.to eq(%w[Nagpur Mumbai])
- end
-
- its('adj') do
- is_expected.to eq('Nagpur' => {'Mumbai' => {0 => {}}}, 'Mumbai' => {'Nagpur' => {0 => {}}})
- end
- end
-
- it 'test `subgraph` method' do
- g = NetworkX::MultiGraph.new
- g.add_nodes_from(0...4)
- g.add_edges([[0, 1], [1, 2], [1, 2], [1, 3]])
-
- h = g.subgraph([0, 1, 2])
-
- expect(h.number_of_nodes).to eq 3
- expect(h.number_of_edges).to eq 3
- expect(h.edges(data: true)).to eq [[0, 1, 0, {}], [1, 2, 0, {}], [1, 2, 1, {}]]
- end
-
- it 'tests error from subgraph and edge_subgraph' do
- g = NetworkX::MultiGraph.new
- expect { g.subgraph(nil) }.to raise_error(ArgumentError)
- expect { g.edge_subgraph(nil) }.to raise_error(ArgumentError)
- end
-
- context 'when edges_subgraph is called' do
- subject { graph.edge_subgraph([%w[Nagpur Mumbai], %w[Nagpur Chennai]]) }
-
- its('nodes') do
- is_expected.to eq(%w[Nagpur Mumbai Chennai])
- end
-
- its('adj') do
- is_expected.to eq('Nagpur' => {'Chennai' => {0 => {}}, 'Mumbai' => {0 => {}}},
- 'Mumbai' => {'Nagpur' => {0 => {}}},
- 'Chennai' => {'Nagpur' => {0 => {}}})
- end
- end
-
- context 'when to_undirected is called' do
- subject { graph.to_undirected }
-
- its('adj') do
- is_expected.to eq('Nagpur' => {'Mumbai' => {}, 'Chennai' => {}},
- 'Bangalore' => {'Chennai' => {}},
- 'Chennai' => {'Nagpur' => {}, 'Bangalore' => {}},
- 'Mumbai' => {'Nagpur' => {}}, 'Kolkata' => {})
- end
- end
-
- it 'directed?' do
- directed_graph = NetworkX::MultiGraph.new
- expect(directed_graph.directed?).to be false
- end
-
- it 'multigraph?' do
- directed_graph = NetworkX::MultiGraph.new
- expect(directed_graph.multigraph?).to be true
- end
-end
diff --git a/spec/network_x/operators/graph_all_spec.rb b/spec/network_x/operators/graph_all_spec.rb
deleted file mode 100644
index f058560..0000000
--- a/spec/network_x/operators/graph_all_spec.rb
+++ /dev/null
@@ -1,48 +0,0 @@
-RSpec.describe NetworkX::Graph do
- subject { graph }
-
- let(:graphs1) { [] }
- let(:graphs2) { [] }
-
- before do
- graphs1 << described_class.new
- graphs1 << described_class.new
- graphs1[0].add_edge(1, 2)
- graphs1[1].add_edge(3, 4)
-
- graphs2 << described_class.new
- graphs2 << described_class.new
- graphs2[0].add_edge(1, 2)
- graphs2[1].add_node(1)
- graphs2[1].add_node(2)
- end
-
- context 'when union_all is called' do
- subject { NetworkX.union_all(graphs1) }
-
- its('adj') { is_expected.to eq(1 => {2 => {}}, 2 => {1 => {}}, 3 => {4 => {}}, 4 => {3 => {}}) }
- end
-
- context 'when disjoint_union_all is called' do
- subject { NetworkX.disjoint_union_all(graphs1) }
-
- its('adj') do
- is_expected.to eq('10' => {'21' => {}},
- '21' => {'10' => {}},
- '30' => {'41' => {}},
- '41' => {'30' => {}})
- end
- end
-
- context 'when intersection_all is called' do
- subject { NetworkX.intersection_all(graphs2) }
-
- its('adj') { is_expected.to eq(1 => {}, 2 => {}) }
- end
-
- context 'when compose_all is called' do
- subject { NetworkX.compose_all(graphs1) }
-
- its('adj') { is_expected.to eq(1 => {2 => {}}, 2 => {1 => {}}, 3 => {4 => {}}, 4 => {3 => {}}) }
- end
-end
diff --git a/spec/network_x/operators/graph_binary_spec.rb b/spec/network_x/operators/graph_binary_spec.rb
deleted file mode 100644
index 3d45f62..0000000
--- a/spec/network_x/operators/graph_binary_spec.rb
+++ /dev/null
@@ -1,336 +0,0 @@
-RSpec.describe NetworkX::Graph do
- subject { graph }
-
- let(:graph1) { described_class.new(type: 'undirected') }
- let(:graph2) { described_class.new(type: 'undirected') }
-
- before do
- graph1.add_edge(1, 2)
- graph2.add_edge(5, 6)
- end
-
- context 'when union is called' do
- subject { NetworkX.union(graph1, graph2) }
-
- its('adj') do
- is_expected.to eq(1 => {2 => {}},
- 2 => {1 => {}},
- 5 => {6 => {}},
- 6 => {5 => {}})
- end
- end
-
- it 'unite DiGraph' do
- graph1 = NetworkX::DiGraph.new
- graph2 = NetworkX::DiGraph.new
- graph1.add_edge(1, 2)
- graph1.add_edge(2, 3)
- graph2.add_edge(5, 6)
-
- graph3 = NetworkX.union(graph1, graph2)
- expect(graph3.class).to be NetworkX::DiGraph
- expect(graph3.number_of_nodes).to be 5
- expect(graph3.number_of_edges).to be 3
- expect(graph3.has_node?(2)).to be true
- expect(graph3.has_node?(5)).to be true
- expect(graph3.has_edge?(5, 6)).to be true
- end
-
- it 'unite Graph' do
- graph1 = NetworkX::Graph.new
- graph2 = NetworkX::Graph.new
- graph1.add_edge(:a, :b)
- graph1.add_edge(:b, :c)
- graph2.add_edge(:e, :f)
-
- graph3 = NetworkX.union(graph1, graph2)
- expect(graph3.class).to be NetworkX::Graph
- expect(graph3.number_of_nodes).to be 5
- expect(graph3.number_of_edges).to be 3
- expect(graph3.has_node?(:b)).to be true
- expect(graph3.has_node?(:e)).to be true
- expect(graph3.has_edge?(:e, :f)).to be true
- end
-
- it 'unite MultiGraph' do
- graph1 = NetworkX::MultiGraph.new
- graph2 = NetworkX::MultiGraph.new
- graph1.add_edge(1, 2)
- graph1.add_edge(2, 3)
- graph2.add_edge(5, 6)
-
- graph3 = NetworkX.union(graph1, graph2)
- expect(graph3.class).to be NetworkX::MultiGraph
- expect(graph3.number_of_nodes).to be 5
- expect(graph3.number_of_edges).to be 3
- expect(graph3.has_node?(2)).to be true
- expect(graph3.has_node?(5)).to be true
- expect(graph3.has_edge?(5, 6)).to be true
- end
-
- it 'unite MultiDiGraph' do
- graph1 = NetworkX::MultiDiGraph.new
- graph2 = NetworkX::MultiDiGraph.new
- graph1.add_edge(1, 2)
- graph1.add_edge(2, 3)
- graph2.add_edge(5, 6)
-
- graph3 = NetworkX.union(graph1, graph2)
- expect(graph3.class).to be NetworkX::MultiDiGraph
- expect(graph3.number_of_nodes).to be 5
- expect(graph3.number_of_edges).to be 3
- expect(graph3.has_node?(2)).to be true
- expect(graph3.has_node?(5)).to be true
- expect(graph3.has_edge?(5, 6)).to be true
- end
-
- context 'when disjoint_union is called' do
- subject { NetworkX.disjoint_union(graph1, graph2) }
-
- its('adj') do
- is_expected.to eq('10' => {'21' => {}},
- '21' => {'10' => {}},
- '50' => {'61' => {}},
- '61' => {'50' => {}})
- end
- end
-
- context 'when compose is called' do
- subject { NetworkX.compose(graph1, graph2) }
-
- its('adj') do
- is_expected.to eq(1 => {2 => {}},
- 2 => {1 => {}},
- 5 => {6 => {}},
- 6 => {5 => {}})
- end
- end
-
- it 'compose multiple graphs' do
- graph1 = NetworkX::MultiDiGraph.new(name: 'first')
- graph2 = NetworkX::MultiDiGraph.new(name: 'second')
- graph1.add_nodes_from(0...5)
- graph2.add_nodes_from(2...6)
-
- graph1.add_edge(0, 1)
- graph1.add_edge(1, 2)
- graph2.add_edge(0, 1)
- graph2.add_edge(4, 5)
- graph2.add_edge(4, 5)
-
- graph3 = NetworkX.compose(graph1, graph2)
- expect(graph3.class).to be NetworkX::MultiDiGraph
- expect(graph3.number_of_nodes).to be 6
- expect(graph3.number_of_edges).to be 5
- end
-
- context 'when symmetric_difference is called' do
- subject { NetworkX.symmetric_difference(graph1, graph2) }
-
- before do
- graph2.clear
- graph2.add_node(1)
- graph2.add_node(2)
- end
-
- its('adj') { is_expected.to eq(1 => {2 => {}}, 2 => {1 => {}}) }
- end
-
- it 'intersection for Graph' do
- g = NetworkX::Graph.new
- h = NetworkX::Graph.new
- g.add_edges_from([[0, 1], [0, 2], [1, 2], [1, 3]])
- h.add_edges_from([[0, 1], [1, 2], [0, 3]])
- new_graph = NetworkX.intersection(g, h)
- expect(new_graph.nodes(data: true)).to eq({0 => {}, 1 => {}, 2 => {}, 3 => {}})
- expect(new_graph.number_of_nodes).to be 4
- expect(new_graph.number_of_edges).to be 2
- expect(new_graph.adj).to eq({
- 0 => {1 => {}},
- 1 => {0 => {}, 2 => {}},
- 2 => {1 => {}},
- 3 => {}
- })
- end
-
- it 'intersection for MultiGraph' do
- g = NetworkX::MultiGraph.new
- h = NetworkX::MultiGraph.new
- g.add_edges_from([[0, 1], [0, 2], [1, 2], [1, 3]])
- h.add_edges_from([[0, 1], [1, 2], [0, 3]])
- new_graph = NetworkX.intersection(g, h)
- expect(new_graph.nodes(data: true)).to eq({0 => {}, 1 => {}, 2 => {}, 3 => {}})
- expect(new_graph.number_of_nodes).to be 4
- expect(new_graph.number_of_edges).to be 2
- expect(new_graph.adj).to eq({
- 0 => {1 => {0 => {}}},
- 1 => {0 => {0 => {}}, 2 => {0 => {}}},
- 2 => {1 => {0 => {}}},
- 3 => {}
- })
- end
-
- it 'intersection for MultiDiGraph' do
- g = NetworkX::MultiDiGraph.new
- h = NetworkX::MultiDiGraph.new
- g.add_edges_from([[0, 1], [0, 2], [1, 2], [1, 3]])
- h.add_edges_from([[0, 1], [1, 2], [0, 3]])
- new_graph = NetworkX.intersection(g, h)
- expect(new_graph.nodes(data: true)).to eq({0 => {}, 1 => {}, 2 => {}, 3 => {}})
- expect(new_graph.number_of_nodes).to be 4
- expect(new_graph.number_of_edges).to be 2
- expect(new_graph.adj).to eq({
- 0 => {1 => {0 => {}}},
- 1 => {2 => {0 => {}}},
- 2 => {},
- 3 => {}
- })
- end
-
- it 'difference for Graph' do
- g = NetworkX::Graph.new
- h = NetworkX::Graph.new
- g.add_edges_from([[0, 1], [0, 2], [1, 2], [1, 3]])
- h.add_edges_from([[0, 1], [1, 2], [0, 3]])
- new_graph = NetworkX.difference(g, h)
- expect(new_graph.nodes(data: true)).to eq({0 => {}, 1 => {}, 2 => {}, 3 => {}})
- expect(new_graph.number_of_nodes).to be 4
- expect(new_graph.number_of_edges).to be 2
- expect(new_graph.adj).to eq({
- 0 => {2 => {}},
- 1 => {3 => {}},
- 2 => {0 => {}},
- 3 => {1 => {}}
- })
- end
-
- it 'difference for DiGraph' do
- g = NetworkX::DiGraph.new
- h = NetworkX::DiGraph.new
- g.add_edges_from([[0, 1], [0, 2], [1, 2], [1, 3]])
- h.add_edges_from([[0, 1], [1, 2], [0, 3]])
- new_graph = NetworkX.difference(g, h)
- expect(new_graph.nodes(data: true)).to eq({0 => {}, 1 => {}, 2 => {}, 3 => {}})
- expect(new_graph.number_of_nodes).to be 4
- expect(new_graph.number_of_edges).to be 2
- expect(new_graph.adj).to eq({
- 0 => {2 => {}},
- 1 => {3 => {}},
- 2 => {},
- 3 => {}
- })
- end
-
- it 'difference for MultiGraph' do
- g = NetworkX::MultiGraph.new
- h = NetworkX::MultiGraph.new
- g.add_edges_from([[0, 1], [0, 2], [1, 2], [1, 3]])
- h.add_edges_from([[0, 1], [1, 2], [0, 3]])
-
- new_graph = NetworkX.difference(g, h)
- expect(new_graph.nodes(data: true)).to eq({0 => {}, 1 => {}, 2 => {}, 3 => {}})
- expect(new_graph.number_of_nodes).to be 4
- expect(new_graph.number_of_edges).to be 2
- expect(new_graph.adj).to eq({
- 0 => {2 => {0 => {}}},
- 1 => {3 => {0 => {}}},
- 2 => {0 => {0 => {}}},
- 3 => {1 => {0 => {}}}
- })
- end
-
- it 'difference for MultiDiGraph' do
- g = NetworkX::MultiDiGraph.new
- h = NetworkX::MultiDiGraph.new
- g.add_edges_from([[0, 1], [0, 2], [1, 2], [1, 3]])
- h.add_edges_from([[0, 1], [1, 2], [0, 3]])
- new_graph = NetworkX.difference(g, h)
- expect(new_graph.nodes(data: true)).to eq({0 => {}, 1 => {}, 2 => {}, 3 => {}})
- expect(new_graph.number_of_nodes).to be 4
- expect(new_graph.number_of_edges).to be 2
- expect(new_graph.adj).to eq({0 => {2 => {0 => {}}}, 1 => {3 => {0 => {}}}, 2 => {}, 3 => {}})
- end
-
- it 'symmetric_difference for Graph' do
- g = NetworkX::Graph.new
- h = NetworkX::Graph.new
- g.add_edges_from([[0, 1], [0, 2], [1, 2], [1, 3]])
- h.add_edges_from([[0, 1], [1, 2], [0, 3]])
- new_graph = NetworkX.symmetric_difference(g, h)
- expect(new_graph.nodes(data: true)).to eq({0 => {}, 1 => {}, 2 => {}, 3 => {}})
- expect(new_graph.number_of_nodes).to be 4
- expect(new_graph.number_of_edges).to be 3
- expect(new_graph.adj).to eq({
- 0 => {2 => {}, 3 => {}},
- 1 => {3 => {}},
- 2 => {0 => {}},
- 3 => {1 => {}, 0 => {}}
- })
- end
-
- it 'symmetric_difference for DiGraph' do
- g = NetworkX::DiGraph.new
- h = NetworkX::DiGraph.new
- g.add_edges_from([[0, 1], [0, 2], [1, 2], [1, 3]])
- h.add_edges_from([[0, 1], [1, 2], [0, 3]])
- new_graph = NetworkX.symmetric_difference(g, h)
- expect(new_graph.number_of_nodes).to be 4
- expect(new_graph.number_of_edges).to be 3
- expect(new_graph.nodes(data: true)).to eq({0 => {}, 1 => {}, 2 => {}, 3 => {}})
- expect(new_graph.adj).to eq({0 => {2 => {}, 3 => {}}, 1 => {3 => {}}, 2 => {}, 3 => {}})
- end
-
- it 'symmetric_difference for MultiGraph' do
- g = NetworkX::MultiGraph.new
- h = NetworkX::MultiGraph.new
- g.add_edges_from([[0, 1], [0, 2], [1, 2], [1, 3]])
- h.add_edges_from([[0, 1], [1, 2], [0, 3]])
-
- new_graph = NetworkX.symmetric_difference(g, h)
- expect(new_graph.nodes(data: true)).to eq({0 => {}, 1 => {}, 2 => {}, 3 => {}})
- expect(new_graph.number_of_nodes).to be 4
- expect(new_graph.number_of_edges).to be 3
- expect(new_graph.adj).to eq({
- 0 => {2 => {0 => {}}, 3 => {0 => {}}},
- 1 => {3 => {0 => {}}},
- 2 => {0 => {0 => {}}},
- 3 => {1 => {0 => {}}, 0 => {0 => {}}}
- })
- end
-
- it 'symmetric_difference for MultiDiGraph' do
- g = NetworkX::MultiDiGraph.new
- h = NetworkX::MultiDiGraph.new
- g.add_edges_from([[0, 1], [0, 2], [1, 2], [1, 3]])
- h.add_edges_from([[0, 1], [1, 2], [0, 3]])
-
- new_graph = NetworkX.symmetric_difference(g, h)
- expect(new_graph.nodes(data: true)).to eq({0 => {}, 1 => {}, 2 => {}, 3 => {}})
- expect(new_graph.number_of_nodes).to be 4
- expect(new_graph.number_of_edges).to be 3
- expect(new_graph.adj).to eq({
- 0 => {2 => {0 => {}}, 3 => {0 => {}}},
- 1 => {3 => {0 => {}}},
- 2 => {},
- 3 => {}
- })
- end
-
- context 'when difference is called' do
- subject { NetworkX.difference(graph1, graph2) }
-
- before do
- graph2.clear
- graph2.add_node(1)
- graph2.add_node(2)
- end
-
- its('adj') { is_expected.to eq(1 => {2 => {}}, 2 => {1 => {}}) }
- end
-
- context 'when intersection is called' do
- subject { NetworkX.intersection(graph1, graph1) }
-
- its('adj') { is_expected.to eq(1 => {2 => {}}, 2 => {1 => {}}) }
- end
-end
diff --git a/spec/network_x/operators/graph_product_spec.rb b/spec/network_x/operators/graph_product_spec.rb
deleted file mode 100644
index ede1425..0000000
--- a/spec/network_x/operators/graph_product_spec.rb
+++ /dev/null
@@ -1,75 +0,0 @@
-RSpec.describe NetworkX::Graph do
- subject { graph }
-
- let(:graph1) { described_class.new(type: 'undirected') }
- let(:graph2) { described_class.new(type: 'undirected') }
-
- before do
- graph1.add_edge(1, 2)
- graph2.add_edge(5, 6)
- end
-
- context 'when tensor_product is called' do
- subject { NetworkX.tensor_product(graph1, graph2) }
-
- its('adj') do
- is_expected.to eq([1, 5] => {[2, 6] => {}},
- [1, 6] => {[2, 5] => {}},
- [2, 5] => {[1, 6] => {}},
- [2, 6] => {[1, 5] => {}})
- end
- end
-
- context 'when lexicographic_product is called' do
- subject { NetworkX.lexicographic_product(graph1, graph2) }
-
- its('adj') do
- is_expected.to eq([1, 5] => {[2, 5] => {}, [2, 6] => {}, [1, 6] => {}},
- [1, 6] => {[2, 5] => {}, [2, 6] => {}, [1, 5] => {}},
- [2, 5] => {[1, 5] => {}, [1, 6] => {}, [2, 6] => {}},
- [2, 6] => {[1, 5] => {}, [1, 6] => {}, [2, 5] => {}})
- end
- end
-
- context 'when cartesian_product is called' do
- subject { NetworkX.cartesian_product(graph1, graph2) }
-
- its('adj') do
- is_expected.to eq([1, 5] => {[2, 5] => {}, [1, 6] => {}},
- [1, 6] => {[2, 6] => {}, [1, 5] => {}},
- [2, 5] => {[1, 5] => {}, [2, 6] => {}},
- [2, 6] => {[1, 6] => {}, [2, 5] => {}})
- end
- end
-
- context 'when strong_product is called' do
- subject { NetworkX.strong_product(graph1, graph2) }
-
- its('adj') do
- is_expected.to eq([1, 5] => {[1, 6] => {}, [2, 5] => {}, [2, 6] => {}},
- [1, 6] => {[1, 5] => {}, [2, 6] => {}, [2, 5] => {}},
- [2, 5] => {[2, 6] => {}, [1, 5] => {}, [1, 6] => {}},
- [2, 6] => {[2, 5] => {}, [1, 6] => {}, [1, 5] => {}})
- end
- end
-
- context 'when power is called' do
- subject { NetworkX.power(graph1, 2) }
-
- its('adj') { is_expected.to eq(1 => {2 => {}}, 2 => {1 => {}}) }
- end
-
- it 'edges_in_array' do
- graph = NetworkX::MultiDiGraph.new
- expect(NetworkX.edges_in_array(graph)).to eq []
-
- graph.add_nodes_from([:a, :b])
- expect(NetworkX.edges_in_array(graph)).to eq []
-
- graph.add_edge(:a, :b)
- expect(NetworkX.edges_in_array(graph)).to eq [[:a, :b, {}]]
-
- graph.add_edge(:a, :b)
- expect(NetworkX.edges_in_array(graph)).to eq [[:a, :b, {}], [:a, :b, {}]]
- end
-end
diff --git a/spec/network_x/operators/graph_unary_spec.rb b/spec/network_x/operators/graph_unary_spec.rb
deleted file mode 100644
index df1b114..0000000
--- a/spec/network_x/operators/graph_unary_spec.rb
+++ /dev/null
@@ -1,22 +0,0 @@
-RSpec.describe NetworkX::Graph do
- subject { graph }
-
- let(:graph1) { described_class.new(type: 'undirected') }
- let(:graph2) { described_class.new(type: 'undirected') }
-
- before do
- graph1.add_edge(1, 2)
- graph1.add_edge(5, 6)
- end
-
- context 'when union is called' do
- subject { NetworkX.complement(graph1) }
-
- its('adj') do
- is_expected.to eq(1 => {5 => {}, 6 => {}},
- 2 => {5 => {}, 6 => {}},
- 5 => {1 => {}, 2 => {}},
- 6 => {1 => {}, 2 => {}})
- end
- end
-end
diff --git a/spec/network_x/others/bridges_spec.rb b/spec/network_x/others/bridges_spec.rb
deleted file mode 100644
index af7716a..0000000
--- a/spec/network_x/others/bridges_spec.rb
+++ /dev/null
@@ -1,50 +0,0 @@
-RSpec.describe NetworkX do
- it 'test empty graph has no bridge' do
- graph = NetworkX::Graph.new
-
- expect(NetworkX.bridges(graph)).to eq []
- expect(NetworkX.number_of_bridges(graph)).to be 0
- end
-
- it 'test simple graph' do
- graph = NetworkX::Graph.new
- graph.add_nodes_from(1..3)
- graph.add_edge(1, 2)
- graph.add_edge(2, 3)
-
- expect(NetworkX.bridges(graph)).to eq [[1, 2], [2, 3]]
- expect(NetworkX.number_of_bridges(graph)).to be 2
- end
-
- # refer to: https://atcoder.jp/contests/abc075/tasks/abc075_c
- it 'test brudges to answer ABC075_C sample#1' do
- n, _m = 7, 7
- edges = [[1, 3], [2, 7], [3, 4], [4, 5], [4, 6], [5, 6], [6, 7]]
- graph = NetworkX::Graph.new
- graph.add_nodes_from(1..n)
- graph.add_edges(edges)
-
- expect(NetworkX.bridges(graph).size).to be 4
- expect(NetworkX.number_of_bridges(graph)).to be 4
- end
-
- it 'test brudges to answer ABC075_C sample#2' do
- n, _m = 3, 3
- edges = [[1, 2], [1, 3], [2, 3]]
- graph = NetworkX::Graph.new
- graph.add_nodes_from(1..n)
- graph.add_edges(edges)
-
- expect(NetworkX.bridges(graph).size).to be 0
- end
-
- it 'test brudges to answer ABC075_C sample#3' do
- n, _m = 6, 5
- edges = [[1, 2], [2, 3], [3, 4], [4, 5], [5, 6]]
- graph = NetworkX::Graph.new
- graph.add_nodes_from(1..n)
- graph.add_edges(edges)
-
- expect(NetworkX.bridges(graph).size).to be 5
- end
-end
diff --git a/spec/network_x/others/generator_spec.rb b/spec/network_x/others/generator_spec.rb
deleted file mode 100644
index a28ec0b..0000000
--- a/spec/network_x/others/generator_spec.rb
+++ /dev/null
@@ -1,150 +0,0 @@
-RSpec.describe NetworkX do
- it 'balanced_tree' do
- balanced_tree = NetworkX::Graph.balanced_tree(3, 2)
- expect(balanced_tree.number_of_nodes).to be 13
- expect(balanced_tree.number_of_edges).to be 12
- end
-
- it 'barbell_graph' do
- barbell_graph = NetworkX::Graph.barbell_graph(5, 2)
- expect(barbell_graph.number_of_nodes).to be 12 # 5 * 2 + 2
- expect(barbell_graph.number_of_edges).to be 23 # (5 * (5 - 1) / 2 * 2) + 2 + 1
- end
-
- it 'complete_graph' do
- complete_graph = NetworkX::Graph.complete_graph(6)
- expect(complete_graph.number_of_nodes).to be 6 # 6
- expect(complete_graph.number_of_edges).to be 15 # 6 * (6 - 1) / 2
- end
-
- it 'circular_ladder_graph' do
- circular_ladder_graph = NetworkX::Graph.circular_ladder_graph(10)
- expect(circular_ladder_graph.number_of_nodes).to be 20 # 10 * 2
- expect(circular_ladder_graph.number_of_edges).to be 30 # 10 * 3
- end
-
- it 'cycle_graph' do
- cycle_graph = NetworkX::Graph.cycle_graph(10)
- expect(cycle_graph.number_of_nodes).to be 10 # 10
- expect(cycle_graph.number_of_edges).to be 10 # 10
- end
-
- it 'empty_graph' do
- empty_graph = NetworkX::Graph.empty_graph(10)
- expect(empty_graph.number_of_nodes).to be 10 # 10
- expect(empty_graph.number_of_edges).to be 0 # 10
- end
-
- it 'ladder_graph' do
- ladder_graph = NetworkX::Graph.ladder_graph(7)
- expect(ladder_graph.number_of_nodes).to be 14 # 7 * 2
- expect(ladder_graph.number_of_edges).to be 19 # 7 * 3 - 2
- end
-
- it 'lollipop_graph' do
- lollipop_graph = NetworkX::Graph.lollipop_graph(6, 3)
- expect(lollipop_graph.number_of_nodes).to be 9 # 6 + 3
- expect(lollipop_graph.number_of_edges).to be 18 # 6 * 5 / 2 + 3
- end
-
- it 'null_graph' do
- null_graph = NetworkX::Graph.null_graph
- expect(null_graph.number_of_nodes).to be 0
- expect(null_graph.number_of_edges).to be 0
- end
-
- it 'path_graph' do
- path_graph = NetworkX::Graph.path_graph(5)
- expect(path_graph.number_of_nodes).to be 5
- expect(path_graph.number_of_edges).to be 4
- end
-
- it 'star_graph' do
- star_graph = NetworkX::Graph.star_graph(5)
- expect(star_graph.number_of_nodes).to be 6 # 5 + 1
- expect(star_graph.number_of_edges).to be 5 # 5
- end
-
- it 'trivial_graph' do
- trivial_graph = NetworkX::Graph.trivial_graph
- expect(trivial_graph.number_of_nodes).to be 1
- expect(trivial_graph.number_of_edges).to be 0
- end
-
- it 'wheel_graph' do
- wheel_graph = NetworkX::Graph.wheel_graph(10)
- expect(wheel_graph.number_of_nodes).to be 10
- expect(wheel_graph.number_of_edges).to be 18
- end
-
- it 'bull_graph' do
- bull_graph = NetworkX::Graph.bull_graph
- expect(bull_graph.number_of_nodes).to be 5
- expect(bull_graph.number_of_edges).to be 5
- end
-
- it 'cubical_graph' do
- cubical_graph = NetworkX::Graph.cubical_graph
- expect(cubical_graph.number_of_nodes).to be 8
- expect(cubical_graph.number_of_edges).to be 12
- end
-
- it 'diamond_graph' do
- diamond_graph = NetworkX::Graph.diamond_graph
- expect(diamond_graph.number_of_nodes).to be 4
- expect(diamond_graph.number_of_edges).to be 5
- end
-
- it 'dodecahedral_graph' do
- dodecahedral_graph = NetworkX::Graph.dodecahedral_graph
- expect(dodecahedral_graph.number_of_nodes).to be 20
- expect(dodecahedral_graph.number_of_edges).to be 30
- end
-
- it 'heawood_graph' do
- heawood_graph = NetworkX::Graph.heawood_graph
- expect(heawood_graph.number_of_nodes).to be 14
- expect(heawood_graph.number_of_edges).to be 21
- end
-
- it 'house_graph' do
- house_graph = NetworkX::Graph.house_graph
- expect(house_graph.number_of_nodes).to be 5
- expect(house_graph.number_of_edges).to be 6
- end
-
- it 'house_x_graph' do
- house_x_graph = NetworkX::Graph.house_x_graph
- expect(house_x_graph.number_of_nodes).to be 5
- expect(house_x_graph.number_of_edges).to be 8
- end
-
- it 'moebius_kantor_graph' do
- moebius_kantor_graph = NetworkX::Graph.moebius_kantor_graph
- expect(moebius_kantor_graph.number_of_nodes).to be 16
- expect(moebius_kantor_graph.number_of_edges).to be 24
- end
-
- it 'octahedral_graph' do
- octahedral_graph = NetworkX::Graph.octahedral_graph
- expect(octahedral_graph.number_of_nodes).to be 6
- expect(octahedral_graph.number_of_edges).to be 12
- end
-
- it 'tetrahedral_graph_graph' do
- tetrahedral_graph = NetworkX::Graph.tetrahedral_graph
- expect(tetrahedral_graph.number_of_nodes).to be 4
- expect(tetrahedral_graph.number_of_edges).to be 6
- end
-
- it 'puts_graph_x2' do
- path_graph = NetworkX::Graph.path_graph(4)
- output = <<~'OUTPUT'
- 4 3
- 0 1
- 1 2
- 2 3
- OUTPUT
- expect { path_graph.put_graph_x2 }.to output(output).to_stdout
- end
-end
diff --git a/spec/network_x/others/grid_2d_graph_spec.rb b/spec/network_x/others/grid_2d_graph_spec.rb
deleted file mode 100644
index 3392761..0000000
--- a/spec/network_x/others/grid_2d_graph_spec.rb
+++ /dev/null
@@ -1,33 +0,0 @@
-RSpec.describe NetworkX do
- it 'test grid_2d_graph for simple square Graph' do
- grid_graph = NetworkX.grid_2d_graph(2, 2)
- expect(grid_graph.number_of_nodes).to be 4
- expect(grid_graph.number_of_edges).to be 4
- end
-
- it 'test grid_2d_graph for simple Graph' do
- grid_graph = NetworkX.grid_2d_graph(3, 6)
- expect(grid_graph.number_of_nodes).to be 3 * 6
- expect(grid_graph.number_of_edges).to be (3 - 1) * 6 + 3 * (6 - 1)
- expect(grid_graph.number_of_edges).to be(3 * 6 * 2 - 3 - 6)
- end
-
- it 'test grid_2d_graph for DiGraph' do
- grid_di_graph = NetworkX.grid_2d_graph(5, 4, create_using: NetworkX::DiGraph)
- expect(grid_di_graph.number_of_nodes).to be 5 * 4
- expect(grid_di_graph.number_of_edges).to be (5 * 4 * 2 - 5 - 4) * 2
- end
-
- it 'test grid_2d_graph for simple MultiGraph' do
- grid_graph = NetworkX.grid_2d_graph(3, 6, create_using: NetworkX::MultiGraph)
- expect(grid_graph.number_of_nodes).to be 3 * 6
- expect(grid_graph.number_of_edges).to be (3 - 1) * 6 + 3 * (6 - 1)
- expect(grid_graph.number_of_edges).to be(3 * 6 * 2 - 3 - 6)
- end
-
- it 'test grid_2d_graph for MultiDiGraph' do
- grid_di_graph = NetworkX.grid_2d_graph(5, 4, create_using: NetworkX::MultiDiGraph)
- expect(grid_di_graph.number_of_nodes).to be 5 * 4
- expect(grid_di_graph.number_of_edges).to be (5 * 4 * 2 - 5 - 4) * 2
- end
-end
diff --git a/spec/network_x/others/info_spec.rb b/spec/network_x/others/info_spec.rb
deleted file mode 100644
index 3bc2215..0000000
--- a/spec/network_x/others/info_spec.rb
+++ /dev/null
@@ -1,12 +0,0 @@
-RSpec.describe NetworkX do
- it 'test info method' do
- output = <<~'OUTPUT'
- Type: NetworkX::Graph
- Number of nodes: 0
- Number of edges: 0
- OUTPUT
-
- graph = NetworkX::Graph.new
- expect(NetworkX.info(graph)).to eq(output)
- end
-end
diff --git a/spec/network_x/others/inputs/edges.txt b/spec/network_x/others/inputs/edges.txt
deleted file mode 100644
index 301ff3b..0000000
--- a/spec/network_x/others/inputs/edges.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-# node1 node2
-a c
-b c
-c d
-d e
-e f
-d f
diff --git a/spec/network_x/others/inputs/weighted_edges.txt b/spec/network_x/others/inputs/weighted_edges.txt
deleted file mode 100644
index 7446561..0000000
--- a/spec/network_x/others/inputs/weighted_edges.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-# node1 node2 weight
-1 3 5.0
-2 3 1.0e3
-3 4 -5.0
-4 5 25
-5 6 4.0
-4 6 5.0
diff --git a/spec/network_x/others/number_connected_components_spec.rb b/spec/network_x/others/number_connected_components_spec.rb
deleted file mode 100644
index e4c5588..0000000
--- a/spec/network_x/others/number_connected_components_spec.rb
+++ /dev/null
@@ -1,12 +0,0 @@
-RSpec.describe NetworkX do
- it 'test number_connected methods' do
- graph = NetworkX::Graph.new
- graph.add_nodes_from('a'..'z')
-
- expect(NetworkX.number_of_connected_components(graph)).to be 26
-
- graph.add_edge('a', 'j')
- graph.add_edge('j', 't')
- expect(NetworkX.number_of_connected_components(graph)).to be 24
- end
-end
diff --git a/spec/network_x/others/reads_spec.rb b/spec/network_x/others/reads_spec.rb
deleted file mode 100644
index 03193d5..0000000
--- a/spec/network_x/others/reads_spec.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-RSpec.describe NetworkX do
- it 'Graph#read_edgelist' do
- graph = NetworkX::Graph.read_edges('spec/network_x/others/inputs/edges.txt')
- expect(graph.number_of_nodes).to be 6
- expect(graph.number_of_edges).to be 6
- end
-
- it 'Graph#read_weighted_edges' do
- graph = NetworkX::Graph.read_weighted_edges('spec/network_x/others/inputs/weighted_edges.txt')
- expect(graph.number_of_nodes).to be 6
- expect(graph.number_of_edges).to be 6
- expect(graph.get_edge_data(1, 3)).to eq({weight: 5})
- end
-
- it 'to_number_if_possible' do
- expect(NetworkX.to_number_if_possible('10')).to be 10
-
- expect(NetworkX.to_number_if_possible('11.0')).to be 11.0
- expect(NetworkX.to_number_if_possible('1e2')).to be 100.0
- expect(NetworkX.to_number_if_possible('-25e-2')).to be(-0.25)
-
- expect(NetworkX.to_number_if_possible('e')).to eq 'e'
- expect(NetworkX.to_number_if_possible('E')).to eq 'E'
- end
-end
diff --git a/spec/network_x/shortest_path/astar_spec.rb b/spec/network_x/shortest_path/astar_spec.rb
deleted file mode 100644
index 99af466..0000000
--- a/spec/network_x/shortest_path/astar_spec.rb
+++ /dev/null
@@ -1,36 +0,0 @@
-RSpec.describe NetworkX::Graph do
- subject { graph }
-
- let(:graph) { described_class.new(type: 'undirected') }
-
- before do
- graph.add_nodes(%w[A B])
- graph.add_edge('A', 'B')
- graph.add_edges([%w[A C], %w[C D]])
- graph.add_node('E')
- end
-
- context 'when astar_path is called' do
- subject { NetworkX.astar_path(graph, 'B', 'D') }
-
- it do
- is_expected.to eq(%w[D C A B])
- end
- end
-
- context 'when astar_path_length is called' do
- subject { NetworkX.astar_path_length(graph, 'B', 'D') }
-
- it do
- is_expected.to eq(3)
- end
- end
-
- it 'not reachable' do
- graph = NetworkX::Graph.new
- graph.add_node(:a)
- graph.add_node(:b)
-
- expect{ NetworkX.astar_path(graph, :a, :b) }.to raise_error(ArgumentError)
- end
-end
diff --git a/spec/network_x/shortest_path/dense_spec.rb b/spec/network_x/shortest_path/dense_spec.rb
deleted file mode 100644
index 319a550..0000000
--- a/spec/network_x/shortest_path/dense_spec.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-RSpec.describe NetworkX::Graph do
- subject { graph }
-
- let(:graph) { described_class.new(type: 'undirected') }
-
- before do
- graph.add_nodes(%w[A B])
- graph.add_edge('A', 'B', weight: 1)
- graph.add_weighted_edges([%w[A C], %w[C D]], [5, 1])
- graph.add_node('E')
- end
-
- context 'when floyd_warshall is called' do
- subject { NetworkX.floyd_warshall(graph) }
-
- it do
- inf = Float::INFINITY
- is_expected.to eq('A' => {'A' => 0.0, 'B' => 1.0, 'C' => 5.0, 'D' => 6.0, 'E' => inf},
- 'B' => {'A' => 1.0, 'B' => 0.0, 'C' => 6.0, 'D' => 7.0, 'E' => inf},
- 'C' => {'A' => 5.0, 'B' => 6.0, 'C' => 0.0, 'D' => 1.0, 'E' => inf},
- 'D' => {'A' => 6.0, 'B' => 7.0, 'C' => 1.0, 'D' => 0.0, 'E' => inf},
- 'E' => {'A' => inf, 'B' => inf, 'C' => inf, 'D' => inf, 'E' => 0.0})
- end
- end
-end
diff --git a/spec/network_x/shortest_path/unweighted_spec.rb b/spec/network_x/shortest_path/unweighted_spec.rb
deleted file mode 100644
index 80549db..0000000
--- a/spec/network_x/shortest_path/unweighted_spec.rb
+++ /dev/null
@@ -1,60 +0,0 @@
-RSpec.describe NetworkX::Graph do
- subject { graph }
-
- let(:graph) { described_class.new(type: 'undirected') }
-
- before do
- graph.add_nodes(%w[A B])
- graph.add_edge('A', 'B')
- graph.add_edges([%w[A C], %w[C D]])
- graph.add_node('E')
- end
-
- context 'when single_source_shortest_path_length is called' do
- subject { NetworkX.single_source_shortest_path_length(graph, 'A') }
-
- it do
- is_expected.to eq([['A', 0], ['B', 1], ['C', 1], ['D', 2]])
- end
- end
-
- context 'when all_pairs_shortest_path_length is called' do
- subject { NetworkX.all_pairs_shortest_path_length(graph) }
-
- it do
- is_expected.to eq([['A', [['A', 0], ['B', 1], ['C', 1], ['D', 2]]],
- ['B', [['B', 0], ['A', 1], ['C', 2], ['D', 3]]],
- ['C', [['C', 0], ['A', 1], ['D', 1], ['B', 2]]],
- ['D', [['D', 0], ['C', 1], ['A', 2], ['B', 3]]],
- ['E', [['E', 0]]]])
- end
- end
-
- context 'when single_source_shortest_path is called' do
- subject { NetworkX.single_source_shortest_path(graph, 'A') }
-
- it do
- is_expected.to eq('A' => ['A'], 'B' => %w[A B], 'C' => %w[A C], 'D' => %w[A C D])
- end
- end
-
- context 'when all_pairs_shortest_path is called' do
- subject { NetworkX.all_pairs_shortest_path(graph) }
-
- it do
- is_expected.to eq([['A', {'A' => ['A'], 'B' => %w[A B], 'C' => %w[A C], 'D' => %w[A C D]}],
- ['B', {'B' => ['B'], 'A' => %w[B A], 'C' => %w[B A C], 'D' => %w[B A C D]}],
- ['C', {'C' => ['C'], 'A' => %w[C A], 'D' => %w[C D], 'B' => %w[C A B]}],
- ['D', {'D' => ['D'], 'C' => %w[D C], 'A' => %w[D C A], 'B' => %w[D C A B]}],
- ['E', {'E' => ['E']}]])
- end
- end
-
- context 'when predecessor is called' do
- subject { NetworkX.predecessor(graph, 'A', true) }
-
- it do
- is_expected.to eq('A' => [], 'B' => ['A'], 'C' => ['A'], 'D' => ['C'])
- end
- end
-end
diff --git a/spec/network_x/shortest_path/weighted_spec.rb b/spec/network_x/shortest_path/weighted_spec.rb
deleted file mode 100644
index 45c0949..0000000
--- a/spec/network_x/shortest_path/weighted_spec.rb
+++ /dev/null
@@ -1,236 +0,0 @@
-RSpec.describe NetworkX::Graph do
- subject { graph }
-
- let(:graph) { described_class.new(type: 'undirected') }
-
- before do
- graph.add_nodes(%w[A B])
- graph.add_edge('A', 'B', weight: 5)
- graph.add_weighted_edges([%w[A C], %w[C D]], [2, 3])
- graph.add_node('E')
- end
-
- it 'simple single source dijkstra' do
- n, _m = 2, 2
- weighted_edges = [[1, 2, 2], [2, 1, 1]]
-
- g = NetworkX::DiGraph.new
- g.add_nodes_from(1..n)
- g.add_weighted_edges_from(weighted_edges)
-
- expect(NetworkX.singlesource_dijkstra_path_length(g, 1)).to eq({1 => 0, 2 => 2})
- expect(NetworkX.dijkstra_path(g, 1, 2)).to eq([1, 2])
- expect(NetworkX.singlesource_dijkstra_path(g, 1)).to eq({1 => [1], 2 => [1, 2]})
- end
-
- it 'single source dijkstra' do
- # https://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=GRL_1_A&lang=ja
- n, _m, r = 4, 5, 0
- weighted_edges = [[0, 1, 1], [0, 2, 4], [1, 2, 2], [2, 3, 1], [1, 3, 5]]
-
- g = NetworkX::DiGraph.new
- g.add_nodes_from(0...n)
- g.add_weighted_edges_from(weighted_edges)
-
- expect(NetworkX.dijkstra_path_length(g, r, 3)).to be 4
- expect(NetworkX.singlesource_dijkstra_path(g, r)).to eq({0 => [0], 1 => [0, 1], 2 => [0, 1, 2], 3 => [0, 1, 2, 3]})
- end
-
- it 'all pair dijkstra' do
- n, _m = 4, 5
- weighted_edges = [[0, 1, 5], [0, 2, -1], [1, 3, 3], [2, 3, 1], [3, 2, 4]]
-
- g = NetworkX::DiGraph.new
- g.add_nodes_from(0...n)
- g.add_weighted_edges_from(weighted_edges)
-
- expect(NetworkX.all_pairs_dijkstra_path_length(g)).to eq [[0, {0 => 0, 1 => 5, 2 => -1, 3 => 0}],
- [1, {1 => 0, 2 => 7, 3 => 3}],
- [2, {2 => 0, 3 => 1}],
- [3, {2 => 4, 3 => 0}]]
- expect(NetworkX.all_pairs_dijkstra_path(g)).to eq [
- {0 => [0], 1 => [0, 1], 2 => [0, 2], 3 => [0, 2, 3]},
- {1 => [1], 3 => [1, 3], 2 => [1, 3, 2]},
- {2 => [2], 3 => [2, 3]},
- {3 => [3], 2 => [3, 2]}
- ]
- end
-
- context 'when multisource_dijkstra is called' do
- subject { NetworkX.multisource_dijkstra(graph, %w[B A], 'D') }
-
- it do
- is_expected.to eq([5, %w[A C D]])
- end
- end
-
- context 'when multisource_dijkstra_path_length is called' do
- subject { NetworkX.multisource_dijkstra_path_length(graph, %w[B A]) }
-
- it do
- is_expected.to eq('B' => 0, 'A' => 0, 'C' => 2, 'D' => 5)
- end
- end
-
- context 'when multisource_dijkstra_path is called' do
- subject { NetworkX.multisource_dijkstra_path(graph, %w[B A]) }
-
- it do
- is_expected.to eq('B' => ['B'], 'A' => ['A'], 'C' => %w[A C], 'D' => %w[A C D])
- end
- end
-
- context 'when multisource_dijkstra_path is called' do
- subject { NetworkX.multisource_dijkstra_path(graph, %w[B A]) }
-
- it do
- is_expected.to eq('B' => ['B'], 'A' => ['A'], 'C' => %w[A C], 'D' => %w[A C D])
- end
- end
-
- context 'when dijkstra_predecessor_distance is called' do
- subject { NetworkX.dijkstra_predecessor_distance(graph, 'A') }
-
- it do
- is_expected.to eq([{'A' => [], 'B' => ['A'], 'C' => ['A'], 'D' => ['C']},
- {'A' => 0, 'C' => 2, 'B' => 5, 'D' => 5}])
- end
- end
-
- context 'when self.all_pairs_dijkstra is called' do
- subject { NetworkX.all_pairs_dijkstra(graph) }
-
- it do
- is_expected.to eq([['A',
- [{'A' => 0, 'C' => 2, 'B' => 5, 'D' => 5},
- {'A' => ['A'],
- 'B' => %w[A B],
- 'C' => %w[A C],
- 'D' => %w[A C D]}]],
- ['B',
- [{'B' => 0, 'A' => 5, 'C' => 7, 'D' => 10},
- {'B' => ['B'],
- 'A' => %w[B A],
- 'C' => %w[B A C],
- 'D' => %w[B A C D]}]],
- ['C',
- [{'C' => 0, 'A' => 2, 'D' => 3, 'B' => 7},
- {'C' => ['C'],
- 'A' => %w[C A],
- 'D' => %w[C D],
- 'B' => %w[C A B]}]],
- ['D',
- [{'D' => 0, 'C' => 3, 'A' => 5, 'B' => 10},
- {'D' => ['D'],
- 'C' => %w[D C],
- 'A' => %w[D C A],
- 'B' => %w[D C A B]}]],
- ['E', [{'E' => 0}, {'E' => ['E']}]]])
- end
- end
-
- context 'when dijkstra_predecessor_distance is called' do
- subject { NetworkX.dijkstra_predecessor_distance(graph, 'A') }
-
- it do
- is_expected.to eq([{'A' => [], 'B' => ['A'], 'C' => ['A'], 'D' => ['C']},
- {'A' => 0, 'C' => 2, 'B' => 5, 'D' => 5}])
- end
- end
-
- it 'dijksttra for simple MultiGraph' do
- graph = NetworkX::MultiGraph.new
- graph.add_edges_from([[:a, :b], [:a, :b], [:b, :a], [:a, :c], [:c, :d], [:a, :d], [:c, :e]])
- expect(NetworkX.dijkstra_path_length(graph, :a, :a)).to be 0
- expect(NetworkX.dijkstra_path_length(graph, :a, :b)).to be 1
- expect(NetworkX.dijkstra_path_length(graph, :a, :c)).to be 1
- expect(NetworkX.dijkstra_path_length(graph, :a, :d)).to be 1
- expect(NetworkX.dijkstra_path_length(graph, :a, :e)).to be 2
- end
-
- it 'dijksttra for MultiGraph' do
- graph = NetworkX::MultiGraph.new
- graph.add_weighted_edges_from([[:a, :b, 20], [:a, :b, 5], [:a, :b, 10]])
- expect(graph.edges).to eq [[:a, :b, 0], [:a, :b, 1], [:a, :b, 2]]
- expect(NetworkX.dijkstra_path_length(graph, :a, :a)).to be 0
- # expect(NetworkX.dijkstra_path_length(graph, :a, :b)).to be 5 # [TODO]
- end
-
- it 'allpairs_bellmanford_path for MultiGraph' do
- graph = NetworkX::MultiGraph.new
- graph.add_edges_from([[:a, :b], [:a, :b], [:b, :c], [:a, :c]])
-
- expect(NetworkX.allpairs_bellmanford_path_length(graph)).to eq [
- [:a, {a: 0, b: 1, c: 1}],
- [:b, {a: 1, b: 0, c: 1}],
- [:c, {a: 1, b: 1, c: 0}]
- ]
- expect(NetworkX.allpairs_bellmanford_path(graph)).to eq [
- [:a, {a: [:a], b: [:b, :a], c: [:c, :a]}],
- [:b, {a: [:a, :b], b: [:b], c: [:c, :b]}],
- [:c, {a: [:a, :c], b: [:b, :c], c: [:c]}]
- ]
- end
-
- it 'raise ArgumentError in singlesource_bellmanford' do
- graph = NetworkX::DiGraph.new
- graph.add_node(:a)
- graph.add_node(:x)
- expect{ NetworkX.singlesource_bellmanford(graph, :a, :x) }.to raise_error(ArgumentError)
- end
-
- it 'bellmanford_path' do
- graph = NetworkX::DiGraph.new
- graph.add_edges_from([[:a, :b], [:b, :c], [:c, :d], [:d, :x], [:c, :x]])
- graph.add_node(:x)
-
- expect(NetworkX.bellmanford_path(graph, :a, :x)).to eq [:x, :c, :b, :a]
- # [TODO] [:a, :b, :c, :x] ?
- end
-
- context 'when bellmanford_predecesor_distance is called' do
- subject { NetworkX.bellmanford_predecesor_distance(graph, 'A') }
-
- it do
- is_expected.to eq([{'A' => [], 'B' => ['A'], 'C' => ['A'], 'D' => ['C']},
- {'A' => 0, 'C' => 2, 'B' => 5, 'D' => 5}])
- end
- end
-
- context 'when singlesource_bellmanford is called' do
- subject { NetworkX.singlesource_bellmanford(graph, 'A') }
-
- it do
- is_expected.to eq([{'A' => 0, 'B' => 5, 'C' => 2, 'D' => 5},
- {'A' => ['A'], 'B' => %w[B A], 'C' => %w[C A], 'D' => %w[D C A]}])
- end
- end
-
- context 'when bellmanford_path_length is called' do
- subject { NetworkX.bellmanford_path_length(graph, 'A', 'D') }
-
- it do
- is_expected.to eq(5)
- end
- end
-
- context 'when bellmanford_path_length is called' do
- subject { NetworkX.bellmanford_path_length(graph, 'A', 'D') }
-
- it do
- is_expected.to eq(5)
- end
- end
-
- context 'when johnson is called' do
- subject { NetworkX.johnson(graph) }
-
- it do
- is_expected.to eq([['A', {'A' => ['A'], 'B' => %w[A B], 'C' => %w[A C], 'D' => %w[A C D]}],
- ['B', {'B' => ['B'], 'A' => %w[B A], 'C' => %w[B A C], 'D' => %w[B A C D]}],
- ['C', {'C' => ['C'], 'A' => %w[C A], 'D' => %w[C D], 'B' => %w[C A B]}],
- ['D', {'D' => ['D'], 'C' => %w[D C], 'A' => %w[D C A], 'B' => %w[D C A B]}],
- ['E', {'E' => ['E']}]])
- end
- end
-end
diff --git a/spec/network_x/to_matrix_spec.rb b/spec/network_x/to_matrix_spec.rb
deleted file mode 100644
index 4fa9619..0000000
--- a/spec/network_x/to_matrix_spec.rb
+++ /dev/null
@@ -1,34 +0,0 @@
-RSpec.describe NetworkX do
- it 'to_matrix(multi graph, val, sum)' do
- graph = NetworkX::MultiGraph.new
-
- graph.add_edge(:a, :b, weight: 10)
- graph.add_edge(:b, :a, weight: 9)
-
- m, indexes = NetworkX.to_matrix(graph, 0)
- expect(m).to eq Matrix[[0, 19], [19, 0]]
- expect(indexes).to eq({0 => :a, 1 => :b})
- end
-
- it 'to_matrix(multi graph, val, max)' do
- graph = NetworkX::MultiGraph.new
-
- graph.add_edge(:x, :y, weight: 10)
- graph.add_edge(:y, :x, weight: 5)
-
- m, index = NetworkX.to_matrix(graph, 0, 'max')
- expect(m).to eq Matrix[[0, 10], [10, 0]]
- expect(index).to eq({0 => :x, 1 => :y})
- end
-
- it 'to_matrix(multi graph, val, min)' do
- graph = NetworkX::MultiGraph.new
-
- graph.add_edge(:v, :w, weight: 10)
- graph.add_edge(:w, :v, weight: 5)
-
- m, index = NetworkX.to_matrix(graph, 0, 'min')
- expect(m).to eq Matrix[[0, 5], [5, 0]]
- expect(index).to eq({0 => :v, 1 => :w})
- end
-end
diff --git a/spec/network_x/traversals/bfs_spec.rb b/spec/network_x/traversals/bfs_spec.rb
deleted file mode 100644
index 9ec9fb7..0000000
--- a/spec/network_x/traversals/bfs_spec.rb
+++ /dev/null
@@ -1,76 +0,0 @@
-RSpec.describe NetworkX::Graph do
- subject { graph }
-
- let(:graph) { described_class.new(type: 'undirected') }
-
- before do
- graph.add_nodes(%w[A B])
- graph.add_edge('A', 'B')
- graph.add_edges([%w[A C], %w[C D]])
- graph.add_node('E')
- end
-
- context 'when bfs_edges is called' do
- subject { NetworkX.bfs_edges(graph, 'A') }
-
- it do
- is_expected.to eq([%w[A B], %w[A C], %w[C D]])
- end
- end
-
- context 'when bfs_successors is called' do
- subject { NetworkX.bfs_successors(graph, 'A') }
-
- it do
- is_expected.to eq('A' => %w[B C], 'C' => ['D'])
- end
- end
-
- context 'when bfs_predecessors is called' do
- subject { NetworkX.bfs_predecessors(graph, 'A') }
-
- it do
- is_expected.to eq('B' => 'A', 'C' => 'A', 'D' => 'C')
- end
- end
-
- it 'bfs_nodes' do
- tree = NetworkX::Graph.new
- tree.add_nodes('a'..'o')
- tree.add_edges([%w[a b], %w[b c], %w[c h], %w[c i], %w[b d], %w[a e], %w[e f], %w[f j], %w[e g], %w[g k]])
-
- expect(tree.bfs_nodes('a')).to eq %w[a b e c d f g h i j k]
- end
-
- it 'test bfs_edge' do
- edges = [[1, 2], [1, 3], [2, 4], [2, 5], [3, 6], [3, 7]]
-
- g = NetworkX::Graph.new
- g.add_nodes_from(1..7)
- g.add_edges_from(edges)
- expect(g.bfs_edges(1)).to eq(edges)
- end
-
- it 'test bfs_edge (ABC051 D - Maze Master many paths)' do
- # https://atcoder.jp/contests/abc151/submissions/36396660
- def bfs(sy, sx, graph)
- dist = {}
- dist[[sy, sx]] = 0
- graph.each_bfs_edge([sy, sx]) do |from, to|
- dist[to] = dist[from] + 1
- end
- dist.values.max
- end
-
- h, w = 12, 12
- grid_graph = NetworkX.grid_2d_graph(h, w)
- ans = 0
- h.times do |y|
- w.times do |x|
- tmp = bfs(y, x, grid_graph)
- ans = tmp if ans < tmp
- end
- end
- expect(ans).to be 22
- end
-end
diff --git a/spec/network_x/traversals/dfs_spec.rb b/spec/network_x/traversals/dfs_spec.rb
deleted file mode 100644
index 8a4284c..0000000
--- a/spec/network_x/traversals/dfs_spec.rb
+++ /dev/null
@@ -1,109 +0,0 @@
-RSpec.describe NetworkX::Graph do
- subject { graph }
-
- let(:graph) { described_class.new(type: 'undirected') }
-
- before do
- graph.add_nodes(%w[A B])
- graph.add_edge('A', 'B')
- graph.add_edges([%w[A C], %w[B D]])
- graph.add_node('E')
- end
-
- context 'when dfs_edges is called' do
- subject { NetworkX.dfs_edges(graph, 'A') }
-
- it do
- is_expected.to eq([%w[A C], %w[A B], %w[B D]])
- end
- end
-
- it 'dfs_edges with limit' do
- graph = NetworkX::Graph.new
- graph.add_edges([[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [4, 5]])
- edges = NetworkX.dfs_edges(graph, 0, 2)
- expect(edges).to eq([[0, 1], [1, 2]])
- end
-
- it 'dfs_tree' do
- graph = NetworkX::Graph.new
- graph.add_edges([[0, 1], [1, 2], [1, 3], [2, 3], [1, 4], [4, 5], [5, 2], [5, 3], [4, 2]])
- tree = NetworkX.dfs_tree(graph, 0)
- expect(tree.edges.sort).to eq([[0, 1], [1, 2], [1, 3], [1, 4], [4, 5]])
- end
-
- it 'dfs_tree with limit' do
- graph = NetworkX::Graph.new
- graph.add_edges([[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [4, 5]])
- tree = NetworkX.dfs_tree(graph, 0, 2)
- expect(tree.edges.sort).to eq([[0, 1], [1, 2]])
- end
-
- context 'when dfs_successors is called' do
- subject { NetworkX.dfs_successors(graph, 'A') }
-
- it do
- is_expected.to eq('A' => %w[C B], 'B' => ['D'])
- end
- end
-
- context 'when dfs_predecessors is called' do
- subject { NetworkX.dfs_predecessors(graph, 'A') }
-
- it do
- is_expected.to eq('B' => 'A', 'C' => 'A', 'D' => 'B')
- end
- end
-
- it 'test dfs_preorder_nodes for Graph' do
- edges = [[1, 2], [1, 3], [2, 4], [2, 5], [3, 6], [3, 7]]
- dfs_preorder_nodes = [1, 2, 4, 5, 3, 6, 7]
-
- g = NetworkX::Graph.new
- g.add_nodes_from(1..7)
- g.add_edges_from(edges)
- expect(g.dfs_preorder_nodes(1)).to eq(dfs_preorder_nodes)
- end
-
- it 'test dfs_preorder_nodes for Digraph' do
- edges = [[1, 2], [1, 3], [2, 4], [2, 5], [3, 6], [3, 7]]
- dfs_preorder_nodes = [1, 2, 4, 5, 3, 6, 7]
-
- g = NetworkX::DiGraph.new
- g.add_nodes_from(1..7)
- g.add_edges_from(edges)
- expect(g.dfs_preorder_nodes(1)).to eq(dfs_preorder_nodes)
- end
-
- it 'test each dfs nodes for Digraph' do
- edges = [[2, 1], [2, 8], [8, 3], [3, 5], [5, 4], [5, 7], [7, 6], [8, 9]]
- dfs_preorder_nodes = [2, 1, 8, 3, 5, 4, 7, 6, 9]
- dfs_postorder_nodes = [1, 4, 6, 7, 5, 3, 9, 8, 2]
-
- g = NetworkX::DiGraph.new
- g.add_nodes_from(1..9)
- g.add_edges_from(edges)
- expect(g.each_dfs_preorder_node(2).to_a).to eq(dfs_preorder_nodes)
- expect(g.each_dfs_postorder_node(2).to_a).to eq(dfs_postorder_nodes)
- end
-
- it 'test dfs nodes for Graph' do
- tree = NetworkX::Graph.new
- tree.add_nodes('a'..'o')
- tree.add_edges([%w[a b], %w[b c], %w[c h], %w[c i], %w[b d], %w[a e], %w[e f], %w[f j], %w[e g], %w[g k]])
-
- expect(tree.dfs_preorder_nodes('a')).to eq %w[a b c h i d e f j g k]
- expect(tree.dfs_postorder_nodes('a')).to eq %w[h i c d b j f k g e a]
- expect(tree.each_dfs_postorder_node('a').to_a).to eq %w[h i c d b j f k g e a]
- end
-
- it 'test dfs nodes for DiGraph' do
- tree = NetworkX::DiGraph.new
- tree.add_nodes('a'..'o')
- tree.add_edges([%w[a b], %w[b c], %w[c h], %w[c i], %w[b d], %w[a e], %w[e f], %w[f j], %w[e g], %w[g k]])
-
- expect(tree.dfs_preorder_nodes('a')).to eq %w[a b c h i d e f j g k]
- expect(tree.dfs_postorder_nodes('a')).to eq %w[h i c d b j f k g e a]
- expect(tree.each_dfs_postorder_node('a').to_a).to eq %w[h i c d b j f k g e a]
- end
-end
diff --git a/spec/network_x/traversals/edge_dfs_spec.rb b/spec/network_x/traversals/edge_dfs_spec.rb
deleted file mode 100644
index 634483b..0000000
--- a/spec/network_x/traversals/edge_dfs_spec.rb
+++ /dev/null
@@ -1,86 +0,0 @@
-RSpec.describe NetworkX::DiGraph do
- subject { graph }
-
- let(:graph) { described_class.new(type: 'directed') }
-
- before do
- graph.add_nodes(%w[A B])
- graph.add_edge('A', 'B')
- graph.add_edges([%w[B A], %w[B D]])
- graph.add_node('E')
- end
-
- context 'when dfs_edges is called' do
- subject { NetworkX.edge_dfs(graph, 'A') }
-
- it do
- is_expected.to eq([%w[A B], %w[B A], %w[B D]])
- end
- end
-
- it 'multigraph' do
- graph = NetworkX::MultiDiGraph.new
- graph.add_edge(:A, :B)
- graph.add_edges([%i[B A], %i[B D]])
-
- expect(NetworkX.edge_dfs(graph, :A)).to eq([[:A, :B, 0], [:B, :A, 0], [:B, :D, 0]])
- end
-
- it 'edges_dfes to digraph with option' do
- graph = NetworkX::DiGraph.new
- graph.add_edge(:A, :B)
- graph.add_edges([%i[B C], %i[C D]])
-
- expect(NetworkX.edge_dfs(graph, :A, :reverse)).to eq([])
- expect(NetworkX.edge_dfs(graph, :D, :ignore)).to eq([%i[D C], %i[C B], %i[B A]])
- expect(NetworkX.edge_dfs(graph, :D, :reverse)).to eq([%i[D C], %i[C B], %i[B A]])
- end
-
- it 'test bfs_edge (ABC051 D - Maze Master sample_01)' do
- # # https://atcoder.jp/contests/abc151/submissions/36398103
- g = NetworkX::Graph.new
- g.add_nodes_from(0...2)
- g.add_edge(0, 1)
- expect(g.bfs_edges(0)).to eq([[0, 1]])
- expect(g.bfs_edges(1)).to eq([[1, 0]])
- end
-
- it 'test dfs_edges' do
- edges = [[1, 2], [1, 3], [2, 4], [2, 5], [3, 6], [3, 7]]
- dfs_edges = [[1, 2], [2, 4], [2, 5], [1, 3], [3, 6], [3, 7]]
-
- g = NetworkX::Graph.new
- g.add_nodes_from(1..7)
- g.add_edges_from(edges)
- expect(g.dfs_edges(1)).to eq(dfs_edges)
- end
-
- it 'tes dfs_edges for object other than integert' do
- tree = NetworkX::Graph.new
- tree.add_nodes('a'..'o')
- tree.add_edges([%w[a b], %w[b c], %w[c h], %w[c i], %w[b d], %w[a e], %w[e f], %w[f j], %w[e g], %w[g k]])
-
- expect(tree.dfs_edges('a')).to eq [%w[a b], %w[b c], %w[c h], %w[c i], %w[b d], %w[a e],
- %w[e f], %w[f j], %w[e g], %w[g k]]
- end
-
- it 'test dfs_edges to line graph (ABC133 E sample1)' do
- n, _k = 4, 3
- edges = [[1, 2], [2, 3], [3, 4]]
-
- g = NetworkX::Graph.new
- g.add_nodes_from(1..n)
- g.add_edges_from(edges)
- expect(g.dfs_edges(1)).to eq([[1, 2], [2, 3], [3, 4]])
- end
-
- it 'test dfs_edges to line graph (ABC133 E sample2)' do
- n, _k = 5, 4
- edges = [[1, 2], [1, 3], [1, 4], [4, 5]]
-
- g = NetworkX::Graph.new
- g.add_nodes_from(1..n)
- g.add_edges_from(edges)
- expect(g.dfs_edges(1)).to eq([[1, 2], [1, 3], [1, 4], [4, 5]])
- end
-end
diff --git a/spec/network_x_spec.rb b/spec/network_x_spec.rb
deleted file mode 100644
index bd2c39e..0000000
--- a/spec/network_x_spec.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-RSpec.describe NetworkX do
- context 'when has a version number' do
- subject { described_class::VERSION }
-
- it { is_expected.not_to be_nil }
- end
-end
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
deleted file mode 100644
index d3d0e6d..0000000
--- a/spec/spec_helper.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-require 'bundler/setup'
-
-require 'simplecov'
-SimpleCov.start { add_filter 'spec' }
-
-require 'rspec'
-require 'rspec/its'
-require 'saharspec/its/call'
-
-require 'networkx'
-
-RSpec::Expectations.configuration.warn_about_potential_false_positives = false
-
-RSpec.configure do |config|
- # Enable flags like --only-failures and --next-failure
- config.example_status_persistence_file_path = 'spec/.rspec_status'
-end
diff --git a/top-level-namespace.html b/top-level-namespace.html
new file mode 100644
index 0000000..b8c591a
--- /dev/null
+++ b/top-level-namespace.html
@@ -0,0 +1,112 @@
+
+
+
+
+ Top Level Namespace
+
+ — Documentation by YARD 0.9.28
+
+
+
+
+
+
+
Top Level Namespace
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Defined Under Namespace
+
+
+
+ Modules: NetworkX Classes: Array
+
+
+
+
+
+
+
+
+
+
+
+
+
+
