Simplifier un modulo - Page 1

Je ne peux que travail en 32 bits signé mais le problème c'est lorsque j'essaye de faire un modulo avec un nombre qui dépasse cette capacité. Je voudrais savoir comment faire pour simplifier mon nombre et effectuer un modulo avec de telle sorte que le résultat soit identique avec un nombre >32 bits signé.

Cette question n'as pas ça place dans le forum TI car je travail en faite sous Visual Basic, j'ai fait de nombreuse recherche à ce sujet et aucune réponde.

Donc quand je fait Nombre >32 bits signé mod 8 j'ai un dépassement de capacité et je voudrais le détourner.

moi je propose &7 dans ce cas
tout depend le modulo

Bas le modulo varie de 16,10,2.

pour faire un modulo de nombre pair, il me semble que tu peux faire un &(nbr-1)
ceka dit, je sais pas si les operateurs sur bits existent en vb

Les opérateur sur bits en VB n'existe pas

arf

Et puis ce n'est pas des modulos sur les nombres pairs qui se simplifient, mais les modulos avec des puissances de 2 (2,4,8,16,...)

heu, oué, merde

Il me semble que x mod y = (x-y) mod y (c'est une idée qui me vient comme ça).
Si oui, alors on a la solution : on calcule combien de fois il faut soustraire y à x pour que le nombre tienne sur 32 bits. Après, on n'a plus qu'à faire le modulo

turn (nombre_trop_grand - diviseur*combien_de_fois_diviseur) % diviseur; }

Tiens, si mon intuition a été bonne, voici l'algo qui résoud ton problème :short calculer_modulo(long long nombre_trop_grand, short diviseur)
{
  long long depassement;
  long long combien_de_fois_diviseur;
  
  depassement= nombre_trop_grand - 0xFFFFFFFF;
  combien_de_fois_diviseur= (depassement / diviseur) + diviseur;
  
  re

Reste à savoir si le VB accepte la division à partir d'un nombre du 64 bits... j'en doute, vu qu'il n'accepte pas le modulo

Ha ! je pense à une méthode qui n'utilise pas de division sur 64 bits, attendez

[edit]
Un nombre sur 64 bits c'est un mot de poids fort Msw et un mot de poids faible Lsw. On peut le décomposer : x = Msw*0xFFFFFFFF + Lsw

w - k1) · (0xFFFFFFFF - k2) + Lsw - k3]

Ainsi, on peut décomposer le problème : x_sur_32_bits = (Msw - k1·y) · (0xFFFFFFFF - k2·y) + (Lsw - k3·y)
               = y · [y · (Ms

On ne travaille qu'avec des nombres sur 32 bits

En effet VB n'accepte pas les divisions sur 64 bits. J'avais déjà essayé une méthode mais sans succès:

modulo=(MonNombre-1)/Base mod (Base/2)

geogeo
a écrit : Donc quand je fait Nombre >32 bits signé mod 8 j'ai un dépassement de capacité et je voudrais le détourner.

Tu as besoin du résultat modulo 8 seulement? Commence par prendre le modulo 8 de tous tes entrées! On a:
(a+b) mod 8 = ((a mod 8) + (b mod 8)) mod 8
(a-b) mod 8 = ((a mod 8) - (b mod 8)) mod 8
(a*b) mod 8 = ((a mod 8) * (b mod 8)) mod 8
Attention, ça ne marche pas avec la division!

Bah voilà, tu appliques ces formules au nombre décomposé (cf post #10)

x mod y = [ (Msw*0xFFFFFFFF mod y)                  + (Lsw mod y)] mod y
        = [((Msw mod y) * (0xFFFFFFFF mod y)) mod y + (Lsw mod y)] mod y

si j'ai bien pigé.

Non j'ai besoin du resultat de modulo 2,10,16.

Mais je ne vois pas à quoi correspond a et b ici car je fait seulement x mod 2 ou 10 ou 16 mais x est supérieur à 32 bits signé.

Bon, pour 2 et 16, tu jettes le Long de poids fort, il ne te sert pas. Pour 10, tu as:
x = msDWORD * 4294967296 + lsDWORD
Donc:
x mod 10 = ((msDWORD mod 10) * (4294967296 mod 10) + (lsDWORD mod 10)) mod 10 = ((msDWORD mod 10) * 6 + (lsDWORD mod 10)) mod 10
C'est aussi simple que ça.

J'ai [((Msw mod y) * (0xFFFFFFFF mod y)) mod y + (Lsw mod y)] mod y en appliquant les formules. Je me suis trompé où ?

Ah oui, il faut que j'applique un mod 10 autour du tout aussi. Mais c'est bien 0x100000000, pas 0xFFFFFFFF.

Voilà, c'est corrigé. Il y a toujours un modulo en moins que dans ta formule parce que 9*6+9 ne risque pas de déborder si on calcule sur 32 bits.

ok

---

heu nan il faut aussi le modulo autour du (Msw mod y) * ((0xFFFFFFFF+1) mod y)x = a*b <=> a*b < x, parceque 9*6 > 10.a*b mod nan ?

Ben non. On a aussi (a + b) mod 10 = (a + (b mod 10)) mod 10. Pas besoin d'appliquer le modulo aux deux.

Tu l'avais pas donnée cette formule

Donc a ce que je vois je doit faire un modulo pour chaque base (2,16) et 10. J'aurais pensé qu'il y avait plus simple

((msDWORD mod y) * (4294967296 mod y) + (lsDWORD mod y)) mod yNon, tu peux garder la formule générale qui marche pour tous : x mod y =96 % y) + (lsDWORD % y)) % y; }

Ca donne une fonction du genre :short modulo(long long x, short y)
{
  long msDWORD= x >> 32;
  long lsDWORD= x;
  
  return  ((msDWORD % y) * (42949672

Et là, j'ai un doute : si x est négatif, le lsDWORD n'est ni signé, ni non-signé... Ca marche quand même ?

Sous Visual Basic il met impossible de faire des décalage binaire et surtout 4294967296 mod y ne risque pas de marcher puisque 4294967296>2^10.
Si je ne peut pas faire de modulo avec un nombre en 32 bits alors encore moins en 64 bits.

(4294967296 mod y) = ((65536 mod y)*(65536 mod y)) mod y
Et ça, tu peux le faire sous VB.

C'est bizarre Kevin ta formule semble correcte et pourtant elle ne fonctionne pas. Mais j'ai remarqué aussi un autre bug qui n'est pas du à la convertion avec les module c'est que l'ordre des chiffres est inversé donc je pense que le mieux c'est de faire ça en 8 bits puis de traiter la chaîne de caractère pour la convertir en 16 et 32 bits, certe ça ne fonctionneras pas en base 10 mais ce n'est pas grave.

Tu dis qu'elle ne marche pas. Pour tous les nombres, ou seulement pour les nombres négatifs ?