Parallel calculations: Difference between revisions

 

prime_numbers.ads:

type Number is private;

Zero : Number;

end Calculate_Factors;

 

 

prime_numbers.adb:

package body Prime_Numbers is

 

end Calculate_Factors;

 

 

Example usage:

 

parallel.adb:

with Prime_Numbers;

procedure Parallel is

Ada.Text_IO.New_Line;

end;

 

{{out}}

For that matter, the code uses the dumbest prime factoring method,

and doesn't even test if the numbers can be divided by 2.

#include <omp.h>

 

printf("Largest factor: %d of %d\n", largest_factor, largest);

return 0;

{{out}} (YMMV regarding the order of output):

<pre>thread 1: found larger: 47 of 12878893

 

=={{header|C sharp|C#}}==

using System.Collections.Generic;

using System.Linq;

Console.WriteLine(string.Join(" ", factors[whatIndexIsThat]));

}

{{out}}

<pre>12878611 has the largest minimum prime factor: 47

Another version, using Parallel.For:

 

using System.Collections.Generic;

using System.Linq;

foreach (int list in l[j])

Console.Write(" "+list);

{{out}}

<pre>Number 12878611 has largest minimal factor:

This uses C++11 features including lambda functions.

 

#include <iterator>

#include <vector>

});

return 0;

{{out}}

<pre>

 

=={{header|Clojure}}==

 

(defn lpf [n]

(apply max-key second)

println

{{out}}

<pre>[99847 313]

=={{header|Common Lisp}}==

Depends on quicklisp.

 

(setf lparallel:*kernel* (lparallel:make-kernel 4)) ;; Configure for your system.

 

(defun print-max-factor (pair)

 

=={{header|D}}==

===Using Eager Parallel Map===

typeof(return) result;

for (ulong i = 2; n >= i * i; i++)

auto pairs = factors.map!(p => tuple(p[0].reduce!min, p[1]));

writeln("N. with largest min factor: ", pairs.reduce!max[1]);

{{out}}

<pre>N. with largest min factor: 7310027617718202995</pre>

 

===Using Threads===

core.thread, core.stdc.time;

 

writefln("Number with largest min. factor is %16d," ~

" with factors:\n\t%s", maxMin.tupleof);

{{out}} (1 core CPU, edited to fit page width):

<pre>Minimum factors for respective numbers are:

{{libheader| Velthuis.BigIntegers}}

{{Trans|C#}}

program Parallel_calculations;

 

 

readln;

 

=={{header|Erlang}}==

Perhaps it is of interest that the code will handle exceptions correctly. If the function (in this case factors/1) throws an exception, then the task will get it. I had to copy factors/1 from [[Prime_decomposition]] since it is only a fragment, not a complete example.

-module( parallel_calculations ).

 

My_pid ! Result

end ).

{{out}}

<pre>

 

=={{header|F_Sharp|F#}}==

open PrimeDecomp // Has the decompose function from the Prime decomposition task

 

List.iter (printf "%d ") primeList

 

 

{{out}}

===Manual Thread Management===

 

USING: io kernel fry locals sequences arrays math.primes.factors math.parser channels threads prettyprint ;

IN: <filename>

"Number with largest min. factor is " swap number>string append

", with factors: " append write .

{{out}}

<pre>

 

===With Concurency Module===

USING: kernel io prettyprint sequences arrays math.primes.factors math.parser concurrency.combinators ;

{ 576460752303423487 576460752303423487 576460752303423487 112272537195293

"Number with largest min. factor is " swap number>string append

", with factors: " append write .

{{out}}

<pre>

Using OpenMP (compile with -fopenmp)

 

program Primes

 

 

end program Primes

 

{{out}}

Thread 0: 15780709 7 17 132611

12878611 have the Largest factor: 47</pre>

 

=={{header|Go}}==

 

import (

}

return res

{{out}}

<pre>

 

=={{header|Haskell}}==

import Control.DeepSeq (NFData)

import Data.List (maximumBy)

 

main :: IO ()

{{out}}

<pre>(115797840077099,[212609249,544651])</pre>

The following only works in Unicon.

 

threads := []

L := list(*A)

link factors

 

Sample run:

=={{header|J}}==

The code at [http://code.jsoftware.com/wiki/User:Marshall_Lochbaum/Parallelize] implements parallel computation. With it, we can write

factors =. q:&.> parallelize 2 numbers NB. q: is parallelized here

ind =. (i. >./) <./@> factors

┌────────┬───────────┐

│12878611│47 101 2713│

 

=={{header|Java}}==

{{works with|Java|8}}

import static java.util.Arrays.stream;

import static java.util.Comparator.comparing;

return new long[]{n, n};

}

 

<pre>12878611 has the largest minimum prime factor: 47</pre>

 

This first portion should be placed in a file called "parallel_worker.js". This file contains the logic used by every worker created.

var onmessage = function(event) {

postMessage({"n" : event.data.n,

return factors;

}

 

For each number a worker is spawned. Once the final worker completes its task (worker_count is reduced to 0), the reduce function is called to determine which number is the answer.

var numbers = [12757923, 12878611, 12757923, 15808973, 15780709, 197622519];

var workers = [];

console.log("The number with the relatively largest factors is: " + n + " : " + factors);

}

 

=={{header|Julia}}==

using Primes

 

answer = maximum(keys(mins))

println("The number that has the largest minimum prime factor is $(mins[answer]), with a smallest factor of $answer")

{{out}}

<pre>

 

=={{header|Kotlin}}==

 

import java.util.stream.Collectors

println(" ${result.first} whose prime factors are ${result.third}")

}

 

{{out}}

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

 

=={{header|Nim}}==

Note that the program must be compiled with option <code>--threads:on</code>.

 

 

const Numbers = [576460752303423487,

echo ""

echo "The first number with the largest minimum prime factor is: ", result

 

{{out}}

Note that program must be compiled with option <code>--threads:on</code>.

 

 

{.experimental: "parallel".}

echo ""

echo "The first number with the largest minimum prime factor is: ", result

 

{{out}}

Numbers of workers to use can be adjusted using --W command line option.

 

 

 

{{out}}

=={{header|ooRexx}}==

This program calls the programs shown under REXX (modified for ooRexx and slightly expanded).

object1 = .example~new

object2 = .example~new

When which=1 Then Call pd1 bot top

When which=2 Then Call pd2 bot top

{{out}}

<pre>Start primes1: 09:25:25

1 primes found.

PD2 took 1.109000 seconds</pre>

/*PD1 REXX pgm does prime decomposition of a range of positive integers (with a prime count)*/

Call Time 'R'

/* [?] The dollar list has a leading blank.*/

if x==1 then return dollar /*Is residual=unity? Then don't append.*/

Call time 'R'

numeric digits 1000 /*handle thousand digits for the powers*/

/* [?] The dollar list has a leading blank.*/

if x==1 then return dollar /*Is residual=unity? Then don't append.*/

 

=={{header|OxygenBasic}}==

'CONFIGURATION

'=============

 

print str((t2-t1)/freq,3) " secs " numbers(n) " " f 'number with highest prime factor

 

=={{header|PARI/GP}}==

See [http://pari.math.u-bordeaux1.fr/Events/PARI2012/talks/pareval.pdf Bill Allombert's slides on parallel programming in GP]. This can be configured to use either MPI (good for many networked computers) or pthreads (good for a single machine).

{{works with|PARI/GP|2.6.2+}}

 

=={{header|Perl}}==

{{libheader|ntheory}}

use threads;

use threads::shared;

my($tnum, $n) = @_;

push @results, shared_clone([$n, factor($n)]);

{{out}}

<pre>

=={{header|Phix}}==

{{libheader|Phix/mpfr}}

{{out}}

<pre>

'[http://software-lab.de/doc/refW.html#wait wait]'s until all results are

available:

(mapcan

'((N)

122811709478644363796375689 ) )

(wait NIL (full Lst)) # Wait until all computations are done

{{out}}

<pre>-> (2532817738450130259664889 6531761 146889539 2639871491)</pre>

This piece needs prime_decomp definition from the [[Prime decomposition#Prolog]] example, it worked on my swipl, but I don't know how other Dialects thread.

 

thread_create(

(prime_decomp(Number,Y),

format('Number with largest minimal Factor is ~w\nFactors are ~w\n',

[Number,Factors]).

 

Example (Numbers Same as in Ada Example):

 

=={{header|PureBasic}}==

ThreadID.i

StartSeamaphore.i

end_of_data:

EndDataSection

[[image:PB_Parallel_Calculations.png]]

 

 

<small>Note that there is no need to calculate all prime factors of all <code>NUMBERS</code> when only the prime factors of the number with the lowest overall prime factor is needed.</small>

from math import floor, sqrt

if __name__ == '__main__':

 

{{out}}

<p>This method works for both Python2 and Python3 using the standard library module [https://docs.python.org/3/library/multiprocessing.html multiprocessing]. The result of the following code is the same as the previous example only the different package is used. </p>

 

 

# ========== #Python3 - concurrent

print(' The one with the largest minimum prime factor is {}:'.format(number))

print(' All its prime factors in order are: {}'.format(all_factors))

 

=={{header|Racket}}==

#lang racket

(require math)

; get the results and find the maximum:

(argmax first (map place-channel-get ps)))

Session:

> (main)

'(544651 115797840077099)

 

=={{header|Raku}}==

 

Using the <tt>prime-factors</tt> routine as defined in the [[Prime_decomposition#Raku|prime decomposition]] task.

83448083465633593921, 84209429893632345702, 87001033462961102237,

87762379890959854011, 89538854889623608177, 98421229882942378967,

$factor = find-factor( $n, $constant + 1 ) if $n == $factor;

$factor;

{{out|Typical output}}

<pre> 64921987050997300559 factors: 736717 88123373087627

 

=={{header|Rust}}==

//! 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

println!("The largest minimal factor is {}", max);

}

{{out}}

<pre>

SequenceL compiles to parallel C++ without any input from the user regarding explicit parallelization. The number of threads to be executed on can be specified at runtime, or by default, the runtime detects the maximum number of logical cores and uses that many threads.

 

import <Utilities/Math.sl>;

import <Utilities/Sequence.sl>;

indexOfMax := firstIndexOf(minFactors, vectorMax(minFactors));

in

 

Using the Trial Division version of primeFactorization here: [http://rosettacode.org/wiki/Prime_decomposition#SequenceL]

 

The primary source of parallelization in the above code is from the line:

Since primeFactorization is defined on scalar integers and inputs is a sequence of integers, this call results in a Normalize Transpose. The value of factored will be the sequence of results of applying primeFactorization to each element of inputs.

 

=={{header|Sidef}}==

The code uses the ''prime_factors()'' function defined in the "Prime decomposition" task.

1578070919762253, 14700694496703910,];

 

var factors = nums.map {|n| prime_factors.ffork(n) }.map { .wait }

{{out}}

<pre>

=={{header|Standard ML}}==

Parallel code is from the 'concurrent computing task'. Works with PolyML. Function -factor- is a deformatted version of the one from the prime decomposition page.

structure TTd = Thread.Thread ;

structure TTm = Thread.Mutex ;

 

end ;

call and output - interpreter

> threadedBigPrime [ 62478923478923409323, 69478923478923409313, 79234790234098402349,

33498023480920234793, 92834098234098023409, 31908234098234098243,

> List.map (List.foldr IntInf.* 1 ) it ;

val it = [62478923478925971503, 62478923478923409323]: IntInf.int list

 

=={{header|Swift}}==

{{libheader|AttaSwift BigInt}}

 

import Foundation

 

}

 

 

{{out}}

With Tcl, it is necessary to explicitly perform computations in other threads because each thread is strongly isolated from the others (except for inter-thread messaging). However, it is entirely practical to wrap up the communications so that only a small part of the code needs to know very much about it, and in fact most of the complexity is managed by a thread pool; each value to process becomes a work item to be handled. It is easier to transfer the results by direct messaging instead of collecting the thread pool results, since we can leverage Tcl's <code>vwait</code> command nicely.

{{works with|Tcl|8.6}}

package require Thread

 

return [array get result]

}

This is the definition of the prime factorization engine (a somewhat stripped-down version of the [[Prime decomposition#Tcl|Tcl Prime decomposition solution]]:

set computationCode {

namespace eval prime {

2532817738450130259664889

122811709478644363796375689

Putting everything together:

# values to its results (itself an ordered dictionary)

set results [pooled::computation $computationCode prime::factors $values]

return [join $v "*"]

}

 

=={{header|zkl}}==

Using 64 bit ints and "green"/co-op threads. Using native threads is bad in this case because spawning a bunch of threads (ie way more than there are cpus) really clogs the system and actually slows things down. Strands (zkl speak for green threads) queues up computations for a limited pool of threads, and, as each thread finishes a job, it reads from the queue for the next computation to perform. Strands, as they start up, kick back a future, which can be forced (ie waited on until a result is available) by evaluating it, in this case, by doing a future.noop().

xyzs:=vm.arglist;

fs:=xyzs.apply(factors.strand) // queue up factorizing 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

// do a bunch so I can watch the system monitor

{{out}}

<pre>

</pre>

[[Prime decomposition#zkl]]

acc:=fcn(n,k,acc,maxD){ // k is 2,3,5,7,9,... not optimum

if(n==1 or k>maxD) acc.close();

if(n!=m) acc.append(n/m); // opps, missed last factor

else acc;

 

{{omit from|6502 Assembly|Technically the language does this at a sub-instruction level but that doesn't count}}