[résolu] Création code Binaire amélioré (BinEx, BinValEx)

[Ollivier]

T'as pas compris là. En fait, on a compris qu'on comprend pas, mais ne t'inquiète pas, on comprend...

Code : Tout sélectionner

 
	Global Dim NullRef.Q(62)


	Define.Q Iq
	Repeat
		Iq + 1
		NullRef(Iq) = ((1 << Iq) - 1) << 1
	Until Iq => 62


Procedure.S NelsonBin(n.Q)
	Protected.Q I
	Repeat
		I + 1
		If n < NullRef(I)
			ProcedureReturn RSet(Bin(n - NullRef(I - 1), #PB_Quad), I, "0")
		EndIf
	ForEver
EndProcedure


Procedure.Q NelsonVal(n.S)
	ProcedureReturn NullRef(Len(n) - 1) + Val("%" + n)
EndProcedure




	; Exemples
	For I = 0 To 7
		Debug Str(I) + "   " + NelsonBin(I)
	Next 

	Debug " "
	Debug NelsonVal(NelsonBin(1234567890123456789) )
	Debug NelsonBin(NelsonVal("10010110100101110010001101110111110010101011100010101101001011") )

[Lord Nelson]

Whaaaouuuuuuuuuuuuu terrible se truc !!!
Merci Ollivier

Sa marche en plus !!!
Par contre j’obtiens des erreur avec mon code à moi

Sa vient surement de chez moi
1000 merci

Je vais pouvoir continuer mes expériences
et pouvoir me rendre compte si ma méthode est ou pas à mettre au oubliettes.

Édit: Ma méthode sert pas à grand chose, je gagne jamais plus que 1 bits même avec la valeur 9223372036854775805
Je remercie les gents qui m'ont aidé, je leurs suis reconnaissant.

Cordialement.

[Frenchy Pilou]

une tête de cochon bouche ouverte qui tire la langue avec des fractales

Il en reste une image quelque part ? C'est trop intrigant!
Google ne trouve rien de concret!

Je connaissais ces animaux-là! Les éléphants de la vallée du même nom, de Douady!

[Frenchy Pilou]

Je voudrais convertir une image avec mon système, voilà pour faire simple et je ne veux pas utiliser le système binaire traditionnel.

Codage informatique des couleurs

[Demivec]

Très simple:

Code : Tout sélectionner

Procedure.s BinEx(Nombre)
  If Nombre < 2
    ProcedureReturn Str(Nombre)
  Else
    ProcedureReturn Mid(Bin(Nombre + 2), 2)
  EndIf
EndProcedure

Procedure.s BinValEx(BinEx$)
  If Len(BinEx$)
    ProcedureReturn Str(Val("%1" + BinEx$) - 2)
  Else
    ProcedureReturn ""
  EndIf
EndProcedure

Define Nombre, BinEx$

For Nombre = 0 To 1000
  BinEx$ = BinEx(Nombre)
  Debug "Codé: " + BinEx$ + " = " + Str(Nombre) + ", Décodé: " + BinValEx(BinEx$)
Next

Vous enregistrez seulement 1 caractère pas 1 bit (la haute-bit) pour la plupart des numéros (tous sauf 2 ) . Si vous allez utiliser des caractères il existe des méthodes plus efficaces ( c.-à- hexadécimal est mieux ) .

Est-ce pour faire des valeurs obscur ?


Vous pouvez améliorer légèrement la méthode à utiliser:

"" = 0
0 = 1
1 = 2
00 = 3
01 = 4
10 = 5
11 = 6
000 = 7
001 = 8

[Micoute]

Bonjour Demivec, très sympa ce style de codage, mais est-ce réversible ?

[Lord Nelson]

Et bhé je suis sacrément gâté
Merci beaucoup pour votre aides !

Vous enregistrez seulement 1 caractère pas 1 bit (la haute-bit) pour la plupart des numéros (tous sauf 2 ) .
Si vous allez utiliser des caractères il existe des méthodes plus efficaces ( c.-à- hexadécimal est mieux ) .

Désoler, je ne vous comprends pas, que voulez vous dire par là ?

Est-ce pour faire des valeurs obscur ?

Je ne vous suis pas désoler, valeurs obscur ?

Vous pouvez améliorer légèrement la méthode à utiliser:
"" = 0
0 = 1
1 = 2
00 = 3
01 = 4
10 = 5
11 = 6
000 = 7
001 = 8

Je vous remercie, cependant dans mon cas se serais inutile et ça prendrais encore plus de place !

En faite je pensais que au bout d'un moment avec cette méthode, j'allais gagner pleins de bits
par apport à la version standard mais malheureusement il en fut point ainsi

Encore milles merci à tous ceux qui m'ont aidé

[Demivec]

Bonjour Demivec, très sympa ce style de codage, mais est-ce réversible ?

Quel style de codage? J'ai montré à la fois BINEX () et BinValEx ().

Le procédé associé (où "" = 0, 0 = 1, 1 = 2) est accomplie par conséquent:

Code : Tout sélectionner

; légère modification
Procedure.s BinEx(Nombre)
  If Nombre < 1
    ProcedureReturn ""
  Else
    ProcedureReturn Mid(Bin(Nombre + 1), 2)
  EndIf
EndProcedure
 
Procedure.s BinValEx(BinEx$)
  If Len(BinEx$)
    ProcedureReturn Str(Val("%1" + BinEx$) - 1)
  Else
    ProcedureReturn "0"
  EndIf
EndProcedure

Define Nombre, BinEx$

For Nombre = 0 To 1000
  BinEx$ = BinEx(Nombre)
  Debug "Codé: " + BinEx$ + " = " + Str(Nombre) + ", Décodé: " + BinValEx(BinEx$)
Next

Désoler, je ne vous comprends pas, que voulez vous dire par là ?

Je veux dire moins de caractères, pour sauver un octet ou deux dans un fichier.

Je ne vous suis pas désoler, valeurs obscur ?

Vous faites les valeurs sibyllin parce qu'ils ne sont pas strictement binaire. Quelqu'un ne peut pas changer les valeurs sans connaître votre méthode secrète.

[Lord Nelson]

Vous faites les valeurs sibyllin parce qu'ils ne sont pas strictement binaire. Quelqu'un ne peut pas changer les valeurs sans connaître votre méthode secrète.

C'est une idée, pour du cryptage quoi en gros ?
C'est pas ce que je pensais faire mais ça peut aussi fonctionner !

Non en faite je pensais pouvoir gagner des bites (Byte) par apport à la version binaire standard voilà
Mais ça ne fonctionne pas

Je cherche un moyen de pouvoir compresser du code binaire autrement que par le système classique -> 8 bits = 1 octets
Si je pouvais faire 9 bits -> 1 octets, ce serait déjà ça !

Voilà

[Ollivier]

@Frenchy pilou

Ça fait 6 ans que le forum francophone de DarkBasic est dégagé.

Une possibilité est de recréer cette erreur de calcul sur les CPUs d'aujourd'hui. Ce que tu montres plus haut est très joli, mais les explications sont comme celles des étoiles dans le Ciel: c'est interprété.
Il n'y a pas de ressemblance avec ce qui est dit.

Avec des erreurs (très particulières), les fractales partent en cacahuètes. En me déplaçant dedans, j'avais trouvé cette tête de cochon vue de profil qui tire la langue. C'est une coïncidence (fallait la trouver, c'était lent aussi).

D'ailleurs, ce que tu montres plus haut, ce n'est qu'une succession d'erreurs de dépassement de multiplications dont on exhibe chaque reste au sein d'un pixel.

@Demivec

C'est bien ce que tu as fait. C'est très pragmatique. C'était ma vingtaine de minutes de programmation dans le mois. J'apprécie une telle réponse.
Les conversions méritaient une telle optimisation, qui, de plus, non seulement d'être convertible en quad, s'épargne d'une erreur de dépassement qui est dans la fonction "NelsonBin()".

Cependant, le tableau NullRef() a une utilité: il permet d'évaluer l'architecture du préfixe à établir pour déterminer la taille du/des nombre(s) qui va/vont suivre. Là, Mid et Bin sont insuffisants. Le but étant de savoir les contraintes du gain de compression. Je doute que, dans ce cas une dichotomie ne soit pas indispensable.

Après, il faut quand même le temps de vérifier s'il n'y a pas un algo déjà présent sur le Net...

[case]

tu stock comment tes valeurs ?

je reprend ton exemple 01 = 2

si tu lis un espace mémoire tu lis obligatoirement 8 bits au minimums (peek), il n'y a que des 0 et des 1 aucune autre valeur

si rien n'as été ajouté a l'adresse mémoire que tu vas lire tu aura a minima 0000000 comment peux tu différencier un bit a zéro d'un bit a zéro que tu aurais ecrit

ou alors tu vas stocker ces 'bits' dans des strings "0" "00" etc chaque 'bit' dans les strings est codé sur 8 bits donc "0" = 8 bits "00" = 16 bits pour représenter 2 bits

quoi que tu essaie tu ne pourra pas 'gagner de place en mémoire grâce a ta méthode.

[Ollivier]

Bonjour case,

je ne comprends pas où tu vois que c'est cette norme est utilisée pour quantifier alors qu'elle ne peut que qualifier.

Ex: les nombres ici vont de 0 à 25
00.0
11.1111
Les 2 premiers bits sont exactement ce que tu décris. Et le point n'existe pas concrètement.
Le but n'est pas de dire, mais de mesurer pour prouver, Et d'avoir le nombre de paramètres à mesurer, notamment taux de compression, taux d'excès et taux de destruction sur des tailles de nombre raisonnables.

[Lord Nelson]

Bonjour, vous inquiétez pas, c'est pas pour la mémoire hein mais un fichier
Avec le code binaire améliorer, tu stocke beaucoup plus de valeur !

Sa une utilité pour moi !
Reste à la mettre en pratique !

[Fig]

Après on peut toujours utiliser un codage de type huffman, on compresse effectivement mais pas du binaire, il faut des données de nature différente. (par exemple, le morse est un codage huffman)

Avec 2 valeurs 0 ou 1 on ne peut pas obtenir un meilleur codage (meilleur= optimisé en ce qui concerne la mémoire) que le binaire pour coder les nombres. (à moins qu'on puisse prouver que, pour une application particulière, on n'utilise pas avec la même fréquence chacun des chiffres)

[Ollivier]

@Fig

C'est juste. En gros, on rajoute un bit dans un champ de données numérique quelconque composé de 2 parties: un quantifiant au format fixe et un qualifiant au format précédemment quantifié. La destruction reste stable (2 nombres) donc insignifiante avec une taille de nombre de plus en plus grande.

Le tout favorise près d'un quart de l'ensemble des nombres possibles, laisse indifférent un autre quart environ et défavorise la moitiée restante.

Les nombres favorisés (compressés) suivent une "faveur" pondérée. (1/8 sont mieux compressés, 1/16 encore mieux, et ainsi de suite).

C'est donc une compression qui nécessite un sondage, en vue de transcrire les nombres selon leur fréquence pour qu'il "allouent" une place de "faveur" dépendant directement de leur fréquence d'apparition.

Conclusion hâtive: c'est simple, purement logique donc entièrement compatible avec tout autre type de compression, peu rentable mais rentable quand même, mais surtout, c'est lent vu que ça nie les formats numériques de taille 8N (en bits)... (3N, 9N, 17N, 33N, etc...)