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

thread 1: not larger: 3 of 12757923

Largest factor: 47 of 12878893</pre>

 

=={{header|C++}}==

This uses C++11 features including lambda functions.

 

#include <iterator>

#include <vector>

});

return 0;

{{out}}

<pre>

12878893 = [ 47 274019 ]

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

Number with largest min. factor is 115797840077099, with factors:

[544651, 212609249]</pre>

 

=={{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>

8> parallel_calculations:task().

12878611 has largest minimal factor among its prime factors [2713,101,47]

</pre>

 

===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>

Number with largest min. factor is 115797840077099, with factors: { 544651 212609249 }

</pre>

 

=={{header|Fortran}}==

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}}==

 

nums :: [Integer]

 

 

 

 

{{out}}

 

==Icon and {{header|Unicon}}==

The following only works in Unicon.

 

threads := []

L := list(*A)

link factors

 

Sample run:

 

=={{header|J}}==

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;

public interface ParallelCalculations {

 

<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|Oforth}}==

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

 

 

 

{{out}}

</pre>

 

 

=={{header|OxygenBasic}}==

'CONFIGURATION

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

 

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

 

 

 

 

 

=={{header|PicoLisp}}==

'[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):

true.

</pre>

=={{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|SequenceL}}==

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>

sidef parallel.sf 24.46s user 0.02s system 158% cpu 15.436 total

</pre>

 

=={{header|Tcl}}==

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|AWK}}

{{omit from|AutoHotkey}}