Complexité

De Bitcoin Wiki
Ceci est la révision approuvée de la page, et aussi la plus récente.
Aller à : navigation, rechercher

Complexité Complexité est une unité de mesure qui montre comment il est difficile de trouver un hach qui sera en dessous de l'objectif proposé par le système(cible).

Les principes du fonctionnement[modifier]

Il y a une complexité globale pour touts les blocs dans le réseau de Bitcoin. Pour être correct, le bloc doit avoir le hach en dessous de l'objectif déclaré (cible). Complexité dans le réseau de Bitcoin change chaque 2016 blocs. Elle est calculée par la formule suivante:

difficulty = difficulty_1_target / current_target

ou difficulty est une complexité et cible est un chiffre de 256 bites. Difficulty_1_target peut accepter les valeurs diverses. Traditionnellement, c'est un hach, les 32 premiers bits duquel sont 0, le reste étant 1 (ceci est aussi appelé pdiff ou pool difficulty). Le protocole Bitcoin est la cible comme un type avec un point flottant et précision limitée. Très souvent les Bitcoin-clients déterminent la complexité sur la base de ces données.

Stockage de la complexité dans les blocs[modifier]

Chaque bloc sauvegarde au-dedans une version emballée (appelé "Bits") d'une cible hexadécimale. En utilisant une formule suivante on peut obtenir une cible du chaque bloc. Par exemple, si la cible emballée dans le bloc est 0x1b0404cb, sa version hexadécimale sera la suivante:

 0x0404cb * 2**(8*(0x1b - 3)) = 0x00000000000404CB000000000000000000000000000000000000000000000000

La valeur maximale pour cette zone est 0x7fffff, minimale - 0x008000. Cible maximale possible (lors de la complexité 1) est défini comme 0x1d00ffff, sous forme hexadécimale de:

0x00ffff * 2**(8*(0x1d - 3)) = 0x00000000FFFF0000000000000000000000000000000000000000000000000000

Il y a un moyen rapide au-dessous pour calculer la complexité du réseau de Bitcoin. Pour les logarithmes on utilise une version modifiée de la série de Taylor et est basé sur les bûches pour transformer le calcul de la complexité.

#include <iostream>
#include <cmath>

inline float fast_log(float val)
{
   int * const exp_ptr = reinterpret_cast <int *>(&val);
   int x = *exp_ptr;
   const int log_2 = ((x >> 23) & 255) - 128;
   x &= ~(255 << 23);
   x += 127 << 23;
   *exp_ptr = x;

   val = ((-1.0f/3) * val + 2) * val - 2.0f/3;
   return ((val + log_2) * 0.69314718f);
}

float difficulty(unsigned int bits)
{
    static double max_body = fast_log(0x00ffff), scaland = fast_log(256);
    return exp(max_body - fast_log(bits & 0x00ffffff) + scaland * (0x1d - ((bits & 0xff000000) >> 24)));
}

int main()
{
    std::cout << difficulty(0x1b0404cb) << std::endl;
    return 0;
}

Les complexités maximale, courante et minimale[modifier]

On peut distinguer une complexité courante en utilisant une Bitcoin-commande getDifficulty.

Parce qu'il n'y a pas de cible minimale, on peut approximativement calculer la cible maximale de la complexité comme suit: maximum_target / 1 (parce que 0 va réduire l'équation à l'infini) et c'est une chiffre inimaginable (~ 2 dans l’ordre de 224).

La complexité minimale est égale au 1.

Changement de la complexité[modifier]

La complexité est changée chaque 2016 blocs. Elle est basée sur le temps nécessaire pour la détermination des 2016 blocs précédents. Si on trouve le bloc chaque 10 minutes (comme il a été prévu à l'origine pour une émission régulière), il faudra 2 semaines pour trouver 2016 blocs. Si on a trouvé 2016 blocs lors d'un période plus de 2 semaines, la complexité sera moins grande, si moins de 2 semaines - la complexité sera plus grande. Plus (moins) du temps on a perdu pour la détermination des 2016 blocs précédents, moins grande (ou plus grande) sera la complexité. Il faut que hach soit moins grand à proportion de la cible (le mode du travail de proof-of-work). Le hach est un nombre aléatoire de 0 jusqu'à 2*256-1. La complexité est déclarée de manière si nous avons trouvé les 2016 blocs précédents avec une fréquence d'une fois par 10 minutes. La moyenne du temps pour la determination seulement du bloc est calculée comme suit: time = difficulty * 2**32 / hashrate ou difficulty est une complexité courante du réseau de Bitcoin, hashrate est un nombre des hashs trouvés par votre expert de mining par seconde et time est une moyenne du temps (en secondes) entre votre determination du bloc.