Algo parallèle calculant n!

début 
  Entier fact=1;
  nbFact<--récupérer le nombre dont on doit calculer le factoriel
  Pour I variant de 1 à nbFact inclus
     fact<--fact * I
  FinPour

 Ecrire"Le factoriel de  ". nbFact." est :".fact

fin

C'est ça que tu veux ?! ? !

Zep3k!GnO

salut
algo fact;
var
s,i,r:entier.

debut
ecrire('entrer votre nombre');read(r);
s<--0;
pour i=1 a r fair
s<--s+r;
ecrire('le resultas est: ');ecrire(s);
fin.
----------
il faut etre serieux dant la vie

bonjour,

en préambule, je n'y connais rien en parallélisme.
ceci étant posé, j'ai quand même imaginé que globalement il devait y avoir un module de répartition du travail entre des entités (que j'ai appelées des threads) et qu'à la fin du travail, il fallait agréger les résultats de chaque thread.
je me suis donc construit un parallèle sérialisé en VBA (marque non déposée).
ça donne :

Function fact_parallele(n, nbthread)
Dim result()
ReDim result(nbthread)
' dispatch sur chaque thread
For j = 1 To nbthread
    result(j) = fact_thread(n - j + 1, nbthread)
Next
'agrège les résultats
resultat = 1
For j = 1 To nbthread
    resultat = resultat * result(j)
Next
fact_parallele = resultat
End Function

************

Function fact_thread(p, q)
    If p <= 1 Then
        fact_thread = 1
    Else
        fact_thread = p * fact_thread(p - q, q)
    End If
End Function

le tableau result() reçoit les résultats de chaque thread.

le calcul de la factorielle est réparti sur chaque thread.
par exemple, si je calcule 10! sur 3 threads, le premier calculera 10*7*4*1, le deuxième : 9*6*3 et le 3ème : 8*5*2.
le résultat agrégé correspond bien entendu au produit des résultats partiels de chaque thread.

voilà un petit délire sur ce que j'imagine être du traitement parallèle d'une factorielle!
pour tester : mettre le n dans A1, le nbre de threads en B1 et faire =fact_parallele(A1, B1) en C1

A+

un code plus dense :

Function fact_parallele_direct(n, nbthread)
'dispatch sur chaque thread et agrège directement
resultat = 1
For j = 1 To nbthread
    resultat = resultat * fact_thread(n - j + 1, nbthread)
Next
fact_parallele_direct = resultat
End Function