Discussion :

[yassinema]

salut !!

je veux trouver le nombre d qui réalise (e*d) mod z =1
je etulise ce code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
dim d,z,e as double
d=0 
while (e*d) mod z <> 1
 
d=d+1
end while

je veux créer un thread comment ?
j'ais un button est trois textbox

[Invité]

tu fais un dépassement de capacité donc tu ne sors pas de ta boucle.

[hunteshiva]

Bonjour,

le code marche très bien

Pas vraiment convaincu, et met un peu de commentaire sinon on a du mal à comprend tes calculs

Effectue la division de deux nombres et retourne seulement le reste.

number1 Mod number2

pour ton problème de freeze, tu peux essayer de lancer ton calcul dans un thread,
ça laisse la main au pc sans trop le tuer.

en 2-3 lignes c'est bon

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
        ' Création du Treah
        Dim MonThread As New Thread(AddressOf MaFonction) ' <- fonction que tu crée au préalable
        ' Lancement du Tread
        MonThread.Start()
        'Laisse le temps de terminer le Thread pour la suite du code
        System.Threading.Thread.Sleep(100) ' permet de ne pas figer l'interface

pour la fonction sleep il faut la librairie :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Imports System.Threading

PS: ce ne sont que des idées, rien de plus
PPS: pour ton vrai problème, "gcorbineau" à la solution

[yassinema]

merci hunteshiva Expert

je vais essayer ton idée

j'espère que gcorbineau(chevronné) me donne la petite solution

[DonQuiche]

Bonjour, il y a plusieurs problèmes avec ce code et l'énoncé donné :
* Il y a plusieurs valeurs possibles pour d, ou aucune, mais jamais une seule. Je présume qu'on cherche la plus petite valeur quand il en existe une.
* Il n'existe pas de critère d'arrêt, le code tournera indéfiniment s'il n'existe aucune solution.
* Il pose des problèmes d'arrondis qui peuvent fausser les résultats, il faut utiliser un type entier : int, voire long si nécessaire.
* On peut faire beaucoup plus efficace.

A part cela, c'est Hunteshiva qui a vu juste.

[yassinema]

bon merci
je voulais faire la methode de Thread mais c'est pas facile pour moi
moi j'ai un button et 3 textbox

merci de m'aider

[hunteshiva]

tu créer une fonction *exemple*

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Public Function MaFonction(ByVal Param_e As Double, ByVal Param_z As Double) As Double
 
   ' Déclaration des variables
   Dim Param_d as Double
 
   ' Init des variables
   Param_d = 0
 
   ' Calcul
   While ((Param_e * Param_d) mod Param_z) <> 1
 
      Param_d += 1 ' Incrémentation de 1
 
   End While
 
   MaFonction =  ?? ' Un Double <- valeur de retour
 
End Function

[yassinema]

salut

est ce que la fonction fait le travaille du thread ??

[Pol63]

demande à google sinon

[DonQuiche]

En fait, le vrai problème ici c'est qu'avec de grandes valeurs ton calcul prendra plusieurs millénaires (et peu importe alors l'affichage d'une barre de progression) alors qu'avec le bon algorithme le résultat se trouve en moins de 100ns (nanosecondes). Quand je te disais qu'on pouvait faire beaucoup plus efficace...

(e*d)%z = 1 est équivalent à e*d - k*z = 1 avec k un entier fonction de d. Et cette dernière équation est ce qu'on appelle une identité de Bézout. Et la première solution (ou l'absence de solutions) est déterminée par l'algorithme d'Euclide étendu, qui s'implémente en dix lignes de code.

Les problèmes mathématiques se résolvent d'abord par les mathématiques, le calcul brut n'est qu'un dernier recours.

[yassinema]

DonQuiche

j'ais déja chercher comment appliquer l'Équation diophantienne en programmation car je connais que le coté math étudié au lycée
et j'ais fais un prog pour calculer le plus grands diviseur commun avec l'algorithme d'Euclide

[DonQuiche]

Ok, tu avais donc déjà creusé mais sans succès... Voilà un bout de code qui traînait dans mes archives. C'est du C# mais ça ne devrait pas être difficile à comprendre.

Code c# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// Résoud l'équation diophantienne ax + by = pgcd(a,b) (identité de Bézout) via l'algo d'Euclide étendu et retourne pgcd(a,b).
static long ExtendedEuclide(long a, long b, out long x, out long y)
{
    if (Math.Abs(a) < Math.Abs(b)) return ExtendedEuclide(b, a, out y, out x);
 
    long u1 = 1, u2 = 0;
    long v1 = 0, v2 = 1;
    long r1 = a, r2 = b;
    while (r2 != 0)
    {
        long q = r1 / r2;
        long u3 = u1 - q * u2;
        long v3 = v1 - q * v2;
        long r3 = r1 - q * r2;
 
        u1 = u2; 
        u2 = u3;
        v1 = v2;
        v2 = v3;
        r1 = r2;
        r2 = r3;
    }
 
    long pgcd = r1;
    x = u1 * Math.Sign(pgcd);
    y = v1 * Math.Sign(pgcd);
    return Math.Abs(pgcd);
}

Et j'y ai ajouté ça pour l'adapter à ton problème :

Code c# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Résoud (d * e) % z = 1
static bool Solve(long e, long z, out long d)
{
    long k;
    ExtendedEuclide(e, z, out d, out k);
    if (z == 0) return false;
 
    // Infinité de solutions : depuis celle trouvée, on cherche la plus petite après zéro (dont on sait qu'elle est inférieure à z).
    // Démo : si d est solution, d+z l'est aussi : e*(d+z) + k*z = e*d + (k+e)*z = e*d + k'*z 
    d = (d % z + z) % z;
 
    // Vérification empirique, le plus sûr
    return (d * e) % z == 1;
}

PS : Il faudra activer les vérifications arithmétiques et gérer ArithmeticException.

[yassinema]

ok merci j'ais comprie le code