Compression RLE - Page 6

Sally (./150) :
mais le fait reste que parler d'opération booléenne sans préciser ça peut laisser penser qu'il s'agit d'opérations sur les booléens, au sens « valeurs de vérité ».

Ben justement, tu fais une opération au sens "valeur de vérité", hein (enfin, AMHA)

Ben quand tu as un caractère représenté par 01001101, tu t'en fous de savoir que c'est un caractère, tu travailles juste sur des valeurs de vérité... où alors j'ai pas compris ta remarque...

ben ce qu'on appelle communément un « booléen » en informatique c'est une valeur de vérité, et il n'y en a que deux, vrai et faux... après il se trouve que le C n'a pas de type booléen et que les valeurs de vérité sont représentées par des entiers, avec 0 qui représente faux et tout autre nombre qui représente vrai, mais peu importe. Je disais qu'on peut croire qu'une « opération booléenne » est une « opération sur les booléens » (au sens « opération sur les valeurs de vérité », donc en C une opération sur des entiers dont le résultat nul ou non ne dépend que de la nullité de ses arguments), donc comme le disait Pollux une opération logique.
Ça n'a aucun rapport avec les opérations booléennes bit-à-bit (par exemple 1 & 1 = 1, mais 1 & 2 = 0, et pourtant "1" et "2" représentent la même valeur de vérité...)

Après si tu veux dire que tu considères ton octet comme un octuplet de booléens et non comme un nombre ou comme un caractère, oui tu fais bien des opérations sur les valeurs de vérité, mais comme je le disais dans mon post précédent, tu fais 8 opérations simultanées sur 8 valeurs de vérité différentes, c'est pas une opération simple. (Et accessoirement la représentation standard d'une valeur de vérité en C c'est pas un bit dans un octet ^^. Et toujours accessoirement, ce que tu considères c'est pas « un caractère représenté par 01001101 » a priori, mais « la séquence de bits 01001101 indépendamment du fait qu'elle puisse représenter un caractère », sauf si j'ai mal compris ton post ?)

Sally (./154) :
Et toujours accessoirement, ce que tu considères c'est pas « un caractère représenté par 01001101 » a priori, mais « la séquence de bits 01001101 indépendamment du fait qu'elle puisse représenter un caractère », sauf si j'ai mal compris ton post ?)

Oui, t'as tout à fait raison, j'ai failli éditer pour rectifier.
Pour le reste, c'est une vue de l'esprit

La vache, j'ai le droit à un véritable cours de manipulation de bits!

Va falloir que je réussisse à comprendre ça (pas trop le temps avec la reprise des cours), même si ma façon actuelle de fonctionner me parait plus simple (mais, peut-être je l'admet, ni conventionnelle ni "belle" en terme de programmation).

Ce n'est pas qu'elle est non conventionnelle, elle est simplement plus lourde.

A la limite un bricolage de ce goût doit permettre une manipulation simple, qui sans être au sommet de l'efficacité (surtout le test en fait), a l'avantage d'être clair même sans utiliser d'opérateurs.

static inline void setbit(long & val, int bit) {
    __asm__ (
        "bset %2,%0"
        : "=d" (val)
        : "0" (val), "i,d" (bit)
        : "cc"
    );
}
static inline void clearbit(long & val, int bit) {
    __asm__ (
        "bclr %2,%0"
        : "=d" (val)
        : "0" (val), "i,d" (bit)
        : "cc"
    );
}
static inline char testbit(long val, int bit) {
    char result;
    __asm__ (
        "btst %2,%1\n"
        "sne %0"
        : "=d" (result)
        : "d,m" (val), "i,d" (bit)
        : "cc"
    );
    return result;
}

Je me demande d'ailleurs si tigcc sait optimiser tout seul quelque chose comme x | (1 << fonction()). Si la réponse est non, les fonctions ci-dessus peuvent même avoir une réelle utilité.

(note : j'ai écrit ça parce que je m'emmerdais quelques minutes au boulot - c'est pas testé rien)

(il doit y avoir des macros déjà incluses dans tigcclib pour ça )

Fort possible. Je ne me suis jamais posé la question, vu que j'en avais déjà un équivalent d'un projet antérieur à ma première utilisation de tigcc

http://tigcc.ticalc.org/doc/peekpoke.html
(Ce sont tous des macros, mais la documentation n'indique la définition de la macro que si elle est simple, pour les macros complexes et/ou illisibles avec par exemple de l'assembleur inline, la documentation montre un prototype comme pour une fonction, mais c'est quand-même une macro en réalité.)