Add tasks for all the new languages

Task/Topological-sort/EchoLisp/topological-sort-1.echolisp

@@ -0,0 +1,26 @@
+(define dependencies
+'((des_system_lib   std synopsys std_cell_lib des_system_lib dw02 dw01 ramlib ieee)
+(dw01             ieee dw01 dware gtech) ;; bad graph add dw04
+(dw02             ieee dw02 dware )
+(dw03             std synopsys dware dw03 dw02 dw01 ieee gtech)
+(dw04             dw04 ieee dw01 dware gtech)
+(dw05             dw05 ieee dware)
+(dw06             dw06 ieee dware)
+(dw07             ieee dware)
+(dware            ieee dware)
+(gtech            ieee gtech)
+(ramlib           std ieee )
+(std_cell_lib     ieee std_cell_lib)
+(synopsys         )))
+
+
+;; build dependency graph
+;;  a depends on b
+;;  add arc (arrow) a --> b
+(lib 'graph.lib)
+(define (a->b  g a b)
+		(unless (equal? a b)
+		(graph-make-arc g (graph-make-vertex g a) (graph-make-vertex g b))))
+
+(define (add-dependencies g dep-list)
+(for* ((dep dep-list)  (b (rest dep))) (a->b  g b (first dep))))

Task/Topological-sort/EchoLisp/topological-sort-2.echolisp

@@ -0,0 +1,31 @@
+;; topological sort
+;;
+;; Complexity O (# of vertices + # of edges)
+
+(define (t-sort g)
+	(stack 'Z) ; vertices of d°(0)
+	(stack 'S) ; ordered result
+
+;; mark all vertices with their in-degree = # of incoming arcs
+;; push all vertices u such as d°(u) = 0
+	(for ((u g)) (mark u (graph-vertex-indegree g u))
+	             (when (zero? (mark? u)) (push 'Z u)))
+	
+;pop a d°(0) vertex u - add it to result
+;decrement in-degree of all v vertices u->v
+; if d°(v) = 0, push it
+
+(while (not (stack-empty? 'Z))
+  			(let  (( u (pop 'Z)))
+ 			(push 'S u)
+			 (for ((v (graph-vertex-out g u)))
+				  (mark v (1- (mark? v)))
+				  (when (zero? (mark? v)) (push 'Z v)))))
+				
+;; finish
+		 (writeln 't-sort (map vertex-label (stack->list 'S)))
+		
+;; check no one remaining
+		(for ((u g))
+		(unless (zero? (mark? u))
+		(error " ♻️ t-sort:cyclic" (map vertex-label (graph-cycle g))))))

Task/Topological-sort/EchoLisp/topological-sort-3.echolisp

@@ -0,0 +1,13 @@
+(define g (make-graph "VHDL"))
+(add-dependencies g dependencies)
+(graph-print g)
+
+(t-sort g)
+→ t-sort     (std synopsys ieee dware dw02 dw05 dw06 dw07 gtech dw01 dw03 dw04 ramlib
+             std_cell_lib des_system_lib)
+
+;; Error case
+;; add dw01 -> dw04
+(t-sort g)
+t-sort     (std synopsys ieee dware dw02 dw05 dw06 dw07 gtech ramlib std_cell_lib)
+⛔️ error: ♻️ t-sort:cyclic (dw04 dw01)	

Task/Topological-sort/FunL/topological-sort.funl

@@ -0,0 +1,61 @@
+def topsort( graph ) =
+  val L = seq()
+  val S = seq()
+  val g = dict( graph )
+
+  for (v, es) <- g
+    g(v) = seq( es )
+
+  for (v, es) <- g if es.isEmpty()
+    S.append( v )
+
+  while not S.isEmpty()
+    val n = S.remove( 0 )
+    L.append( n )
+
+    for (m, es) <- g if n in es
+      if (es -= n).isEmpty()
+        S.append( m )
+
+  for (v, es) <- g
+    if not es.isEmpty()
+      return None
+
+  Some( L.toList() )
+
+dependencies = '''
+  des_system_lib   std synopsys std_cell_lib des_system_lib dw02 dw01 ramlib ieee
+  dw01             ieee dw01 dware gtech
+  dw02             ieee dw02 dware
+  dw03             std synopsys dware dw03 dw02 dw01 ieee gtech
+  dw04             dw04 ieee dw01 dware gtech
+  dw05             dw05 ieee dware
+  dw06             dw06 ieee dware
+  dw07             ieee dware
+  dware            ieee dware
+  gtech            ieee gtech
+  ramlib           std ieee
+  std_cell_lib     ieee std_cell_lib
+  synopsys
+  '''
+
+// convert dependencies data into a directed graph
+graph = dict()
+deps = set()
+
+for l <- WrappedString( dependencies ).lines() if l.trim() != ''
+  case list(l.trim().split('\\s+')) of
+    [a] -> graph(a) = []
+    h:t ->
+      d = set( t )
+      d -= h                  // remove self dependencies
+      graph(h) = d
+      deps ++= t
+
+// add graph vertices for dependencies not appearing in left column
+for e <- deps if e not in graph
+  graph(e) = []
+
+case topsort( graph ) of
+  None -> println( 'un-orderable' )
+  Some( ordering ) -> println( ordering )

Task/Topological-sort/Sidef/topological-sort.sidef

@@ -0,0 +1,42 @@
+func print_topo_sort (deps) {
+    var ba = Hash.new;
+    deps.each { |before, afters|
+        afters.each { |after|
+            if (before != after) {
+                ba{before}{after} = 1;
+            };
+            ba{after} \\= Hash.new;
+        }
+    };
+
+    loop {
+        var afters = ba.keys.grep {|k| ba{k}.values.len == 0 }.sort;
+        afters.len || break;
+        say afters.join(" ");
+        ba.delete(afters...);
+        ba.values.each { |v| v.delete(afters...) };
+    };
+
+    say (ba.len ? "Cicle found! #{ba.keys.sort}" : "---");
+}
+
+var deps = Hash.new(
+    des_system_lib => < std synopsys std_cell_lib des_system_lib dw02
+                                                     dw01 ramlib ieee >,
+    dw01           => < ieee dw01 dware gtech                         >,
+    dw02           => < ieee dw02 dware                               >,
+    dw03           => < std synopsys dware dw03 dw02 dw01 ieee gtech  >,
+    dw04           => < dw04 ieee dw01 dware gtech                    >,
+    dw05           => < dw05 ieee dware                               >,
+    dw06           => < dw06 ieee dware                               >,
+    dw07           => < ieee dware                                    >,
+    dware          => < ieee dware                                    >,
+    gtech          => < ieee gtech                                    >,
+    ramlib         => < std ieee                                      >,
+    std_cell_lib   => < ieee std_cell_lib                             >,
+    synopsys       => <                                               >
+);
+
+print_topo_sort(deps);
+deps{:dw01}.append('dw04');     # Add unresolvable dependency
+print_topo_sort(deps);

Task/Topological-sort/jq/topological-sort-1.jq

@@ -0,0 +1,51 @@
+# independent/0 emits an array of the dependencies that have no dependencies
+# Input: an object representing a normalized dependency graph
+def independent:
+  . as $G
+  | reduce keys[] as $key
+      ([];
+       . +  ((reduce $G[$key][] as $node
+               ([];
+                if ($G[$node] == null or ($G[$node]|length)==0) then . + [$node]
+                else .
+                end ))))
+  | unique;
+
+# normalize/0 eliminates self-dependencies in the input dependency graph.
+# Input: an object representing a dependency graph.
+def normalize:
+  . as $G
+  | reduce keys[] as $key
+      ($G;
+       .[$key] as $nodes
+       | if $nodes and ($nodes|index($key)) then .[$key] = $nodes - [$key] else . end);
+
+
+# minus/1 removes all the items in ary from each of the values in the input object
+# Input: an object representing a dependency graph
+def minus(ary):
+  . as $G | reduce keys[] as $key ($G; $G[$key] -= ary);
+
+# tsort/0 emits the topologically sorted nodes of the input,
+# in ">" order.
+# Input is assumed to be an object representing a dependency
+# graph and need not be normalized.
+def tsort:
+  # _sort: input: [L, Graph], where L is the tsort so far
+  def _tsort:
+
+    def done: [.[]] | all( length==0 );
+
+    .[0] as $L | .[1] as $G
+    | if ($G|done) then $L + (($G|keys) - $L)
+      else
+         ($G|independent) as $I
+         | if (($I|length) == 0)
+           then error("the dependency graph is cyclic: \($G)")
+           else [ ($L + $I), ($G|minus($I))] | _tsort
+           end
+      end;
+
+  normalize | [[], .] | _tsort ;
+
+tsort

Task/Topological-sort/jq/topological-sort-2.jq

@@ -0,0 +1,14 @@
+{"des_system_lib": [ "std", "synopsys", "std_cell_lib", "des_system_lib", "dw02", "dw01", "ramlib", "ieee"],
+ "dw01": [ "ieee", "dw01", "dware", "gtech"],
+ "dw02": [ "ieee", "dw02", "dware"],
+ "dw03": [ "std", "synopsys", "dware", "dw03", "dw02", "dw01", "ieee", "gtech"],
+ "dw04": [ "dw04", "ieee", "dw01", "dware", "gtech"],
+ "dw05": [ "dw05", "ieee", "dware"],
+ "dw06": [ "dw06", "ieee", "dware"],
+ "dw07": [ "ieee", "dware"],
+ "dware": [ "ieee", "dware"],
+ "gtech": [ "ieee", "gtech"],
+ "ramlib": [ "std", "ieee"],
+ "std_cell_lib": [ "ieee", "std_cell_lib"],
+ "synopsys": []
+}

Task/Topological-sort/jq/topological-sort-3.jq

@@ -0,0 +1,2 @@
+$ jq -c -f tsort.jq tsort.json
+["ieee","std","synopsys","dware","gtech","ramlib","std_cell_lib","dw01","dw02","des_system_lib","dw03","dw04","dw05","dw06","dw07"]