Data commit

2023-07-01 11:58:00 -04:00 · 2023-07-01 11:58:00 -04:00 · cb5bb5e222
commit cb5bb5e222
parent 7387c8f97b
199093 changed files with 3378972 additions and 0 deletions
--- a/Task/Parallel-calculations/00-META.yaml
+++ b/Task/Parallel-calculations/00-META.yaml
@ -0,0 +1,3 @@
+---
+from: http://rosettacode.org/wiki/Parallel_calculations
+note: Control Structures
--- a/Task/Parallel-calculations/00-TASK.txt
+++ b/Task/Parallel-calculations/00-TASK.txt
@ -0,0 +1,23 @@
+Many programming languages allow you to specify computations to be run in parallel. 
+While [[Concurrent computing]] is focused on concurrency, 
+the purpose of this task is to distribute time-consuming calculations 
+on as many CPUs as possible.
+
+Assume we have a collection of numbers, and want to find the one 
+with the largest minimal prime factor 
+(that is, the one that contains relatively large factors). 
+To speed up the search, the factorization should be done 
+in parallel using separate threads or processes, 
+to take advantage of multi-core CPUs.
+
+Show how this can be formulated in your language. 
+Parallelize the factorization of those numbers, 
+then search the returned list of numbers and factors 
+for the largest minimal factor, 
+and return that number and its prime factors.
+
+For the prime number decomposition 
+you may use the solution of the [[Prime decomposition]] task.
+
+{{omit from|J}}
+
--- a/Task/Parallel-calculations/Ada/parallel-calculations-1.ada
+++ b/Task/Parallel-calculations/Ada/parallel-calculations-1.ada
@ -0,0 +1,22 @@
+generic
+   type Number is private;
+   Zero : Number;
+   One  : Number;
+   Two  : Number;
+   with function Image (X : Number) return String is <>;
+   with function "+"   (X, Y : Number) return Number is <>;
+   with function "/"   (X, Y : Number) return Number is <>;
+   with function "mod" (X, Y : Number) return Number is <>;
+   with function ">="  (X, Y : Number) return Boolean is <>;
+package Prime_Numbers is
+   type Number_List is array (Positive range <>) of Number;
+
+   procedure Put (List : Number_List);
+
+   task type Calculate_Factors is
+      entry Start (The_Number : in Number);
+      entry Get_Size (Size : out Natural);
+      entry Get_Result (List : out Number_List);
+   end Calculate_Factors;
+
+end Prime_Numbers;
--- a/Task/Parallel-calculations/Ada/parallel-calculations-2.ada
+++ b/Task/Parallel-calculations/Ada/parallel-calculations-2.ada
@ -0,0 +1,50 @@
+with Ada.Text_IO;
+package body Prime_Numbers is
+
+   procedure Put (List : Number_List) is
+   begin
+      for Index in List'Range loop
+         Ada.Text_IO.Put (Image (List (Index)));
+      end loop;
+   end Put;
+
+   task body Calculate_Factors is
+      Size : Natural := 0;
+      N    : Number;
+      M    : Number;
+      K    : Number  := Two;
+   begin
+      accept Start (The_Number : in Number) do
+         N := The_Number;
+         M := N;
+      end Start;
+      -- Estimation of the result length from above
+      while M >= Two loop
+         M    := (M + One) / Two;
+         Size := Size + 1;
+      end loop;
+      M := N;
+      -- Filling the result with prime numbers
+      declare
+         Result : Number_List (1 .. Size);
+         Index  : Positive := 1;
+      begin
+         while N >= K loop -- Divisors loop
+            while Zero = (M mod K) loop -- While divides
+               Result (Index) := K;
+               Index          := Index + 1;
+               M              := M / K;
+            end loop;
+            K := K + One;
+         end loop;
+         Index := Index - 1;
+         accept Get_Size (Size : out Natural) do
+            Size := Index;
+         end Get_Size;
+         accept Get_Result (List : out Number_List) do
+            List (1 .. Index) := Result (1 .. Index);
+         end Get_Result;
+      end;
+   end Calculate_Factors;
+
+end Prime_Numbers;
--- a/Task/Parallel-calculations/Ada/parallel-calculations-3.ada
+++ b/Task/Parallel-calculations/Ada/parallel-calculations-3.ada
@ -0,0 +1,54 @@
+with Ada.Text_IO;
+with Prime_Numbers;
+procedure Parallel is
+   package Integer_Primes is new Prime_Numbers (
+      Number => Integer, -- use Large_Integer for longer numbers
+      Zero   => 0,
+      One    => 1,
+      Two    => 2,
+      Image  => Integer'Image);
+
+   My_List : Integer_Primes.Number_List :=
+     ( 12757923,
+       12878611,
+       12757923,
+       15808973,
+       15780709,
+      197622519);
+
+   Decomposers : array (My_List'Range) of Integer_Primes.Calculate_Factors;
+   Lengths     : array (My_List'Range) of Natural;
+   Max_Length  : Natural := 0;
+begin
+   for I in My_List'Range loop
+      -- starts the tasks
+      Decomposers (I).Start (My_List (I));
+   end loop;
+   for I in My_List'Range loop
+      -- wait until task has reached Get_Size entry
+      Decomposers (I).Get_Size (Lengths (I));
+      if Lengths (I) > Max_Length then
+         Max_Length := Lengths (I);
+      end if;
+   end loop;
+   declare
+      Results                :
+        array (My_List'Range) of Integer_Primes.Number_List (1 .. Max_Length);
+      Largest_Minimal_Factor : Integer := 0;
+      Winning_Index          : Positive;
+   begin
+      for I in My_List'Range loop
+         -- after Get_Result, the tasks terminate
+         Decomposers (I).Get_Result (Results (I));
+         if Results (I) (1) > Largest_Minimal_Factor then
+            Largest_Minimal_Factor := Results (I) (1);
+            Winning_Index          := I;
+         end if;
+      end loop;
+      Ada.Text_IO.Put_Line
+        ("Number" & Integer'Image (My_List (Winning_Index)) &
+         " has largest minimal factor:");
+      Integer_Primes.Put (Results (Winning_Index) (1 .. Lengths (Winning_Index)));
+      Ada.Text_IO.New_Line;
+   end;
+end Parallel;
--- a/Task/Parallel-calculations/C++/parallel-calculations.cpp
+++ b/Task/Parallel-calculations/C++/parallel-calculations.cpp
@ -0,0 +1,57 @@
+#include <iostream>
+#include <iterator>
+#include <vector>
+#include <ppl.h> // MSVC++
+#include <concurrent_vector.h> // MSVC++
+
+struct Factors
+{
+    int number;
+    std::vector<int> primes;
+};
+
+const int data[] =
+{
+    12757923, 12878611, 12878893, 12757923, 15808973, 15780709, 197622519
+};
+
+int main()
+{
+    // concurrency-safe container replaces std::vector<>
+    Concurrency::concurrent_vector<Factors> results;
+
+    // parallel algorithm replaces std::for_each()
+    Concurrency::parallel_for_each(std::begin(data), std::end(data), [&](int n)
+    {
+        Factors factors;
+        factors.number = n;
+        for (int f = 2; n > 1; ++f)
+        {
+            while (n % f == 0)
+            {
+                factors.primes.push_back(f);
+                n /= f;
+            }
+        }
+        results.push_back(factors); // add factorization to results
+    });
+    // end of parallel calculations
+
+    // find largest minimal prime factor in results
+    auto max = std::max_element(results.begin(), results.end(), [](const Factors &a, const Factors &b)
+    {
+        return a.primes.front() < b.primes.front();
+    });
+
+    // print number(s) and factorization
+    std::for_each(results.begin(), results.end(), [&](const Factors &f)
+    {
+        if (f.primes.front() == max->primes.front())
+        {
+            std::cout << f.number << " = [ ";
+            std::copy(f.primes.begin(), f.primes.end(), std::ostream_iterator<int>(std::cout, " "));
+            std::cout << "]\n";
+        }
+    });
+    return 0;
+}
--- a/Task/Parallel-calculations/C-sharp/parallel-calculations-1.cs
+++ b/Task/Parallel-calculations/C-sharp/parallel-calculations-1.cs
@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+class Program
+{
+    public static List<int> PrimeFactors(int number)
+    {
+        var primes = new List<int>();
+        for (int div = 2; div <= number; div++)
+        {
+            while (number % div == 0)
+            {
+                primes.Add(div);
+                number = number / div;
+            }
+        }
+        return primes;
+    }
+
+    static void Main(string[] args)
+    {
+        int[] n = { 12757923, 12878611, 12757923, 15808973, 15780709, 197622519 };
+        // Calculate each of those numbers' prime factors, in parallel
+        var factors = n.AsParallel().Select(PrimeFactors).ToList();
+        // Make a new list showing the smallest factor for each
+        var smallestFactors = factors.Select(thisNumbersFactors => thisNumbersFactors.Min()).ToList();
+        // Find the index that corresponds with the largest of those factors
+        int biggestFactor = smallestFactors.Max();
+        int whatIndexIsThat = smallestFactors.IndexOf(biggestFactor);
+        Console.WriteLine("{0} has the largest minimum prime factor: {1}", n[whatIndexIsThat], biggestFactor);
+        Console.WriteLine(string.Join(" ", factors[whatIndexIsThat]));
+    }
+}
--- a/Task/Parallel-calculations/C-sharp/parallel-calculations-2.cs
+++ b/Task/Parallel-calculations/C-sharp/parallel-calculations-2.cs
@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+private static void Main(string[] args)
+{
+  int j = 0, m = 0;
+  decimal[] n = {12757923, 12878611, 12757923, 15808973, 15780709, 197622519};
+  var l = new List<int>[n.Length];
+
+  Parallel.For(0, n.Length, i => { l[i] = getPrimes(n[i]); });
+
+  for (int i = 0; i<n.Length; i++)
+    if (l[i].Min()>m)
+    {
+      m = l[i].Min();
+      j = i;
+    }
+
+  Console.WriteLine("Number {0} has largest minimal factor:", n[j]);
+  foreach (int list in l[j])
+    Console.Write(" "+list);
+}
--- a/Task/Parallel-calculations/C/parallel-calculations.c
+++ b/Task/Parallel-calculations/C/parallel-calculations.c
@ -0,0 +1,33 @@
+#include <stdio.h>
+#include <omp.h>
+
+int main()
+{
+        int data[] = {12757923, 12878611, 12878893, 12757923, 15808973, 15780709, 197622519};
+        int largest, largest_factor = 0;
+
+        omp_set_num_threads(4);
+        /* "omp parallel for" turns the for loop multithreaded by making each thread
+         * iterating only a part of the loop variable, in this case i; variables declared
+         * as "shared" will be implicitly locked on access
+         */
+        #pragma omp parallel for shared(largest_factor, largest)
+        for (int i = 0; i < 7; i++) {
+                int p, n = data[i];
+
+                for (p = 3; p * p <= n && n % p; p += 2);
+                if (p * p > n) p = n;
+                if (p > largest_factor) {
+                        largest_factor = p;
+                        largest = n;
+                        printf("thread %d: found larger: %d of %d\n",
+                                omp_get_thread_num(), p, n);
+                } else {
+                        printf("thread %d: not larger:   %d of %d\n",
+                                omp_get_thread_num(), p, n);
+                }
+        }
+
+        printf("Largest factor: %d of %d\n", largest_factor, largest);
+        return 0;
+}
--- a/Task/Parallel-calculations/Clojure/parallel-calculations.clj
+++ b/Task/Parallel-calculations/Clojure/parallel-calculations.clj
@ -0,0 +1,14 @@
+(use '[clojure.contrib.lazy-seqs :only [primes]])
+
+(defn lpf [n]
+  [n (or (last
+          (for [p (take-while #(<= (* % %) n) primes)
+                :when (zero? (rem n p))]
+            p))
+         1)])
+
+(->> (range 2 100000)
+     (pmap lpf)
+     (apply max-key second)
+     println
+     time)
--- a/Task/Parallel-calculations/Common-Lisp/parallel-calculations-1.lisp
+++ b/Task/Parallel-calculations/Common-Lisp/parallel-calculations-1.lisp
@ -0,0 +1,25 @@
+(ql:quickload '(lparallel))
+
+(setf lparallel:*kernel* (lparallel:make-kernel 4)) ;; Configure for your system.
+
+(defun factor (n &optional (acc '()))
+  (when (> n 1)
+    (loop with max-d = (isqrt n)
+       for d = 2 then (if (evenp d) (1+ d) (+ d 2)) do
+         (cond ((> d max-d) (return (cons (list n 1) acc)))
+               ((zerop (rem n d))
+                (return (factor (truncate n d)
+                                (if (eq d (caar acc))
+                                    (cons
+                                     (list (caar acc) (1+ (cadar acc)))
+                                     (cdr acc))
+                                    (cons (list d 1) acc)))))))))
+
+(defun max-minimum-factor (numbers)
+  (lparallel:pmap-reduce
+   (lambda (n) (cons n (apply #'min (mapcar #'car (factor n)))))
+   (lambda (a b) (if (> (cdr a) (cdr b)) a b))
+   numbers))
+
+(defun print-max-factor (pair)
+  (format t "~a has the largest minimum factor ~a~%" (car pair) (cdr pair)))
--- a/Task/Parallel-calculations/Common-Lisp/parallel-calculations-2.lisp
+++ b/Task/Parallel-calculations/Common-Lisp/parallel-calculations-2.lisp
@ -0,0 +1,2 @@
+CL-USER> (print-max-factor (max-minimum-factor '(12757923 12878611 12878893 12757923 15808973 15780709 197622519)))
+12878893 has the largest minimum factor 47
--- a/Task/Parallel-calculations/D/parallel-calculations-1.d
+++ b/Task/Parallel-calculations/D/parallel-calculations-1.d
@ -0,0 +1,27 @@
+ulong[] decompose(ulong n) pure nothrow {
+    typeof(return) result;
+    for (ulong i = 2; n >= i * i; i++)
+        for (; n % i == 0; n /= i)
+            result ~= i;
+    if (n != 1)
+        result ~= n;
+    return result;
+}
+
+void main() {
+    import std.stdio, std.algorithm, std.parallelism, std.typecons;
+
+    immutable ulong[] data = [
+        2UL^^59-1, 2UL^^59-1, 2UL^^59-1, 112_272_537_195_293UL,
+        115_284_584_522_153, 115_280_098_190_773,
+        115_797_840_077_099, 112_582_718_962_171,
+        112_272_537_095_293, 1_099_726_829_285_419];
+
+    //auto factors = taskPool.amap!(n => tuple(decompose(n), n))(data);
+    //static enum genPair = (ulong n) pure => tuple(decompose(n), n);
+    static genPair(ulong n) pure { return tuple(decompose(n), n); }
+    auto factors = taskPool.amap!genPair(data);
+
+    auto pairs = factors.map!(p => tuple(p[0].reduce!min, p[1]));
+    writeln("N. with largest min factor: ", pairs.reduce!max[1]);
+}
--- a/Task/Parallel-calculations/D/parallel-calculations-2.d
+++ b/Task/Parallel-calculations/D/parallel-calculations-2.d
@ -0,0 +1,85 @@
+import std.stdio, std.math, std.algorithm, std.typecons,
+       core.thread, core.stdc.time;
+
+final class MinFactor: Thread {
+    private immutable ulong num;
+    private ulong[] fac;
+    private ulong minFac;
+
+    this(in ulong n) /*pure nothrow*/ {
+        super(&run);
+        num = n;
+        fac = new ulong[0];
+    }
+
+    @property ulong number() const pure nothrow {
+        return num;
+    }
+
+    @property const(ulong[]) factors() const pure nothrow {
+        return fac;
+    }
+
+    @property ulong minFactor() const pure nothrow {
+        return minFac;
+    }
+
+    private void run() {
+        immutable clock_t begin = clock;
+        switch (num) {
+            case 0: fac = [];
+                    break;
+
+            case 1: fac = [1];
+                    break;
+
+            default:
+                uint limit = cast(uint)(1 + double(num).sqrt);
+                ulong n = num;
+                for (ulong divi = 3; divi < limit; divi += 2) {
+                    if (n == 1)
+                        break;
+                    if ((n % divi) == 0) {
+                        while ((n > 1) && ((n % divi) == 0)) {
+                            fac ~= divi;
+                            n /= divi;
+                        }
+                        limit = cast(uint)(1 + double(n).sqrt);
+                    }
+                }
+                if (n > 1)
+                    fac ~= n;
+        }
+        minFac = fac.reduce!min;
+        immutable clock_t end = clock;
+        writefln("num: %20d --> min. factor: %20d  ticks(%7d -> %7d)",
+                 num, minFac, begin, end);
+    }
+}
+
+void main() {
+    immutable ulong[] numbers = [
+        2UL^^59-1, 2UL^^59-1, 2UL^^59-1, 112_272_537_195_293UL,
+        115_284_584_522_153, 115_280_098_190_773,
+        115_797_840_077_099, 112_582_718_962_171,
+        112_272_537_095_293, 1_099_726_829_285_419];
+
+    auto tGroup = new ThreadGroup;
+    foreach (const n; numbers)
+        tGroup.add(new MinFactor(n));
+
+    writeln("Minimum factors for respective numbers are:");
+    foreach (t; tGroup)
+        t.start;
+    tGroup.joinAll;
+
+    auto maxMin = tuple(0UL, [0UL], 0UL);
+    foreach (thread; tGroup) {
+        auto s = cast(MinFactor)thread;
+        if (s !is null && maxMin[2] < s.minFactor)
+            maxMin = tuple(s.number, s.factors.dup, s.minFactor);
+    }
+
+    writefln("Number with largest min. factor is %16d," ~
+             " with factors:\n\t%s", maxMin.tupleof);
+}
--- a/Task/Parallel-calculations/Delphi/parallel-calculations.delphi
+++ b/Task/Parallel-calculations/Delphi/parallel-calculations.delphi
@ -0,0 +1,94 @@
+program Parallel_calculations;
+
+{$APPTYPE CONSOLE}
+
+uses
+  System.SysUtils,
+  System.Threading,
+  Velthuis.BigIntegers;
+
+function IsPrime(n: BigInteger): Boolean;
+var
+  i: BigInteger;
+begin
+  if n <= 1 then
+    exit(False);
+
+  i := 2;
+  while i < BigInteger.Sqrt(n) do
+  begin
+    if n mod i = 0 then
+      exit(False);
+    inc(i);
+  end;
+
+  Result := True;
+end;
+
+function GetPrimes(n: BigInteger): TArray<BigInteger>;
+var
+  divisor, next, rest: BigInteger;
+begin
+  divisor := 2;
+  next := 3;
+  rest := n;
+  while (rest <> 1) do
+  begin
+    while (rest mod divisor = 0) do
+    begin
+      SetLength(Result, Length(Result) + 1);
+      Result[High(Result)] := divisor;
+      rest := rest div divisor;
+    end;
+    divisor := next;
+    next := next + 2;
+  end;
+end;
+
+function Min(l: TArray<BigInteger>): BigInteger;
+begin
+  if Length(l) = 0 then
+    exit(0);
+
+  Result := l[0];
+  for var v in l do
+    if v < result then
+      Result := v;
+end;
+
+const
+  n: array of Uint64 = [12757923, 12878611, 12757923, 15808973, 15780709, 197622519];
+
+var
+  m: BigInteger;
+  len, j, i: Uint64;
+  l: TArray<TArray<BigInteger>>;
+
+begin
+  j := 0;
+  m := 0;
+  len := length(n);
+  SetLength(l, len);
+
+  TParallel.for (0, len - 1,
+    procedure(i: Integer)
+    begin
+      l[i] := getPrimes(n[i]);
+    end);
+
+  for i := 0 to len - 1 do
+  begin
+    var _min := Min(l[i]);
+    if _min > m then
+    begin
+      m := _min;
+      j := i;
+    end;
+  end;
+
+  writeln('Number ', n[j].ToString, ' has largest minimal factor:');
+  for var v in l[j] do
+    write(' ', v.ToString);
+
+  readln;
+end.
--- a/Task/Parallel-calculations/Erlang/parallel-calculations.erl
+++ b/Task/Parallel-calculations/Erlang/parallel-calculations.erl
@ -0,0 +1,42 @@
+-module( parallel_calculations ).
+
+-export( [fun_results/2, task/0] ).
+
+fun_results( Fun, Datas ) ->
+        My_pid = erlang:self(),
+	Pids = [fun_spawn( Fun, X, My_pid ) || X <- Datas],
+	[fun_receive(X) || X <- Pids].
+
+task() ->
+    Numbers = [12757923, 12878611, 12757923, 15808973, 15780709, 197622519],
+    Results = fun_results( fun factors/1, Numbers ),
+    Min_results = [lists:min(X) || X <- Results],
+    {_Max_min_factor, Number} = lists:max( lists:zip(Min_results, Numbers) ),
+    {Number, Factors} = lists:keyfind( Number, 1, lists:zip(Numbers, Results) ),
+    io:fwrite( "~p has largest minimal factor among its prime factors ~p~n", [Number, Factors] ).
+
+
+
+factors(N) -> factors(N,2,[]).
+
+factors(1,_,Acc) -> Acc;
+factors(N,K,Acc) when N rem K == 0 -> factors(N div K,K, [K|Acc]);
+factors(N,K,Acc) -> factors(N,K+1,Acc).
+
+fun_receive( Pid ) ->
+        receive
+        {ok, Result, Pid} -> Result;
+	{Type, Error, Pid} -> erlang:Type( Error )
+        end.
+
+fun_spawn( Fun, Data, My_pid ) ->
+        erlang:spawn( fun() ->
+                Result = try
+                       {ok, Fun(Data), erlang:self()}
+
+		       catch
+	               Type:Error -> {Type, Error, erlang:self()}
+
+		       end,
+	        My_pid ! Result
+        end ).
--- a/Task/Parallel-calculations/F-Sharp/parallel-calculations.fs
+++ b/Task/Parallel-calculations/F-Sharp/parallel-calculations.fs
@ -0,0 +1,19 @@
+open System
+open PrimeDecomp // Has the decompose function from the Prime decomposition task
+
+let data = [112272537195293L; 112582718962171L; 112272537095293L; 115280098190773L; 115797840077099L; 1099726829285419L]
+let decomp num = decompose num 2L
+
+let largestMinPrimeFactor (numbers: int64 list) =
+    let decompDetails = Async.Parallel [ for n in numbers -> async { return n, decomp n } ] // Compute the number and its prime decomposition list
+                        |> Async.RunSynchronously                                           // Start and wait for all parallel computations to complete.
+                        |> Array.sortBy (snd >> List.min >> (~-))                           // Sort in descending order, based on the min prime decomp number.
+
+    decompDetails.[0]
+
+let showLargestMinPrimeFactor numbers =
+    let number, primeList = largestMinPrimeFactor numbers
+    printf "Number %d has largest minimal factor:\n    " number
+    List.iter (printf "%d ") primeList
+
+showLargestMinPrimeFactor data
--- a/Task/Parallel-calculations/Factor/parallel-calculations-1.factor
+++ b/Task/Parallel-calculations/Factor/parallel-calculations-1.factor
@ -0,0 +1,18 @@
+USING: io kernel fry locals sequences arrays math.primes.factors math.parser channels threads prettyprint ;
+IN: <filename>
+
+:: map-parallel ( seq quot -- newseq )
+    <channel> :> ch
+    seq [ '[ _ quot call ch to ] "factors" spawn ] { } map-as
+    dup length [ ch from ] replicate nip ;
+
+{ 576460752303423487 576460752303423487
+  576460752303423487 112272537195293
+  115284584522153 115280098190773
+  115797840077099 112582718962171
+  112272537095293 1099726829285419 }
+dup [ factors ] map-parallel
+dup [ infimum ] map dup supremum
+swap index swap dupd nth -rot swap nth
+"Number with largest min. factor is " swap number>string append
+", with factors: " append write .
--- a/Task/Parallel-calculations/Factor/parallel-calculations-2.factor
+++ b/Task/Parallel-calculations/Factor/parallel-calculations-2.factor
@ -0,0 +1,7 @@
+USING: kernel io prettyprint sequences arrays math.primes.factors math.parser concurrency.combinators ;
+{ 576460752303423487 576460752303423487 576460752303423487 112272537195293
+  115284584522153 115280098190773 115797840077099 112582718962171 }
+dup [ factors ] parallel-map dup [ infimum ] map dup supremum
+swap index swap dupd nth -rot swap nth
+"Number with largest min. factor is " swap number>string append
+", with factors: " append write .
--- a/Task/Parallel-calculations/Fortran/parallel-calculations.f
+++ b/Task/Parallel-calculations/Fortran/parallel-calculations.f
@ -0,0 +1,54 @@
+program Primes
+
+    use ISO_FORTRAN_ENV
+
+    implicit none
+
+    integer(int64), dimension(7) :: data = (/2099726827, 15780709, 1122725370, 15808973, 576460741, 12878611, 12757923/)
+    integer(int64), dimension(100) :: outprimes
+    integer(int64) :: largest_factor = 0, largest = 0, minim = 0, val = 0
+    integer(int16) :: count = 0, OMP_GET_THREAD_NUM
+
+    call omp_set_num_threads(4);
+    !$omp parallel do private(val,outprimes,count) shared(data,largest_factor,largest)
+    do val = 1, 7
+        outprimes = 0
+        call find_factors(data(val), outprimes, count)
+        minim = minval(outprimes(1:count))
+        if (minim > largest_factor) then
+            largest_factor = minim
+            largest = data(val)
+        end if
+        write(*, fmt = '(A7,i0,A2,i12,100i12)') 'Thread ', OMP_GET_THREAD_NUM(), ': ', data(val), outprimes(1:count)
+    end do
+    !$omp end parallel do
+
+    write(*, fmt = '(i0,A26,i0)') largest, ' have the Largest factor: ', largest_factor
+
+    return
+
+contains
+
+    subroutine find_factors(n, d, count)
+        integer(int64), intent(in) :: n
+        integer(int64), dimension(:), intent(out) :: d
+        integer(int16), intent(out) :: count
+        integer(int16) :: i
+        integer(int64) :: div, next, rest
+
+        i = 1
+        div = 2; next = 3; rest = n
+
+        do while (rest /= 1)
+            do while (mod(rest, div) == 0)
+                d(i) = div
+                i = i + 1
+                rest = rest / div
+            end do
+            div = next
+            next = next + 2
+        end do
+        count = i - 1
+    end subroutine find_factors
+
+end program Primes
--- a/Task/Parallel-calculations/Go/parallel-calculations.go
+++ b/Task/Parallel-calculations/Go/parallel-calculations.go
@ -0,0 +1,96 @@
+package main
+
+import (
+    "fmt"
+    "math/big"
+)
+
+// collection of numbers.  A slice is used for the collection.
+// The elements are big integers, since that's what the function Primes
+// uses (as was specified by the Prime decomposition task.)
+var numbers = []*big.Int{
+    big.NewInt(12757923),
+    big.NewInt(12878611),
+    big.NewInt(12878893),
+    big.NewInt(12757923),
+    big.NewInt(15808973),
+    big.NewInt(15780709),
+}
+
+// main just calls the function specified by the task description and
+// prints results.  note it allows for multiple numbers with the largest
+// minimal factor.  the task didn't specify to handle this, but obviously
+// it's possible.
+func main() {
+    rs := lmf(numbers)
+    fmt.Println("largest minimal factor:", rs[0].decomp[0])
+    for _, r := range rs {
+        fmt.Println(r.number, "->", r.decomp)
+    }
+}
+
+// this type associates a number with it's prime decomposition.
+// the type is neccessary so that they can be sent together over
+// a Go channel, but it turns out to be convenient as well for
+// the return type of lmf.
+type result struct {
+    number *big.Int
+    decomp []*big.Int
+}
+
+// the function specified by the task description, "largest minimal factor."
+func lmf([]*big.Int) []result {
+    // construct result channel and start a goroutine to decompose each number.
+    // goroutines run in parallel as CPU cores are available.
+    rCh := make(chan result)
+    for _, n := range numbers {
+        go decomp(n, rCh)
+    }
+
+    // collect results.  <-rCh returns a single result from the result channel.
+    // we know how many results to expect so code here collects exactly that
+    // many results, and accumulates a list of those with the largest
+    // minimal factor.
+    rs := []result{<-rCh}
+    for i := 1; i < len(numbers); i++ {
+        switch r := <-rCh; r.decomp[0].Cmp(rs[0].decomp[0]) {
+        case 1:
+            rs = rs[:1]
+            rs[0] = r
+        case 0:
+            rs = append(rs, r)
+        }
+    }
+    return rs
+}
+
+// decomp is the function run as a goroutine.  multiple instances of this
+// function will run concurrently, one for each number being decomposed.
+// it acts as a driver for Primes, calling Primes as needed, packaging
+// the result, and sending the packaged result on the channel.
+// "as needed" turns out to mean sending Primes a copy of n, as Primes
+// as written is destructive on its argument.
+func decomp(n *big.Int, rCh chan result) {
+    rCh <- result{n, Primes(new(big.Int).Set(n))}
+}
+
+// code below copied from Prime decomposition task
+var (
+    ZERO = big.NewInt(0)
+    ONE  = big.NewInt(1)
+)
+
+func Primes(n *big.Int) []*big.Int {
+    res := []*big.Int{}
+    mod, div := new(big.Int), new(big.Int)
+    for i := big.NewInt(2); i.Cmp(n) != 1; {
+        div.DivMod(n, i, mod)
+        for mod.Cmp(ZERO) == 0 {
+            res = append(res, new(big.Int).Set(i))
+            n.Set(div)
+            div.DivMod(n, i, mod)
+        }
+        i.Add(i, ONE)
+    }
+    return res
+}
--- a/Task/Parallel-calculations/Haskell/parallel-calculations-1.hs
+++ b/Task/Parallel-calculations/Haskell/parallel-calculations-1.hs
@ -0,0 +1,47 @@
+import Control.Parallel.Strategies (parMap, rdeepseq)
+import Control.DeepSeq (NFData)
+import Data.List (maximumBy)
+import Data.Function (on)
+
+nums :: [Integer]
+nums =
+  [ 112272537195293
+  , 112582718962171
+  , 112272537095293
+  , 115280098190773
+  , 115797840077099
+  , 1099726829285419
+  ]
+
+lowestFactor
+  :: Integral a
+  => a -> a -> a
+lowestFactor s n
+  | even n = 2
+  | otherwise = head y
+  where
+    y =
+      [ x
+      | x <- [s .. ceiling . sqrt $ fromIntegral n] ++ [n]
+      , n `rem` x == 0
+      , odd x ]
+
+primeFactors
+  :: Integral a
+  => a -> a -> [a]
+primeFactors l n = f n l []
+  where
+    f n l xs =
+      if n > 1
+        then f (n `div` l) (lowestFactor (max l 3) (n `div` l)) (l : xs)
+        else xs
+
+minPrimes
+  :: (Control.DeepSeq.NFData a, Integral a)
+  => [a] -> (a, [a])
+minPrimes ns =
+  (\(x, y) -> (x, primeFactors y x)) $
+  maximumBy (compare `on` snd) $ zip ns (parMap rdeepseq (lowestFactor 3) ns)
+
+main :: IO ()
+main = print $ minPrimes nums
--- a/Task/Parallel-calculations/Haskell/parallel-calculations-2.hs
+++ b/Task/Parallel-calculations/Haskell/parallel-calculations-2.hs
@ -0,0 +1,17 @@
+procedure main(A)
+    threads := []
+    L := list(*A)
+    every i := 1 to *A do put(threads, thread L[i] := primedecomp(A[i]))
+    every wait(!threads)
+
+    maxminF := L[maxminI := 1][1]
+    every i := 2 to *L do if maxminF <:= L[i][1] then maxminI := i
+    every writes((A[maxminI]||": ")|(!L[maxminI]||" ")|"\n")
+end
+
+procedure primedecomp(n)         #: return a list of factors
+    every put(F := [], genfactors(n))
+    return F
+end
+
+link factors
--- a/Task/Parallel-calculations/J/parallel-calculations.j
+++ b/Task/Parallel-calculations/J/parallel-calculations.j
@ -0,0 +1,7 @@
+   numbers =. 12757923 12878611 12878893 12757923 15808973 15780709 197622519
+   factors =. q:&.> parallelize 2 numbers NB. q: is parallelized here
+   ind =. (i. >./) <./@> factors
+   ind { numbers ;"_1 factors
+┌────────┬───────────┐
+│12878611│47 101 2713│
+└────────┴───────────┘
--- a/Task/Parallel-calculations/Java/parallel-calculations.java
+++ b/Task/Parallel-calculations/Java/parallel-calculations.java
@ -0,0 +1,37 @@
+import static java.lang.System.out;
+import static java.util.Arrays.stream;
+import static java.util.Comparator.comparing;
+
+public interface ParallelCalculations {
+    public static final long[] NUMBERS = {
+      12757923,
+      12878611,
+      12878893,
+      12757923,
+      15808973,
+      15780709,
+      197622519
+    };
+
+    public static void main(String... arguments) {
+      stream(NUMBERS)
+        .unordered()
+        .parallel()
+        .mapToObj(ParallelCalculations::minimalPrimeFactor)
+        .max(comparing(a -> a[0]))
+        .ifPresent(res -> out.printf(
+          "%d has the largest minimum prime factor: %d%n",
+          res[1],
+          res[0]
+        ));
+    }
+
+    public static long[] minimalPrimeFactor(long n) {
+      for (long i = 2; n >= i * i; i++) {
+        if (n % i == 0) {
+          return new long[]{i, n};
+        }
+      }
+      return new long[]{n, n};
+    }
+}
--- a/Task/Parallel-calculations/JavaScript/parallel-calculations-1.js
+++ b/Task/Parallel-calculations/JavaScript/parallel-calculations-1.js
@ -0,0 +1,16 @@
+var onmessage = function(event) {
+    postMessage({"n" : event.data.n,
+                 "factors" : factor(event.data.n),
+                 "id" : event.data.id});
+};
+
+function factor(n) {
+    var factors = [];
+    for(p = 2; p <= n; p++) {
+        if((n % p) == 0) {
+            factors[factors.length] = p;
+            n /= p;
+        }
+    }
+    return factors;
+}
--- a/Task/Parallel-calculations/JavaScript/parallel-calculations-2.js
+++ b/Task/Parallel-calculations/JavaScript/parallel-calculations-2.js
@ -0,0 +1,38 @@
+var numbers = [12757923, 12878611, 12757923, 15808973, 15780709, 197622519];
+var workers = [];
+var worker_count = 0;
+
+var results = [];
+
+for(var i = 0; i < numbers.length; i++) {
+    worker_count++;
+    workers[i] = new Worker("parallel_worker.js");
+    workers[i].onmessage = accumulate;
+    workers[i].postMessage({n: numbers[i], id: i});
+}
+
+function accumulate(event) {
+    n = event.data.n;
+    factors = event.data.factors;
+    id = event.data.id;
+    console.log(n + " : " + factors);
+    results[id] = {n:n, factors:factors};
+    // Cleanup - kill the worker and countdown until all work is done
+    workers[id].terminate();
+    worker_count--;
+    if(worker_count == 0)
+	reduce();
+}
+
+function reduce() {
+    answer = 0;
+    for(i = 1; i < results.length; i++) {
+	min = results[i].factors[0];
+	largest_min = results[answer].factors[0];
+	if(min > largest_min)
+	    answer = i;
+    }
+    n = results[answer].n;
+    factors = results[answer].factors;
+    console.log("The number with the relatively largest factors is: " + n + " : " + factors);
+}
--- a/Task/Parallel-calculations/Julia/parallel-calculations.julia
+++ b/Task/Parallel-calculations/Julia/parallel-calculations.julia
@ -0,0 +1,21 @@
+using Primes
+
+factortodict(d, n) = (d[minimum(collect(keys(factor(n))))] = n)
+
+# Numbers are from from the Raku example.
+numbers = [64921987050997300559,  70251412046988563035,  71774104902986066597,
+           83448083465633593921,  84209429893632345702,  87001033462961102237,
+           87762379890959854011,  89538854889623608177,  98421229882942378967,
+           259826672618677756753, 262872058330672763871, 267440136898665274575,
+           278352769033314050117, 281398154745309057242, 292057004737291582187]
+
+mins = Dict()
+
+Base.@sync(
+    Threads.@threads for n in numbers
+        factortodict(mins, n)
+    end
+)
+
+answer = maximum(keys(mins))
+println("The number that has the largest minimum prime factor is $(mins[answer]), with a smallest factor of $answer")
--- a/Task/Parallel-calculations/Kotlin/parallel-calculations.kotlin
+++ b/Task/Parallel-calculations/Kotlin/parallel-calculations.kotlin
@ -0,0 +1,52 @@
+// version 1.1.51
+
+import java.util.stream.Collectors
+
+/* returns the number itself, its smallest prime factor and all its prime factors */
+fun primeFactorInfo(n: Int): Triple<Int, Int, List<Int>> {
+    if (n <= 1) throw IllegalArgumentException("Number must be more than one")
+    if (isPrime(n)) return Triple(n, n, listOf(n))
+    val factors = mutableListOf<Int>()
+    var factor = 2
+    var nn = n
+    while (true) {
+        if (nn % factor == 0) {
+            factors.add(factor)
+            nn /= factor
+            if (nn == 1) return Triple(n, factors.min()!!, factors)
+            if (isPrime(nn)) factor = nn
+        }
+        else if (factor >= 3) factor += 2
+        else factor = 3
+    }
+}
+
+fun isPrime(n: Int) : Boolean {
+    if (n < 2) return false
+    if (n % 2 == 0) return n == 2
+    if (n % 3 == 0) return n == 3
+    var d = 5
+    while (d * d <= n) {
+        if (n % d == 0) return false
+        d += 2
+        if (n % d == 0) return false
+        d += 4
+    }
+    return true
+}
+
+fun main(args: Array<String>) {
+    val numbers = listOf(
+        12757923, 12878611, 12878893, 12757923, 15808973, 15780709, 197622519
+    )
+    val info = numbers.stream()
+                      .parallel()
+                      .map { primeFactorInfo(it) }
+                      .collect(Collectors.toList())
+    val maxFactor = info.maxBy { it.second }!!.second
+    val results = info.filter { it.second == maxFactor }
+    println("The following number(s) have the largest minimal prime factor of $maxFactor:")
+    for (result in results) {
+        println("  ${result.first} whose prime factors are ${result.third}")
+    }
+}
--- a/Task/Parallel-calculations/Mathematica/parallel-calculations.math
+++ b/Task/Parallel-calculations/Mathematica/parallel-calculations.math
@ -0,0 +1 @@
+hasSmallestFactor[data_List]:=Sort[Transpose[{ParallelTable[FactorInteger[x][[1, 1]], {x, data}],data}]][[1, 2]]
--- a/Task/Parallel-calculations/Nim/parallel-calculations-1.nim
+++ b/Task/Parallel-calculations/Nim/parallel-calculations-1.nim
@ -0,0 +1,54 @@
+import strformat, strutils, threadpool
+
+const Numbers = [576460752303423487,
+                 576460752303423487,
+                 576460752303423487,
+                 112272537195293,
+                 115284584522153,
+                 115280098190773,
+                 115797840077099,
+                 112582718962171,
+                 299866111963290359]
+
+
+proc lowestFactor(n: int64): int64 =
+  if n mod 2 == 0: return 2
+  if n mod 3 == 0: return 3
+  var p = 5
+  var delta = 2
+  while p * p < n:
+    if n mod p == 0: return p
+    inc p, delta
+    delta = 6 - delta
+  result = n
+
+
+proc factors(n, lowest: int64): seq[int64] =
+  var n = n
+  var lowest = lowest
+  while true:
+    result.add lowest
+    n = n div lowest
+    if n == 1: break
+    lowest = lowestFactor(n)
+
+
+# Launch a thread for each number to process.
+var responses: array[Numbers.len, FlowVar[int64]]
+for i, n in Numbers:
+  responses[i] = spawn lowestFactor(n)
+
+# Read the results and find the largest minimum prime factor.
+var maxMinfact = 0i64
+var maxIdx: int
+for i in 0..responses.high:
+  let minfact = ^responses[i]   # Blocking read.
+  echo &"For n = {Numbers[i]}, the lowest factor is {minfact}."
+  if minfact > maxMinfact:
+    maxMinfact = minfact
+    maxIdx = i
+let result = Numbers[maxIdx]
+
+echo ""
+echo "The first number with the largest minimum prime factor is: ", result
+echo "Its factors are: ", result.factors(maxMinfact).join(", ")
--- a/Task/Parallel-calculations/Nim/parallel-calculations-2.nim
+++ b/Task/Parallel-calculations/Nim/parallel-calculations-2.nim
@ -0,0 +1,51 @@
+import sequtils, strutils, threadpool
+
+{.experimental: "parallel".}
+
+const Numbers = [576460752303423487,
+                 576460752303423487,
+                 576460752303423487,
+                 112272537195293,
+                 115284584522153,
+                 115280098190773,
+                 115797840077099,
+                 112582718962171,
+                 299866111963290359]
+
+
+proc lowestFactor(n: int64): int64 =
+  if n mod 2 == 0: return 2
+  if n mod 3 == 0: return 3
+  var p = 5
+  var delta = 2
+  while p * p < n:
+    if n mod p == 0: return p
+    inc p, delta
+    delta = 6 - delta
+  result = n
+
+
+proc factors(n, lowest: int64): seq[int64] =
+  var n = n
+  var lowest = lowest
+  while true:
+    result.add lowest
+    n = n div lowest
+    if n == 1: break
+    lowest = lowestFactor(n)
+
+
+# Launch the threads.
+var results: array[Numbers.len, int64]    # To store the results.
+parallel:
+  for i, n in Numbers:
+    results[i] = spawn lowestFactor(n)
+
+# Find the minimum prime factor and the first number with this minimum factor.
+let maxIdx = results.maxIndex()
+let maxMinfact = results[maxIdx]
+let result = Numbers[maxIdx]
+
+echo ""
+echo "The first number with the largest minimum prime factor is: ", result
+echo "Its factors are: ", result.factors(maxMinfact).join(", ")
--- a/Task/Parallel-calculations/Oforth/parallel-calculations.fth
+++ b/Task/Parallel-calculations/Oforth/parallel-calculations.fth
@ -0,0 +1,3 @@
+import: parallel
+
+: largeMinFactor  dup mapParallel(#factors) zip maxFor(#[ second first ]) ;
--- a/Task/Parallel-calculations/OoRexx/parallel-calculations-1.rexx
+++ b/Task/Parallel-calculations/OoRexx/parallel-calculations-1.rexx
@ -0,0 +1,15 @@
+/* Concurrency in ooRexx. Example of early reply */
+object1 = .example~new
+object2 = .example~new
+say object1~primes(1,11111111111,11111111114)
+say object2~primes(2,11111111111,11111111114)
+say "Main ended at" time()
+exit
+::class example
+::method primes
+use arg which,bot,top
+reply "Start primes"which':' time()
+Select
+  When which=1 Then Call pd1 bot top
+  When which=2 Then Call pd2 bot top
+  End
--- a/Task/Parallel-calculations/OoRexx/parallel-calculations-2.rexx
+++ b/Task/Parallel-calculations/OoRexx/parallel-calculations-2.rexx
@ -0,0 +1,45 @@
+/*PD1 REXX pgm does prime decomposition of a range of positive integers (with a prime count)*/
+Call Time 'R'
+numeric digits 1000                              /*handle thousand digits for the powers*/
+parse arg  bot  top  step   base  add            /*get optional arguments from the C.L. */
+if  bot==''   then do;  bot=1;  top=100;  end    /*no  BOT given?  Then use the default.*/
+if  top==''   then              top=bot          /* "  TOP?  "       "   "   "     "    */
+if step==''   then step=  1                      /* " STEP?  "       "   "   "     "    */
+if add ==''   then  add= -1                      /* "  ADD?  "       "   "   "     "    */
+tell= top>0;       top=abs(top)                  /*if TOP is negative, suppress displays*/
+w=length(top)                                    /*get maximum width for aligned display*/
+if base\==''  then w=length(base**top)           /*will be testing powers of two later? */
+commat.=left('', 7);   commat.0="{unity}";   commat.1='[prime]' /*some literals:  pad;  prime (or not).*/
+numeric digits max(9, w+1)                       /*maybe increase the digits precision. */
+hash=0                                              /*hash:    is the number of primes found. */
+        do n=bot  to top  by step                /*process a single number  or  a range.*/
+        ?=n;  if base\==''  then ?=base**n + add /*should we perform a "Mercenne" test? */
+        pf=factr(?);      f=words(pf)            /*get prime factors; number of factors.*/
+        if f==1  then hash=hash+1                      /*Is N prime?  Then bump prime counter.*/
+        if tell  then say right(?,w)   right('('f")",9)   'prime factors: '     commat.f     pf
+        end   /*n*/
+say
+ps= 'primes';    if p==1  then ps= "prime"       /*setup for proper English in sentence.*/
+say right(hash, w+9+1)       ps       'found.'      /*display the number of primes found.  */
+Say 'PD1 took' time('E') 'seconds'
+exit                                             /*stick a fork in it,  we're all done. */
+/*--------------------------------------------------------------------------------------*/
+factr: procedure;  parse arg x 1 d,dollar             /*set X, D  to argument 1;  dollar  to null.*/
+if x==1  then return ''                          /*handle the special case of   X = 1.  */
+       do  while x//2==0;  dollar=dollar 2;  x=x%2;  end   /*append all the  2  factors of new  X.*/
+       do  while x//3==0;  dollar=dollar 3;  x=x%3;  end   /*   "    "   "   3     "     "  "   " */
+       do  while x//5==0;  dollar=dollar 5;  x=x%5;  end   /*   "    "   "   5     "     "  "   " */
+       do  while x//7==0;  dollar=dollar 7;  x=x%7;  end   /*   "    "   "   7     "     "  "   " */
+                                                 /*                                  ___*/
+q=1;   do  while q<=x;  q=q*4;  end              /*these two lines compute integer  v X */
+r=0;   do  while q>1;   q=q%4;  _=d-r-q;  r=r%2;   if _>=0  then do; d=_; r=r+q; end;  end
+
+       do j=11  by 6  to r                       /*insure that  J  isn't divisible by 3.*/
+       parse var j  ''  -1  _                    /*obtain the last decimal digit of  J. */
+       if _\==5  then  do  while x//j==0;  dollar=dollar j;  x=x%j;  end     /*maybe reduce by J. */
+       if _ ==3  then iterate                    /*Is next  Y  is divisible by 5?  Skip.*/
+       y=j+2;          do  while x//y==0;  dollar=dollar y;  x=x%y;  end     /*maybe reduce by J. */
+       end   /*j*/
+                                                 /* [?]  The dollar list has a leading blank.*/
+if x==1  then return dollar                           /*Is residual=unity? Then don't append.*/
+              return dollar x                         /*return   dollar   with appended residual. */
--- a/Task/Parallel-calculations/OoRexx/parallel-calculations-3.rexx
+++ b/Task/Parallel-calculations/OoRexx/parallel-calculations-3.rexx
@ -0,0 +1,50 @@
+/*PD2 REXX pgm does prime decomposition of a range of positive integers (with a prime count)*/
+Call time 'R'
+numeric digits 1000                              /*handle thousand digits for the powers*/
+parse arg  bot  top  step   base  add            /*get optional arguments from the C.L. */
+if  bot==''   then do;  bot=1;  top=100;  end    /*no  BOT given?  Then use the default.*/
+if  top==''   then              top=bot          /* "  TOP?  "       "   "   "     "    */
+if step==''   then step=  1                      /* " STEP?  "       "   "   "     "    */
+if add ==''   then  add= -1                      /* "  ADD?  "       "   "   "     "    */
+tell= top>0;       top=abs(top)                  /*if TOP is negative, suppress displays*/
+w=length(top)                                    /*get maximum width for aligned display*/
+if base\==''  then w=length(base**top)           /*will be testing powers of two later? */
+commat.=left('', 7);   commat.0="{unity}";   commat.1='[prime]' /*some literals:  pad;  prime (or not).*/
+numeric digits max(9, w+1)                       /*maybe increase the digits precision. */
+hash=0                                              /*hash:    is the number of primes found. */
+        do n=bot  to top  by step                /*process a single number  or  a range.*/
+        ?=n;  if base\==''  then ?=base**n + add /*should we perform a "Mercenne" test? */
+        pf=factr(?);      f=words(pf)            /*get prime factors; number of factors.*/
+        if f==1  then hash=hash+1                      /*Is N prime?  Then bump prime counter.*/
+        if tell  then say right(?,w)   right('('f")",9)   'prime factors: '     commat.f     pf
+        end   /*n*/
+say
+ps= 'primes';    if p==1  then ps= "prime"       /*setup for proper English in sentence.*/
+say right(hash, w+9+1)       ps       'found.'      /*display the number of primes found.  */
+Say 'PD2 took' time('E') 'seconds'
+exit                                             /*stick a fork in it,  we're all done. */
+/*--------------------------------------------------------------------------------------*/
+factr: procedure;  parse arg x 1 d,dollar             /*set X, D  to argument 1;  dollar  to null.*/
+if x==1  then return ''                          /*handle the special case of   X = 1.  */
+       do  while x// 2==0;  dollar=dollar  2;  x=x%2;  end /*append all the  2  factors of new  X.*/
+       do  while x// 3==0;  dollar=dollar  3;  x=x%3;  end /*   "    "   "   3     "     "  "   " */
+       do  while x// 5==0;  dollar=dollar  5;  x=x%5;  end /*   "    "   "   5     "     "  "   " */
+       do  while x// 7==0;  dollar=dollar  7;  x=x%7;  end /*   "    "   "   7     "     "  "   " */
+       do  while x//11==0;  dollar=dollar 11;  x=x%11; end /*   "    "   "  11     "     "  "   " */    /* ?¦¦¦¦ added.*/
+       do  while x//13==0;  dollar=dollar 13;  x=x%13; end /*   "    "   "  13     "     "  "   " */    /* ?¦¦¦¦ added.*/
+       do  while x//17==0;  dollar=dollar 17;  x=x%17; end /*   "    "   "  17     "     "  "   " */    /* ?¦¦¦¦ added.*/
+       do  while x//19==0;  dollar=dollar 19;  x=x%19; end /*   "    "   "  19     "     "  "   " */    /* ?¦¦¦¦ added.*/
+       do  while x//23==0;  dollar=dollar 23;  x=x%23; end /*   "    "   "  23     "     "  "   " */    /* ?¦¦¦¦ added.*/
+                                                 /*                                  ___*/
+q=1;   do  while q<=x;  q=q*4;  end              /*these two lines compute integer  v X */
+r=0;   do  while q>1;   q=q%4;  _=d-r-q;  r=r%2;   if _>=0  then do; d=_; r=r+q; end;  end
+
+       do j=29  by 6  to r                       /*insure that  J  isn't divisible by 3.*/    /* ?¦¦¦¦ changed.*/
+       parse var j  ''  -1  _                    /*obtain the last decimal digit of  J. */
+       if _\==5  then  do  while x//j==0;  dollar=dollar j;  x=x%j;  end     /*maybe reduce by J. */
+       if _ ==3  then iterate                    /*Is next  Y  is divisible by 5?  Skip.*/
+       y=j+2;          do  while x//y==0;  dollar=dollar y;  x=x%y;  end     /*maybe reduce by J. */
+       end   /*j*/
+                                                 /* [?]  The dollar list has a leading blank.*/
+if x==1  then return dollar                           /*Is residual=unity? Then don't append.*/
+              return dollar x                         /*return   dollar   with appended residual. */
--- a/Task/Parallel-calculations/OxygenBasic/parallel-calculations.basic
+++ b/Task/Parallel-calculations/OxygenBasic/parallel-calculations.basic
@ -0,0 +1,181 @@
+'CONFIGURATION
+'=============
+
+% max     8192  'Maximum amount of Prime Numbers (must be 2^n) (excluding 1 and 2)
+% cores   4     'CPU cores available (limited to 4 here)
+% share   2048  'Amount of numbers allocated to each core
+
+'SETUP
+'=====
+
+'SOURCE DATA BUFFERS
+
+sys primes[max]
+sys numbers[max]
+
+'RESULT BUFFER
+
+double pp[max] 'main thread
+
+
+'MULTITHREADING AND TIMING API
+'=============================
+
+extern lib "kernel32.dll"
+'
+void   QueryPerformanceCounter(quad*c)
+void   QueryPerformanceFrequency(quad*freq)
+sys    CreateThread (sys lpThreadAttributes, dwStackSize, lpStartAddress, lpParameter, dwCreationFlags, *lpThreadId)
+dword  WaitForMultipleObjects(sys nCount,*lpHandles, bWaitAll, dwMilliseconds)
+bool   CloseHandle(sys hObject)
+void   Sleep(sys dwMilliSeconds)
+'
+quad freq,t1,t2
+QueryPerformanceFrequency freq
+
+
+'MACROS AND FUNCTIONS
+'====================
+
+
+macro FindPrimes(p)
+'==================
+finit
+sys n=1
+sys c,k
+do
+  n+=2
+  if c>=max then exit do
+  '
+  'IS IT DIVISIBLE BE ANY PREVIOUS PRIME
+  '
+  for k=1 to c
+     if frac(n/p[k])=0 then exit for
+  next
+  '
+  if k>c then
+    c++
+    p[c]=n 'STORE PRIME
+  end if
+end do
+end macro
+
+
+macro ProcessNumbers(p,bb)
+'=========================
+finit
+sys i,b,e
+b=bb*share
+e=b+share
+sys v,w
+for i=b+1 to e
+  v=numbers(i)
+  for j=max to 1 step -1
+    w=primes(j)
+    if w<v then
+      if frac(v/w)=0 then
+        p(i)=primes(j)    'store highest factor
+        exit for          'process next number
+      end if
+    end if
+  next
+next
+end macro
+
+'THREAD FUNCTIONS
+
+function threadA(sys v) as sys
+ProcessNumbers(pp,v)
+end function
+
+
+function threadB(sys v) as sys
+ProcessNumbers(pp,v)
+end function
+
+
+function threadC(sys v) as sys
+ProcessNumbers(pp,v)
+end function
+
+
+end extern
+
+function mainThread(sys b)
+'===========================
+ProcessNumbers(pp,b)
+end function
+
+
+'SOURCE DATA GENERATION
+
+sys seed = 0x12345678
+
+function Rnd() as sys
+'====================
+'
+mov eax,seed
+rol eax,7
+imul eax,eax,13
+mov seed,eax
+return eax
+end function
+
+
+function GenerateNumbers()
+'=========================
+sys i,v,mask
+mask=max * 8 -1 'as bit mask
+for i=1 to max
+  v=rnd()
+  v and=mask
+  numbers(i)=v
+next
+end function
+
+
+
+FindPrimes(primes)
+
+GenerateNumbers()
+
+
+
+% threads Cores-1
+
+% INFINITE 0xFFFFFFFF  'Infinite timeout
+
+sys Funs[threads]={@threadA,@threadB,@threadC} '3 additional threads
+sys  hThread[threads], id[threads], i
+'
+'START TIMER
+'
+QueryPerformanceCounter   t1
+'
+for i=1 to threads
+  hThread(i) =  CreateThread 0,0,funs(i),i,0,id(i)
+next
+
+
+MainThread(0) 'process numbers in main thread (bottom share)
+
+if threads>0 then
+  WaitForMultipleObjects Threads, hThread, 1, INFINITE
+end if
+
+for i=1 to Threads
+  CloseHandle hThread(i)
+next
+
+'CAPTURE NUMBER WITH HIGHEST PRIME FACTOR
+
+sys n,f
+for i=1 to max
+  if pp(i)>f then f=pp(i) : n=i
+next
+
+'STOP TIMER
+
+QueryPerformanceCounter t2
+
+print str((t2-t1)/freq,3) " secs    " numbers(n) "    " f 'number with highest prime factor
--- a/Task/Parallel-calculations/PARI-GP/parallel-calculations.parigp
+++ b/Task/Parallel-calculations/PARI-GP/parallel-calculations.parigp
@ -0,0 +1,2 @@
+v=pareval(vector(1000,i,()->factor(2^i+1)[1,1]));
+vecmin(v)
--- a/Task/Parallel-calculations/Perl/parallel-calculations.pl
+++ b/Task/Parallel-calculations/Perl/parallel-calculations.pl
@ -0,0 +1,19 @@
+use ntheory qw/factor vecmax/;
+use threads;
+use threads::shared;
+my @results :shared;
+
+my $tnum = 0;
+$_->join() for
+  map { threads->create('tfactor', $tnum++, $_) }
+  (qw/576460752303423487 576460752303423487 576460752303423487 112272537195293
+  115284584522153 115280098190773 115797840077099 112582718962171 299866111963290359/);
+
+my $lmf = vecmax( map { $_->[1] } @results );
+print "Largest minimal factor of $lmf found in:\n";
+print "  $_->[0] = [@$_[1..$#$_]]\n" for grep { $_->[1] == $lmf } @results;
+
+sub tfactor {
+  my($tnum, $n) = @_;
+  push @results, shared_clone([$n, factor($n)]);
+}
--- a/Task/Parallel-calculations/Phix/parallel-calculations.phix
+++ b/Task/Parallel-calculations/Phix/parallel-calculations.phix
@ -0,0 +1,54 @@
+(notonline)-->
+ <span style="color: #000080;font-style:italic;">--
+ -- demo\rosetta\ParallelCalculations.exw
+ -- =====================================
+ --
+ --  Proof that more threads can make things faster...
+ --</span>
+ <span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (threads)</span>
+ <span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
+ <span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span>
+ <span style="color: #008080;">constant</span> <span style="color: #000000;">res_cs</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">init_cs</span><span style="color: #0000FF;">()</span>         <span style="color: #000080;font-style:italic;">-- critical section</span>
+
+ <span style="color: #008080;">procedure</span> <span style="color: #000000;">athread</span><span style="color: #0000FF;">()</span>
+     <span style="color: #004080;">mpz</span> <span style="color: #000000;">z</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_init</span><span style="color: #0000FF;">()</span>
+     <span style="color: #008080;">while</span> <span style="color: #004600;">true</span> <span style="color: #008080;">do</span>
+         <span style="color: #004080;">integer</span> <span style="color: #000000;">found</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
+         <span style="color: #7060A8;">enter_cs</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res_cs</span><span style="color: #0000FF;">)</span>
+         <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
+             <span style="color: #008080;">if</span> <span style="color: #004080;">integer</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">])</span>
+             <span style="color: #008080;">and</span> <span style="color: #000000;">res</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]></span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
+                 <span style="color: #000000;">found</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">i</span>
+                 <span style="color: #000000;">res</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
+                 <span style="color: #008080;">exit</span>
+             <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+         <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+         <span style="color: #7060A8;">leave_cs</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res_cs</span><span style="color: #0000FF;">)</span>
+         <span style="color: #008080;">if</span> <span style="color: #008080;">not</span> <span style="color: #000000;">found</span> <span style="color: #008080;">then</span> <span style="color: #008080;">exit</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+         <span style="color: #7060A8;">mpz_ui_pow_ui</span><span style="color: #0000FF;">(</span><span style="color: #000000;">z</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">found</span><span style="color: #0000FF;">)</span>
+         <span style="color: #7060A8;">mpz_add_ui</span><span style="color: #0000FF;">(</span><span style="color: #000000;">z</span><span style="color: #0000FF;">,</span><span style="color: #000000;">z</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
+         <span style="color: #004080;">object</span> <span style="color: #000000;">r</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_prime_factors</span><span style="color: #0000FF;">(</span><span style="color: #000000;">z</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1_000_000</span><span style="color: #0000FF;">)</span>
+         <span style="color: #7060A8;">enter_cs</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res_cs</span><span style="color: #0000FF;">)</span>
+         <span style="color: #000000;">res</span><span style="color: #0000FF;">[</span><span style="color: #000000;">found</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">r</span>
+         <span style="color: #000000;">r</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
+         <span style="color: #7060A8;">leave_cs</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res_cs</span><span style="color: #0000FF;">)</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
+     <span style="color: #7060A8;">exit_thread</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
+
+ <span style="color: #008080;">for</span> <span style="color: #000000;">nthreads</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">5</span> <span style="color: #008080;">do</span>
+     <span style="color: #7060A8;">progress</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"testing %d threads..."</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">nthreads</span><span style="color: #0000FF;">})</span>
+     <span style="color: #004080;">atom</span> <span style="color: #000000;">t0</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()</span>
+     <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">100</span><span style="color: #0000FF;">)</span>
+     <span style="color: #004080;">sequence</span> <span style="color: #000000;">threads</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
+     <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">nthreads</span> <span style="color: #008080;">do</span>
+         <span style="color: #000000;">threads</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">threads</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">create_thread</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">routine_id</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"athread"</span><span style="color: #0000FF;">),{}))</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+     <span style="color: #7060A8;">wait_thread</span><span style="color: #0000FF;">(</span><span style="color: #000000;">threads</span><span style="color: #0000FF;">)</span>
+     <span style="color: #004080;">integer</span> <span style="color: #000000;">k</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">largest</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #004600;">true</span><span style="color: #0000FF;">)</span>
+     <span style="color: #004080;">string</span> <span style="color: #000000;">e</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">)</span>
+     <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"largest is 2^%d+1 with smallest factor of %d (%d threads, %s)\n"</span><span style="color: #0000FF;">,</span>
+              <span style="color: #0000FF;">{</span><span style="color: #000000;">k</span><span style="color: #0000FF;">,</span><span style="color: #000000;">res</span><span style="color: #0000FF;">[</span><span style="color: #000000;">k</span><span style="color: #0000FF;">][</span><span style="color: #000000;">1</span><span style="color: #0000FF;">][</span><span style="color: #000000;">1</span><span style="color: #0000FF;">],</span><span style="color: #000000;">nthreads</span><span style="color: #0000FF;">,</span><span style="color: #000000;">e</span><span style="color: #0000FF;">})</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+ <span style="color: #7060A8;">delete_cs</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res_cs</span><span style="color: #0000FF;">)</span>
+<!--
--- a/Task/Parallel-calculations/PicoLisp/parallel-calculations.l
+++ b/Task/Parallel-calculations/PicoLisp/parallel-calculations.l
@ -0,0 +1,20 @@
+(let Lst
+   (mapcan
+      '((N)
+         (later (cons)               # When done,
+            (cons N (factor N)) ) )  # return the number and its factors
+      (quote
+         188573867500151328137405845301  # Process a collection of 12 numbers
+         3326500147448018653351160281
+         979950537738920439376739947
+         2297143294659738998811251
+         136725986940237175592672413
+         3922278474227311428906119
+         839038954347805828784081
+         42834604813424961061749793
+         2651919914968647665159621
+         967022047408233232418982157
+         2532817738450130259664889
+         122811709478644363796375689 ) )
+   (wait NIL (full Lst))  # Wait until all computations are done
+   (maxi '((L) (apply min L)) Lst) )  # Result: Number in CAR, factors in CDR
--- a/Task/Parallel-calculations/Prolog/parallel-calculations.pro
+++ b/Task/Parallel-calculations/Prolog/parallel-calculations.pro
@ -0,0 +1,31 @@
+threaded_decomp(Number,ID):-
+	thread_create(
+		      (prime_decomp(Number,Y),
+		       thread_exit((Number,Y)))
+		     ,ID,[]).
+
+threaded_decomp_list(List,Erg):-
+	maplist(threaded_decomp,List,IDs),
+	maplist(thread_join,IDs,Results),
+	maplist(pack_exit_out,Results,Smallest_Factors_List),
+	largest_min_factor(Smallest_Factors_List,Erg).
+
+pack_exit_out(exited(X),X).
+%Note that here some error handling should happen.
+
+largest_min_factor([(N,Facs)|A],(N2,Fs2)):-
+	min_list(Facs,MF),
+	largest_min_factor(A,(N,MF,Facs),(N2,_,Fs2)).
+
+largest_min_factor([],Acc,Acc).
+largest_min_factor([(N1,Facs1)|Rest],(N2,MF2,Facs2),Goal):-
+	min_list(Facs1, MF1),
+	(MF1 > MF2->
+	largest_min_factor(Rest,(N1,MF1,Facs1),Goal);
+	largest_min_factor(Rest,(N2,MF2,Facs2),Goal)).
+
+
+format_it(List):-
+	threaded_decomp_list(List,(Number,Factors)),
+	format('Number with largest minimal Factor is ~w\nFactors are ~w\n',
+	       [Number,Factors]).
--- a/Task/Parallel-calculations/PureBasic/parallel-calculations.basic
+++ b/Task/Parallel-calculations/PureBasic/parallel-calculations.basic
@ -0,0 +1,87 @@
+Structure IO_block
+  ThreadID.i
+  StartSeamaphore.i
+  Value.q
+  MinimumFactor.i
+  List Factors.i()
+EndStructure
+;\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
+
+Declare Factorize(*IO.IO_block)
+Declare main()
+;\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
+
+Main()
+End
+;\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
+
+Procedure Main()
+  Protected AvailableCpu, MainSemaphore
+  Protected i, j, qData.q, Title$, Message$
+  NewList T.IO_block()
+  ;
+  AvailableCpu = Val(GetEnvironmentVariable("NUMBER_OF_PROCESSORS"))
+  If AvailableCpu<1: AvailableCpu=1: EndIf
+  MainSemaphore = CreateSemaphore(AvailableCpu)
+  ;
+  Restore Start_of_data
+  For i=1 To (?end_of_data-?Start_of_data) / SizeOf(Quad)
+    ; Start all threads at ones, they will then be let to
+    ; self-oganize according to the availiable Cores.
+    AddElement(T())
+    Read.q  qData
+    T()\Value = qData
+    T()\StartSeamaphore = MainSemaphore
+    T()\ThreadID = CreateThread(@Factorize(), @T())
+  Next
+  ;
+  ForEach T()
+    ; Wait for all threads to complete their work and
+    ; find the smallest factor from eact task.
+    WaitThread(T()\ThreadID)
+  Next
+  ;
+  i = OffsetOf(IO_block\MinimumFactor)
+  SortStructuredList(T(), #PB_Sort_Integer, i, #PB_Sort_Descending)
+  FirstElement(T())
+  Title$="Info"
+  Message$="Number "+Str(T()\Value)+" has largest minimal factor:"+#CRLF$
+  ForEach T()\Factors()
+    Message$ + Str(T()\Factors())+" "
+  Next
+  MessageRequester(Title$, Message$)
+EndProcedure
+
+ProcedureDLL Factorize(*IO.IO_block) ; Fill list Factors() with the factor parts of Number
+  ;Based on http://rosettacode.org/wiki/Prime_decomposition#PureBasic
+  With *IO
+    Protected Value.q=\Value
+    WaitSemaphore(\StartSeamaphore)
+    Protected I = 3
+    ClearList(\Factors())
+    While Value % 2 = 0
+      AddElement(\Factors())
+      \Factors() = 2
+      Value / 2
+    Wend
+    Protected Max = Value
+    While I <= Max And Value > 1
+      While Value % I = 0
+        AddElement(\Factors())
+        \Factors() = I
+        Value / I
+      Wend
+      I + 2
+    Wend
+    SortList(\Factors(), #PB_Sort_Ascending)
+    FirstElement(\Factors())
+    \MinimumFactor=\Factors()
+    SignalSemaphore(\StartSeamaphore)
+  EndWith ;*IO
+EndProcedure
+
+DataSection
+  Start_of_data: ; Same numbers as Ada
+  Data.q  12757923, 12878611, 12757923, 15808973, 15780709, 197622519
+  end_of_data:
+EndDataSection
--- a/Task/Parallel-calculations/Python/parallel-calculations-1.py
+++ b/Task/Parallel-calculations/Python/parallel-calculations-1.py
@ -0,0 +1,45 @@
+from concurrent import futures
+from math import floor, sqrt
+
+NUMBERS = [
+    112272537195293,
+    112582718962171,
+    112272537095293,
+    115280098190773,
+    115797840077099,
+    1099726829285419]
+# NUMBERS = [33, 44, 55, 275]
+
+def lowest_factor(n, _start=3):
+    if n % 2 == 0:
+        return 2
+    search_max = int(floor(sqrt(n))) + 1
+    for i in range(_start, search_max, 2):
+        if n % i == 0:
+            return i
+    return n
+
+def prime_factors(n, lowest):
+    pf = []
+    while n > 1:
+        pf.append(lowest)
+        n //= lowest
+        lowest = lowest_factor(n, max(lowest, 3))
+    return pf
+
+def prime_factors_of_number_with_lowest_prime_factor(NUMBERS):
+    with futures.ProcessPoolExecutor() as executor:
+        low_factor, number = max( (l, f) for l, f in zip(executor.map(lowest_factor, NUMBERS), NUMBERS) )
+        all_factors = prime_factors(number, low_factor)
+        return number, all_factors
+
+
+def main():
+    print('For these numbers:')
+    print('\n  '.join(str(p) for p in NUMBERS))
+    number, all_factors = prime_factors_of_number_with_lowest_prime_factor(NUMBERS)
+    print('    The one with the largest minimum prime factor is {}:'.format(number))
+    print('      All its prime factors in order are: {}'.format(all_factors))
+
+if __name__ == '__main__':
+    main()
--- a/Task/Parallel-calculations/Python/parallel-calculations-2.py
+++ b/Task/Parallel-calculations/Python/parallel-calculations-2.py
@ -0,0 +1,46 @@
+import multiprocessing
+
+# ========== #Python3 - concurrent
+from math import floor, sqrt
+
+numbers = [
+    112272537195293,
+    112582718962171,
+    112272537095293,
+    115280098190773,
+    115797840077099,
+    1099726829285419]
+# numbers = [33, 44, 55, 275]
+
+def lowest_factor(n, _start=3):
+    if n % 2 == 0:
+        return 2
+    search_max = int(floor(sqrt(n))) + 1
+    for i in range(_start, search_max, 2):
+        if n % i == 0:
+            return i
+    return n
+
+def prime_factors(n, lowest):
+    pf = []
+    while n > 1:
+        pf.append(lowest)
+        n //= lowest
+        lowest = lowest_factor(n, max(lowest, 3))
+    return pf
+# ========== #Python3 - concurrent
+
+def prime_factors_of_number_with_lowest_prime_factor(numbers):
+    pool = multiprocessing.Pool(processes=5)
+    factors = pool.map(lowest_factor,numbers)
+
+    low_factor,number = max((l,f) for l,f in zip(factors,numbers))
+    all_factors = prime_factors(number,low_factor)
+    return number,all_factors
+
+if __name__ == '__main__':
+    print('For these numbers:')
+    print('\n  '.join(str(p) for p in numbers))
+    number, all_factors = prime_factors_of_number_with_lowest_prime_factor(numbers)
+    print('    The one with the largest minimum prime factor is {}:'.format(number))
+    print('      All its prime factors in order are: {}'.format(all_factors))
--- a/Task/Parallel-calculations/Racket/parallel-calculations-1.rkt
+++ b/Task/Parallel-calculations/Racket/parallel-calculations-1.rkt
@ -0,0 +1,25 @@
+#lang racket
+(require math)
+(provide main)
+
+(define (smallest-factor n)
+  (list (first (first (factorize n))) n))
+
+(define numbers
+  '(112272537195293 112582718962171 112272537095293
+    115280098190773 115797840077099 1099726829285419))
+
+(define (main)
+  ; create as many instances of Racket as
+  ; there are numbers:
+  (define ps
+    (for/list ([_ numbers])
+      (place ch
+             (place-channel-put
+              ch
+              (smallest-factor
+               (place-channel-get ch))))))
+  ; send the numbers to the instances:
+  (map place-channel-put ps numbers)
+  ; get the results and find the maximum:
+  (argmax first (map place-channel-get ps)))
--- a/Task/Parallel-calculations/Racket/parallel-calculations-2.rkt
+++ b/Task/Parallel-calculations/Racket/parallel-calculations-2.rkt
@ -0,0 +1,2 @@
+> (main)
+'(544651 115797840077099)
--- a/Task/Parallel-calculations/Raku/parallel-calculations.raku
+++ b/Task/Parallel-calculations/Raku/parallel-calculations.raku
@ -0,0 +1,69 @@
+my @nums = 64921987050997300559,  70251412046988563035,  71774104902986066597,
+           83448083465633593921,  84209429893632345702,  87001033462961102237,
+           87762379890959854011,  89538854889623608177,  98421229882942378967,
+           259826672618677756753, 262872058330672763871, 267440136898665274575,
+           278352769033314050117, 281398154745309057242, 292057004737291582187;
+
+my @factories = @nums.hyper(:3batch).map: &prime-factors;
+printf "%21d factors: %s\n", |$_ for @nums Z @factories;
+my $gmf = {}.append(@factories»[0] »=>« @nums).max: +*.key;
+say "\nGreatest minimum factor: ", $gmf.key;
+say "from: { $gmf.value }\n";
+say 'Run time: ', now - INIT now;
+say '-' x 80;
+
+# For amusements sake and for relative comparison, using the same 100
+# numbers as in the SequenceL example, testing with different numbers of threads.
+
+@nums = <625070029 413238785 815577134 738415913 400125878 967798656 830022841
+   774153795 114250661 259366941 571026384 522503284 757673286 509866901 6303092
+   516535622 177377611 520078930 996973832 148686385 33604768 384564659 95268916
+   659700539 149740384 320999438 822361007 701572051 897604940 2091927 206462079
+   290027015 307100080 904465970 689995756 203175746 802376955 220768968 433644101
+   892007533 244830058 36338487 870509730 350043612 282189614 262732002 66723331
+   908238109 635738243 335338769 461336039 225527523 256718333 277834108 430753136
+   151142121 602303689 847642943 538451532 683561566 724473614 422235315 921779758
+   766603317 364366380 60185500 333804616 988528614 933855820 168694202 219881490
+   703969452 308390898 567869022 719881996 577182004 462330772 770409840 203075270
+   666478446 351859802 660783778 503851023 789751915 224633442 347265052 782142901
+   43731988 246754498 736887493 875621732 594506110 854991694 829661614 377470268
+   984990763 275192380 39848200 892766084 76503760>».Int;
+
+for 1..8 -> $degree {
+    my $start = now;
+    my \factories = @nums.hyper(:degree($degree), :3batch).map: &prime-factors;
+    my $gmf = {}.append(factories»[0] »=>« @nums).max: +*.key;
+    say "\nFactoring {+@nums} numbers, greatest minimum factor: {$gmf.key}";
+    say "Using: $degree thread{ $degree > 1 ?? 's' !! ''}";
+    my $end = now;
+    say 'Run time: ', $end - $start, ' seconds.';
+}
+
+# Prime factoring routines from the Prime decomposition task
+sub prime-factors ( Int $n where * > 0 ) {
+    return $n if $n.is-prime;
+    return [] if $n == 1;
+    my $factor = find-factor( $n );
+    sort flat prime-factors( $factor ), prime-factors( $n div $factor );
+}
+
+sub find-factor ( Int $n, $constant = 1 ) {
+    return 2 unless $n +& 1;
+    if (my $gcd = $n gcd 6541380665835015) > 1 {
+        return $gcd if $gcd != $n
+    }
+    my $x      = 2;
+    my $rho    = 1;
+    my $factor = 1;
+    while $factor == 1 {
+        $rho *= 2;
+        my $fixed = $x;
+        for ^$rho {
+            $x = ( $x * $x + $constant ) % $n;
+            $factor = ( $x - $fixed ) gcd $n;
+            last if 1 < $factor;
+        }
+    }
+    $factor = find-factor( $n, $constant + 1 ) if $n == $factor;
+    $factor;
+}
--- a/Task/Parallel-calculations/Rust/parallel-calculations.rust
+++ b/Task/Parallel-calculations/Rust/parallel-calculations.rust
@ -0,0 +1,29 @@
+//! This solution uses [rayon](https://github.com/rayon-rs/rayon), a data-parallelism library.
+//! Since Rust guarantees that a program has no data races, adding parallelism to a sequential
+//! computation is as easy as importing the rayon traits and calling the `par_iter()` method.
+
+extern crate rayon;
+
+extern crate prime_decomposition;
+
+use rayon::prelude::*;
+
+/// Returns the largest minimal factor of the numbers in a slice
+pub fn largest_min_factor(numbers: &[usize]) -> usize {
+    numbers
+        .par_iter()
+        .map(|n| {
+            // `factor` returns a sorted vector, so we just take the first element.
+            prime_decomposition::factor(*n)[0]
+        })
+        .max()
+        .unwrap()
+}
+
+fn main() {
+    let numbers = &[
+        1_122_725, 1_125_827, 1_122_725, 1_152_800, 1_157_978, 1_099_726,
+    ];
+    let max = largest_min_factor(numbers);
+    println!("The largest minimal factor is {}", max);
+}
--- a/Task/Parallel-calculations/SequenceL/parallel-calculations-1.sequencel
+++ b/Task/Parallel-calculations/SequenceL/parallel-calculations-1.sequencel
@ -0,0 +1,13 @@
+import <Utilities/Conversion.sl>;
+import <Utilities/Math.sl>;
+import <Utilities/Sequence.sl>;
+		
+main(args(2)) :=
+	let
+		inputs := stringToInt(args);
+		factored := primeFactorization(inputs);
+		minFactors := vectorMin(factored);
+		
+		indexOfMax := firstIndexOf(minFactors, vectorMax(minFactors));
+	in
+		"Number " ++ intToString(inputs[indexOfMax]) ++ " has largest minimal factor:\n"  ++ delimit(intToString(factored[indexOfMax]), ' ');
--- a/Task/Parallel-calculations/SequenceL/parallel-calculations-2.sequencel
+++ b/Task/Parallel-calculations/SequenceL/parallel-calculations-2.sequencel
@ -0,0 +1 @@
+factored := primeFactorization(inputs);
--- a/Task/Parallel-calculations/Sidef/parallel-calculations.sidef
+++ b/Task/Parallel-calculations/Sidef/parallel-calculations.sidef
@ -0,0 +1,5 @@
+var nums = [1275792312878611, 12345678915808973,
+            1578070919762253, 14700694496703910,];
+
+var factors = nums.map {|n| prime_factors.ffork(n) }.map { .wait }
+say ((nums ~Z factors)->max_by {|m| m[1][0] })
--- a/Task/Parallel-calculations/Standard-ML/parallel-calculations-1.ml
+++ b/Task/Parallel-calculations/Standard-ML/parallel-calculations-1.ml
@ -0,0 +1,58 @@
+structure TTd  =  Thread.Thread ;
+structure TTm  =  Thread.Mutex  ;
+
+
+val threadedBigPrime =  fn input:IntInf.int list  =>
+
+let
+
+(* --------------------- code from prime decomposition page  ------------------- *)
+  val factor = fn n :IntInf.int  =>
+   let
+     val unfactored  = fn (u,_,_)   => u; val factors = fn (_,f,_) => f; val try  = fn (_,_,i)   => i; fun getresult t = unfactored t::(factors t);
+     fun until done change x = if done x  then getresult x else until done change (change x);       (* iteration *)
+     fun lastprime t = unfactored t  <  (try t)*(try t)
+     fun trymore t   = if unfactored t mod (try t) = 0  then (unfactored t div (try t) , try t::(factors t) , try t) else (unfactored t, factors t , try t + 1)
+   in  until lastprime trymore (n,[],2)  end;
+(* --------------------- end of code from prime decomposition page  ------------ *)
+
+
+ val mx   =  TTm.mutex () ;
+ val results :  IntInf.int list list ref  =  ref [  ] ;
+ val tasks   :  IntInf.int list list ref  =  ref [  ] ;
+
+
+ val divideup =  fn cores => fn inp : IntInf.int list =>
+  let
+   val np = (List.length inp) div cores + (cores +1) div cores                          (* assume length > cores to reduce code *)
+   val rec divd = fn ([], outp)    =>  ([],outp )
+                      | (inp,outp) =>  divd ( List.drop (inp,np) , (List.take (inp,np))::outp )  handle Subscript => ([],inp :: outp)
+  in
+    #2 ( divd (inp, [ ] ))
+  end;
+
+
+ val doTask =  fn () =>
+  let
+    val mytask :  IntInf.int list ref     = ref [];
+    val myres  : IntInf.int list list ref = ref [];
+  in
+   (   TTm.lock mx ; mytask :=  hd ( !tasks ) ;  tasks:= tl (!tasks)   ; TTm.unlock mx ;
+       myres  :=  List.map  factor ( !mytask ) ;
+       TTm.lock mx ; results :=  !myres @ ( !results )   ; TTm.unlock mx ;
+       TTd.exit ()
+   )
+ end;
+
+
+ val cores     =  TTd.numProcessors ();
+ val tmp       =  tasks :=  divideup cores input ;
+ val processes =  List.tabulate ( cores , fn i => TTd.fork (doTask , []) ) ;
+ val maxim     =  ( while ( List.exists TTd.isActive processes ) do (Posix.Process.sleep (Time.fromReal 1.0 ));
+                    List.foldr IntInf.max  1 ( List.map (fn i => List.last i ) (!results) ) )                   (* maximal lowest prime *)
+
+in
+
+   List.filter (fn lst => List.last lst = maxim ) (!results)
+
+end ;
--- a/Task/Parallel-calculations/Standard-ML/parallel-calculations-2.ml
+++ b/Task/Parallel-calculations/Standard-ML/parallel-calculations-2.ml
@ -0,0 +1,11 @@
+> threadedBigPrime [ 62478923478923409323,   69478923478923409313,  79234790234098402349,
+           33498023480920234793,  92834098234098023409,  31908234098234098243,
+           92873400002348028833,  73498200234098200239,  4349023423478999243,
+           13480234982340982343,  62478923478925971503,  5340823480234982007,
+           134802349691098498233, 81780923490092302251,  802487292348792949 ] ;
+
+val it = [[1463103844669601, 42703], [1463103844669541, 42703]]:
+
+(* numbers *)
+> List.map (List.foldr IntInf.* 1 ) it ;
+val it = [62478923478925971503, 62478923478923409323]: IntInf.int list
--- a/Task/Parallel-calculations/Swift/parallel-calculations.swift
+++ b/Task/Parallel-calculations/Swift/parallel-calculations.swift
@ -0,0 +1,74 @@
+import BigInt
+import Foundation
+
+extension BinaryInteger {
+  @inlinable
+  public func primeDecomposition() -> [Self] {
+    guard self > 1 else { return [] }
+
+    func step(_ x: Self) -> Self {
+      return 1 + (x << 2) - ((x >> 1) << 1)
+    }
+
+    let maxQ = Self(Double(self).squareRoot())
+    var d: Self = 1
+    var q: Self = self & 1 == 0 ? 2 : 3
+
+    while q <= maxQ && self % q != 0 {
+      q = step(d)
+      d += 1
+    }
+
+    return q <= maxQ ? [q] + (self / q).primeDecomposition() : [self]
+  }
+}
+
+let numbers = [
+  112272537195293,
+  112582718962171,
+  112272537095293,
+  115280098190773,
+  115797840077099,
+  1099726829285419,
+  1275792312878611,
+  BigInt("64921987050997300559")
+]
+
+func findLargestMinFactor<T: BinaryInteger>(for nums: [T], then: @escaping ((n: T, factors: [T])) -> ()) {
+  let waiter = DispatchSemaphore(value: 0)
+  let lock = DispatchSemaphore(value: 1)
+  var factors = [(n: T, factors: [T])]()
+
+  DispatchQueue.concurrentPerform(iterations: nums.count) {i in
+    let n = nums[i]
+
+    print("Factoring \(n)")
+
+    let nFacs = n.primeDecomposition().sorted()
+
+    print("Factored \(n)")
+
+    lock.wait()
+    factors.append((n, nFacs))
+
+    if factors.count == nums.count {
+      waiter.signal()
+    }
+
+    lock.signal()
+  }
+
+  waiter.wait()
+
+  then(factors.sorted(by: { $0.factors.first! > $1.factors.first! }).first!)
+}
+
+findLargestMinFactor(for: numbers) {res in
+  let (n, factors) = res
+
+  print("Number with largest min prime factor: \(n); factors: \(factors)")
+
+  exit(0)
+}
+
+dispatchMain()
--- a/Task/Parallel-calculations/Tcl/parallel-calculations-1.tcl
+++ b/Task/Parallel-calculations/Tcl/parallel-calculations-1.tcl
@ -0,0 +1,42 @@
+package require Tcl 8.6
+package require Thread
+
+# Pooled computation engine; runs event loop internally
+namespace eval pooled {
+    variable poolSize 3; # Needs to be tuned to system size
+
+    proc computation {computationDefinition entryPoint values} {
+	variable result
+	variable poolSize
+	# Add communication shim
+	append computationDefinition [subst -nocommands {
+	    proc poolcompute {value target} {
+		set outcome [$entryPoint \$value]
+		set msg [list set ::pooled::result(\$value) \$outcome]
+		thread::send -async \$target \$msg
+	    }
+	}]
+
+	# Set up the pool
+	set pool [tpool::create -initcmd $computationDefinition \
+		      -maxworkers $poolSize]
+
+	# Prepare to receive results
+	unset -nocomplain result
+	array set result {}
+
+	# Dispatch the computations
+	foreach value $values {
+	    tpool::post $pool [list poolcompute $value [thread::id]]
+	}
+
+	# Wait for results
+	while {[array size result] < [llength $values]} {vwait pooled::result}
+
+	# Dispose of the pool
+	tpool::release $pool
+
+	# Return the results
+	return [array get result]
+    }
+}
--- a/Task/Parallel-calculations/Tcl/parallel-calculations-2.tcl
+++ b/Task/Parallel-calculations/Tcl/parallel-calculations-2.tcl
@ -0,0 +1,67 @@
+# Code for computing the prime factors of a number
+set computationCode {
+    namespace eval prime {
+	variable primes [list 2 3 5 7 11]
+	proc restart {} {
+	    variable index -1
+	    variable primes
+	    variable current [lindex $primes end]
+	}
+
+	proc get_next_prime {} {
+	    variable primes
+	    variable index
+	    if {$index < [llength $primes]-1} {
+		return [lindex $primes [incr index]]
+	    }
+	    variable current
+	    while 1 {
+		incr current 2
+		set p 1
+		foreach prime $primes {
+		    if {$current % $prime} {} else {
+			set p 0
+			break
+		    }
+		}
+		if {$p} {
+		    return [lindex [lappend primes $current] [incr index]]
+		}
+	    }
+	}
+
+	proc factors {num} {
+	    restart
+	    set factors [dict create]
+	    for {set i [get_next_prime]} {$i <= $num} {} {
+		if {$num % $i == 0} {
+		    dict incr factors $i
+		    set num [expr {$num / $i}]
+		    continue
+		} elseif {$i*$i > $num} {
+		    dict incr factors $num
+		    break
+		} else {
+		    set i [get_next_prime]
+		}
+	    }
+	    return $factors
+	}
+    }
+}
+
+# The values to be factored
+set values {
+    188573867500151328137405845301
+    3326500147448018653351160281
+    979950537738920439376739947
+    2297143294659738998811251
+    136725986940237175592672413
+    3922278474227311428906119
+    839038954347805828784081
+    42834604813424961061749793
+    2651919914968647665159621
+    967022047408233232418982157
+    2532817738450130259664889
+    122811709478644363796375689
+}
--- a/Task/Parallel-calculations/Tcl/parallel-calculations-3.tcl
+++ b/Task/Parallel-calculations/Tcl/parallel-calculations-3.tcl
@ -0,0 +1,15 @@
+# Do the computation, getting back a dictionary that maps
+# values to its results (itself an ordered dictionary)
+set results [pooled::computation $computationCode prime::factors $values]
+
+# Find the maximum minimum factor with sorting magic
+set best [lindex [lsort -integer -stride 2 -index {1 0} $results] end-1]
+
+# Print in human-readable form
+proc renderFactors {factorDict} {
+    dict for {factor times} $factorDict {
+	lappend v {*}[lrepeat $times $factor]
+    }
+    return [join $v "*"]
+}
+puts "$best = [renderFactors [dict get $results $best]]"
--- a/Task/Parallel-calculations/Wren/parallel-calculations-1.wren
+++ b/Task/Parallel-calculations/Wren/parallel-calculations-1.wren
@ -0,0 +1,9 @@
+/* parallel_calculations.wren */
+
+import "./math" for Int
+
+class C {
+    static minPrimeFactor(n)  { Int.primeFactors(n)[0] }
+
+    static allPrimeFactors(n) { Int.primeFactors(n) }
+}
--- a/Task/Parallel-calculations/Wren/parallel-calculations-2.wren
+++ b/Task/Parallel-calculations/Wren/parallel-calculations-2.wren
@ -0,0 +1,123 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <omp.h>
+#include "wren.h"
+
+#define NUM_VMS 4
+
+WrenVM* vms[NUM_VMS]; // array of VMs
+
+void doParallelCalcs() {
+    int data[] = {12757923, 12878611, 12878893, 12757923, 15808973, 15780709, 197622519};
+    int i, count, largest, largest_factor = 0;
+    omp_set_num_threads(4);
+    // we can share the same call and class handles amongst VMs
+    WrenHandle* callHandle  = wrenMakeCallHandle(vms[0], "minPrimeFactor(_)");
+    WrenHandle* callHandle2 = wrenMakeCallHandle(vms[0], "allPrimeFactors(_)");
+    wrenEnsureSlots(vms[0], 1);
+    wrenGetVariable(vms[0], "main", "C", 0);
+    WrenHandle* classHandle = wrenGetSlotHandle(vms[0], 0);
+
+    #pragma omp parallel for shared(largest_factor, largest)
+    for (i = 0; i < 7; ++i) {
+        int n = data[i];
+        int vi = omp_get_thread_num(); // assign a VM (via its array index) for this number
+        wrenEnsureSlots(vms[vi], 2);
+        wrenSetSlotHandle(vms[vi], 0, classHandle);
+        wrenSetSlotDouble(vms[vi], 1, (double)n);
+        wrenCall(vms[vi], callHandle);
+        int p = (int)wrenGetSlotDouble(vms[vi], 0);
+        if (p > largest_factor) {
+            largest_factor = p;
+            largest = n;
+            printf("Thread %d: found larger: %d of %d\n", vi, p, n);
+        } else {
+            printf("Thread %d: not larger:   %d of %d\n", vi, p, n);
+        }
+    }
+
+    printf("\nLargest minimal prime factor: %d of %d\n", largest_factor, largest);
+    printf("All prime factors for this number: ");
+    wrenEnsureSlots(vms[0], 2);
+    wrenSetSlotHandle(vms[0], 0, classHandle);
+    wrenSetSlotDouble(vms[0], 1, (double)largest);
+    wrenCall(vms[0], callHandle2);
+    count = wrenGetListCount(vms[0], 0);
+    for (i = 0; i < count; ++i) {
+        wrenGetListElement(vms[0], 0, i, 1);
+        printf("%d ", (int)wrenGetSlotDouble(vms[0], 1));
+    }
+    printf("\n");
+    wrenReleaseHandle(vms[0], callHandle);
+    wrenReleaseHandle(vms[0], callHandle2);
+    wrenReleaseHandle(vms[0], classHandle);
+}
+
+static void writeFn(WrenVM* vm, const char* text) {
+    printf("%s", text);
+}
+
+void errorFn(WrenVM* vm, WrenErrorType errorType, const char* module, const int line, const char* msg) {
+    switch (errorType) {
+        case WREN_ERROR_COMPILE:
+            printf("[%s line %d] [Error] %s\n", module, line, msg);
+            break;
+        case WREN_ERROR_STACK_TRACE:
+            printf("[%s line %d] in %s\n", module, line, msg);
+            break;
+        case WREN_ERROR_RUNTIME:
+            printf("[Runtime Error] %s\n", msg);
+            break;
+    }
+}
+
+char *readFile(const char *fileName) {
+    FILE *f = fopen(fileName, "r");
+    fseek(f, 0, SEEK_END);
+    long fsize = ftell(f);
+    rewind(f);
+    char *script = malloc(fsize + 1);
+    fread(script, 1, fsize, f);
+    fclose(f);
+    script[fsize] = 0;
+    return script;
+}
+
+static void loadModuleComplete(WrenVM* vm, const char* module, WrenLoadModuleResult result) {
+    if( result.source) free((void*)result.source);
+}
+
+WrenLoadModuleResult loadModule(WrenVM* vm, const char* name) {
+    WrenLoadModuleResult result = {0};
+    if (strcmp(name, "random") != 0 && strcmp(name, "meta") != 0) {
+        result.onComplete = loadModuleComplete;
+        char fullName[strlen(name) + 6];
+        strcpy(fullName, name);
+        strcat(fullName, ".wren");
+        result.source = readFile(fullName);
+    }
+    return result;
+}
+
+int main(int argc, char **argv) {
+    WrenConfiguration config;
+    wrenInitConfiguration(&config);
+    config.writeFn = &writeFn;
+    config.errorFn = &errorFn;
+    config.loadModuleFn = &loadModule;
+    const char* module = "main";
+    const char* fileName = "parallel_calculations.wren";
+    char *script = readFile(fileName);
+
+    // config the VMs and interpret the script
+    int i;
+    for (i = 0; i < NUM_VMS; ++i) {
+        vms[i] = wrenNewVM(&config);
+        wrenInterpret(vms[i], module, script);
+    }
+    doParallelCalcs();
+    for (i = 0; i < NUM_VMS; ++i) wrenFreeVM(vms[i]);
+    free(script);
+    return 0;
+}
--- a/Task/Parallel-calculations/Zkl/parallel-calculations-1.zkl
+++ b/Task/Parallel-calculations/Zkl/parallel-calculations-1.zkl
@ -0,0 +1,8 @@
+fcn factorize(x,y,z,etc){
+   xyzs:=vm.arglist;
+   fs:=xyzs.apply(factors.strand) // queue up factorizing for x,y,...
+       .apply("noop")		  // wait for all threads to finish factoring
+       .apply(fcn{ (0).min(vm.arglist) }); // find minimum factor for x,y...
+   [0..].zip(fs).filter(fcn([(n,x)],M){ x==M }.fp1((0).max(fs))) // find max of mins
+   .apply('wrap([(n,_)]){ xyzs[n] })  // and pluck src from arglist
+}
--- a/Task/Parallel-calculations/Zkl/parallel-calculations-2.zkl
+++ b/Task/Parallel-calculations/Zkl/parallel-calculations-2.zkl
@ -0,0 +1,3 @@
+factorize(12757923,12878611,12757923,15808973,15780709,197622519).println();
+    // do a bunch so I can watch the system monitor
+factorize( (0).pump(5000,List,fcn{(1000).random() }).xplode() ).println();
--- a/Task/Parallel-calculations/Zkl/parallel-calculations-3.zkl
+++ b/Task/Parallel-calculations/Zkl/parallel-calculations-3.zkl
@ -0,0 +1,13 @@
+fcn factors(n){  // Return a list of factors of n
+   acc:=fcn(n,k,acc,maxD){  // k is 2,3,5,7,9,... not optimum
+      if(n==1 or k>maxD) acc.close();
+      else{
+	 q,r:=n.divr(k);   // divr-->(quotient,remainder)
+	 if(r==0) return(self.fcn(q,k,acc.write(k),q.toFloat().sqrt()));
+	 return(self.fcn(n,k+1+k.isOdd,acc,maxD))
+      }
+   }(n,2,Sink(List),n.toFloat().sqrt());
+   m:=acc.reduce('*,1);      // mulitply factors
+   if(n!=m) acc.append(n/m); // opps, missed last factor
+   else acc;
+}
				`@ -0,0 +1 @@`
				`hasSmallestFactor[data_List]:=Sort[Transpose[{ParallelTable[FactorInteger[x][[1, 1]], {x, data}],data}]][[1, 2]]`