BIN_INV BIN_SHL BIN_SHR

Est-il possible d'avoir une info pour savoir quant sortira ces trois instructions.
Je suis sur du codage, et même si je peux me débrouiller autrement pour l'instant, j'aurai aimé connaitre le moment où on verra le jour de ces trois instructions.
D'avance merci

Jean Claude a aussi pas mal d'instructions comme ça,
écrites en martien.
Et alors, ça servirait à quoi (INVSHLSHR-KLKHNJGFEF-DJKHG) ?

Opérations en binaire sur des entiers
BIN_INV: inverser les bits d'un entier (0->1, 1->0)
BIN_SHL: shift/left décalage à gauche d'un bit ( = multiplié par 2)
BIN_SHR: shift/right décalage à droite d'un bit ( = divisé par 2)

Ah oui, c'est pas mal !
Le bin_inv, on peut déjà le faire en faisant :
bin_xor(x,255)
les autres, il y a sûrement un moyen,
mais sans doute plus compliqué
et de nouvelles commandes seraient effectivement utiles.

T'as tout compris ! (tu as Free ?)

("Putain"), je me suis planté. En lisant les explications de JL35, j'ai eu un doute sur les instructions que je demandais. J'ai pas fais d'assembleur depuis 87, je crois, et j'ai oublié les décalage, qui de fait multiplie ou divise par 2 et c les rotations: ROR: rotation à droite, et ROL rotation à gauche (pour assembleur 6502)
Il faut que je regarde les tables de vérité sur les opérateurs, et récupérer le bit de gauche et voir en multipliant par deux, et soustraire le dépassement de bit par soustraction de 256 (je pense, il faut que je fasse les essais), on doit pouvoir en décimal faire ce genre d'opération. J'ai pas appris les maths comme vous, mais je devrais m'en sortir. Si à tout hazar l'un d'entre vous à une réponse toute faite et qu'il veuille bien la donner, je gagnerais du temps.
Merci d'avance (même si il n'y a pas de réponse, j'aurais du regarder un peu mieux avant de faire cette demande. (opération dans les deux sens, ROR et ROL)

Ah tu veux une rotation ? c'est à dire reporter le bit qui sort à l'autre bout ?

Alors, sauf erreur, je verrais quelque chose comme ça (uniquement pour un octet de 0 à 255):

Code:

DIM octet, bit
octet = octet AND 255: ' seulement 8 bits

' 1) ROL décalage à gauche avec report à droite du bit débordant
bit = 0: IF octet > 127 THEN bit = 1
octet = octet * 2 + bit

' 2) ROR décalage à droite avec report à gauche du bit débordant
bit = (octet AND 1) * 128
octet = INT(octet / 2) + bit

Mais j'avoue que je n'en vois pas bien l'usage...

Ca ne marche pas :
(octet = octet AND 255)
il faut mettre :
octet = bin_and(octet,255)
et pour l'autre :
bit = bin_and(octet,1)*128

Mais non, c'est rien,
je sais, l'alzeimer.

Ca me coûte, mais je dois bien reconnaître que tu as raison, j'ai confondu le and et le bin_and, vieille déformation du vieux basic (par un tout jeune programmeur).
C'est pas une raison pour rigoler !

Bon, ben j'ai plus qu'à

Je vous remercie, pour vos réponse. J'avais déjà à peut-près la réponse pendant le diner, maintenant j'expérimente.
Merci. Comme quoi, tout est possible si on prend la peine de se creuser la tête.

Je montre le premier teste. Peut-être aurez-vous des remarques à faire.
Les nombres binaires sont reportés depuis une calculette pour contrôle.

Code:

dim a% ,b% ,deb% ,n% :width 0,720
memo 1:width 1,700:height 1,300:font_size 1,12:font_name 1,"Bitstream Vera Sans Mono" :print_target_is 1

a%=230
  ' nb binaire reporté depuis une calculatrice scient. pour vérification
print "ROL rotation à gauche"
      print "        nombre de départ:",right$("  "+str$(a%),3)  ,"  : 1110 0110"
     
deb%=  bin_and(a%,128):if deb%=128 then deb%=1
      print "            débordement:",right$("  "+str$(deb%),3),"  : 1000 0000"
     
n% =  bin_and(a%,127)
      print "nb soustrait du 8ème bit:",right$("  "+str$(n%),3)  ,"  : 0110 0110"
     
a%= n%*2+deb%
      print "                  décalé:",right$("  "+str$(a%),3)  ,"  : 1100 1101"
      print "__________________________________________________________"
print "ROR rotation à droite, reprise du nb précédent décalé, soit :",a%
      print "        nombre de départ:",right$("  "+str$(a%),3)  ,"  : 1100 1101"
     
deb%= bin_and(a%,1):if deb%=1 then deb%=128
      print "            débordement:",right$("  "+str$(deb%),3),"  : 1000 0000  nota le 1 devient 128"
     
n% =  bin_and(a%,254)
      print "nb soustrait du 1èr  bit:",right$("  "+str$(n%),3)  ,"  : 1100 1100"
     
a%= n%/2+deb%
      print "                  décalé:",right$("  "+str$(a%),3),"  le nb de départ" 

A plus.

Ca a l'air d'être bien,
mais des calculs comme ça,
à une heure pareille,
je ne t'en dirai pas plus.

J'ai pas de chance, au moment de mettre la formule simplifiée, sans les présentations, mon ordi s'est planté Heureusement il y a la sauvegarde ici, vu que sur l'ordi je ne l'avais pas faite Je récupère, et je rajoute

Code:

dim a% ,b% ,deb% ,n% :width 0,720
memo 1:width 1,700:height 1,300:font_size 1,12:font_name 1,"Bitstream Vera Sans Mono" :print_target_is 1
print "======================================================= "
print "          simplification"
a%= 230
print "___________ROL___________"
deb%=bin_and(a%,128):if deb%=128 then deb%=1
n%=bin_and(a%,127)*2+deb%  :  print n%
print "___________ROR___________"
a%=n%
deb%=bin_and(a%,1):if deb%=1 then deb%=128
n%=bin_and(a%,254)/2+deb%  :  print n%

Si j'ai fait une erreur, corrigez moi, mais tous les essais que j'ai fait semblent bon

Bonsoir,

J'ai regardé et testé ces fonctions, et tout me semble bon !

Tu travailles sur des "caractères, n'est-ce pas ? Donc des nombres "non signés" de 8 bits, compris entre 0 et 255.

Qu'en est-il des entiers de type "dim n%" ? Là, il s'agit d'entiers signés sur 16 bits, le 16ème bit indiquant le signe. En respectant la convention suivante:

1 = 0000 0000 0000 0001
0 = 0000 0000 0000 0000
-1 = 1111 1111 1111 1111

etc. Dans ce cas, il faut traiter les nombres positifs et négatifs séparément, en faisant un bin_xor entre ton nombre de départ et -32767 pour écarter le signe (-32767 = binaire 1000 0000 0000 0000), puistu adapte ton algorithme en utilisant le bit 0100 0000 0000 0000 pour le débordement. Il ne reste plis qu'à rétablir de signe négatif des nombres négatifs via le même bin_xor.

Ca vous serait utile d'avoir une fonction DLL qui réalise tout cela ? En attendant que Panoramic soit étendu à ces instructions, je pourrais l'inclure à ma DLL qui est disponible sur mon site (rubrique "copier un mémo dans le presse-papier). Elle recevra à terme toutes les routines, et contient pour l'heure la routine ClipboardCopy.

Salut
Je suis d'accord pour ta proposition. Mais moi c'est bien sur les caractères que je travaille actuellement. Pour ce cas de figure, il m'importe peu que ce soit des nb signés ou non.J'ai besoin de garder tous les bites, pour pouvoir les rétablir ensuite.
Maintenant, je passe ma journée en forêt avec ma tronçonneuse.
Salutation

Il suffit de te dire qu'un arbre debout c'est un bit à 1 et un arbre coupé c'est un bit à zéro, comme ça tu peux continuer à réfléchir et à faire tes expériences.
Je vais me faire tuer par les écolos.

Cela dit, Klaus je suis très intéressé par ta dll. Il faudra que j'apprenne à l'utiliser mais ça ne doit pas êtdre bien sorcier.

Salut,

Ma DLL est au point pour les entiers sur 16 bits, avec les fonctions:

Code:

resultat%=bin_ROL(valeur%,compteur%)
resultat%=bin_ROR(valeur%,compteur%)
resultat%=bin_SHL(valeur%,compteur%)
resultat%=bin_SHR(valeur%,compteur%)

Je suis en train de faire les fonctions analogues pour des caractères:

Code:

resultat%=bin_CROL(valeur%,compteur%)
resultat%=bin_CROR(valeur%,compteur%)
resultat%=bin_CSHL(valeur%,compteur%)
resultat%=bin_CSHR(valeur%,compteur%)

et ce sera en ligne bientôt sur mon site !

Pour ce qui est des arbres coupés, et l'écologie, je tiens à faire savoir qu'une forêt qui est entretenue se porte beaucoup mieux qu'une forêt qu'on laisse faire. Un incendie dans une forêt fait énormément de dégâts. Nos petites communes vivent beaucoup de l'exploitation du bois, et bien souvent n'ont que cette apport comme richesse. La détruire, c'est aussi détruire à échéance ses revenus. Je crois que la forêt dans nos régions, augmente, ce qui n'est pas le cas partout. De plus le bois que nous exploitons chez nous, ne contribue à l'importation de bois des les pays qui défrichent à tout va, sans compter la pollution supplémentaire pour faire venir du bois de ces zones là. L'affouage qui est présent dans nos régions (voyez Wikipédia si vous ne connaissait pas) consiste à récupérer le haut des cimes après abattage d'un arbre, dont le tronc sert aux métier du bois, au lieu de le laisser pourrir, à abattre aussi des arbres malade, ou des arbres qui gêne le développement d'autre qui ont besoin d'espace. Cela dit un arbre qui pourri est aussi une source de fonctionnement pour une forêt., mais depuis année je n'ai pas utilisé une seule goutte de mazout pour ma chaudière, je me chauffe au bois, et aucun dans nos région pense un seul instant qu'il met la planète en danger.
Cela dit je ne pense pas que tu es voulu être méchant avec moi, mais parfois, il faut expliquer les choses pour comprendre, et comme tu dis un arbre debout c'est un 1, et un arbre couché c'est pour moi, un arbre -1.
@+

Eh cosmos, évidemment que je plaisantais. Et comme tu sembles être chatouilleux sur le sujet, je précise que je n'ai rien contre l'entretien des forêts qui se traduit aussi par des coupes, comme dans un jardin. Bon, d'accord, il faut faire attention à ce qu'on dit pour ne froisser personne...

Ca y est: ma DLL est en ligne sur mon site. Elle s'appelle KGF.dll. Voici le lien:
http://membres.multimania.fr/klaus/Bienvenue.1.html

Regardez la page d'info sur la DLL pour la doc et téléchargez-là.

Il y a pour le moment 14 fonctions, dont 3 groupes de 4 fonctions pour les manipulations binaires. J'ai fait les routines ROL,ROR,SHL et SHR en version 32 bits pour les entiers Panoramic, en 16 bits et en 8 bits pour les caractères. Comme ça, il y en a pour tout le monde.

Alors, à vos guirlandes binaires défilantes...

J'ai fini ma journée (il fallait que je ramène la voiture). Pas de panique JL, tes propos ne m'ont pas chatouillés. Dans Ma République à Moi, chacun a le droit de dire ce qu'il pense, et tu peux avoir un regard différent du mien. Ce que j'ai dit n'est qu'une info (et non un faux, parce que c'est un vrai). j'ai pu constaté que des gens non informés, avaient un point de vue sur certaines choses, en rapport de ce qu'on a l'habitude d'entendre ici et là, et parfois une contre vérité doit-être signalée pour avoir une plus juste opinion. Cela dit j'ai vraiment pas de plaisir à descendre un arbre. Il y a 15 jours, en abattant un, il est tombé sur un autre, et l'a déraciné. Franchement je n'en suis pas fière.
Si mes propos peuvent parfois semblé sulfureux, c'est que je ne sais pas m'exprimer autrement. Mon problème est que j'ai du mal à me faire comprendre, ce qui m'oblige à mettre toute une tartine pour dire les choses. Donc JL pas de problème! et continu à dire les choses comme tu le sens.

A Klaus: est-ce que une dll est plus rapide que les lignes que j'ai mis hier soir?.
A++

Bonsoir, Cosmos70,

Oui, sans contestation possible, la DLL sera nettement plus rapide, et si la vitesse est un critère, alors il n'y a pas photo.

A titre d'exemple, je libre ici la partie du code de la DLL qui réalise la rotation à gauche d'une valeur de 16 bits:

Code:

// rotation 16 bits de "num" à gauche de "cnt" bits
function bin_WROL(num, cnt :integer) :integer; stdcall; export;
asm
        PUSH    ECX
        MOV    EAX,num
        MOVZX  EAX,AX
        MOV    ECX,cnt
        ROL    AX,CL
        POP    ECX
        MOV    @RESULT,EAX
end;

Comme tu vois, le tout est joué en 7 lignes assembleur. En temps d'exécution, c'est négligeable, d'autant que la routine est capable de travailler sur un décalage de "cnt" bits d'un coup ce qui évite les boucles s'il faut décaler de 3 bits, par exemple...

Bien sûr, il faut garder la DLL ouverte pendant le programme et ne pas l'appeler et la fermer chaque fois qu'on en a besoin, sinon, l'effet recherché est gâché !

Y'a pas de lézard cosmos, crois-moi, comme tout le monde ici c'est toujours avec le sourire et sans aucune arrière pensée. Et chacun apporte sa petite pierre à l'édifice en fonction de ses connaissances acquises (certains des pierres plus grosses), mais toujours dans la bonne humeur.

Pas de lézard non plus.
Pour le temps d'exécution, je pensais au temps d'appel de la routine, et non à la routine, vu que par exemple avec execute le programme doit lire d'abord l'adresse du programme, et Panoramic, je crois est long à la trouver. Jl35 en essayant de lire octet par octet, trouve que de ce côté le temps est interminable.
Mais peut-être le premier appel est long, et ensuite tout va vite avec dll. Ce sera mon 1er essai avec cette instruction.
merci