June 2018 Update

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 Perl 6 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")

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}")
+    }
+}

Task/Parallel-calculations/Perl-6/parallel-calculations.pl6

@@ -1,5 +1,32 @@
-my @nums = 12757923, 12878611, 123456789, 15808973, 15780709, 197622519;
+my @nums = 64921987050997300559,  70251412046988563035,  71774104902986066597,
+           83448083465633593921,  84209429893632345702,  87001033462961102237,
+           87762379890959854011,  89538854889623608177,  98421229882942378967,
+           259826672618677756753, 262872058330672763871, 267440136898665274575,
+           278352769033314050117, 281398154745309057242, 292057004737291582187;
 
-my @factories;
-@factories[$_] := factors(@nums[$_]) for ^@nums;
-my $gmf = ([max] @factories»[0] »=>« @nums).value;
+my \factories = @nums.hyper.map: *.&prime-factors.cache;
+say my $gmf = {}.append(factories»[0] »=>« @nums).max: {+.key};
+
+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 ) {
+    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;
+}

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)]);
+}