Fonctions d'ordre

QfFermionOperator *qf_ferm_op_canonical_order(const QfFermionOperator *op)

Renvoie une copie d'un opérateur fermionique dont les termes sont classés dans l'ordre canonique.

Les termes sont classés selon un ordre canonique qui dépend uniquement de la structure de chaque terme (la chaîne d'opérateurs qu'il représente) et non de son coefficient. L'ordre est donc déterministe pour un ensemble donné de termes, quelle que soit la manière dont l'opérateur a été construit. Les termes eux-mêmes restent inchangés : cela ne fait que les réorganiser, sans simplifier ni mettre l'opérateur en ordre normal.

 1QfFermionOperator *op = qf_ferm_op_zero();
 2bool actions[2] = {true, false};
 3uint32_t modes_a[2] = {1, 0};
 4QkComplex64 coeff_a = {1.0, 0.0};
 5qf_ferm_op_add_term(op, 2, actions, modes_a, &coeff_a);
 6uint32_t modes_b[2] = {0, 1};
 7QkComplex64 coeff_b = {2.0, 0.0};
 8qf_ferm_op_add_term(op, 2, actions, modes_b, &coeff_b);
 9
10QfFermionOperator *ordered = qf_ferm_op_canonical_order(op);

Paramètres

• op – Un pointeur vers l'opérateur dont les termes doivent être réorganisés.

Retours

Un pointeur vers l'opérateur créé.

QfMajoranaOperator *qf_maj_op_canonical_order(const QfMajoranaOperator *op)

Renvoie une copie d'un opérateur de Majorana dont les termes sont classés selon l'ordre canonique.

Les termes sont classés selon un ordre canonique qui dépend uniquement de la structure de chaque terme (la chaîne d'opérateurs qu'il représente) et non de son coefficient. L'ordre est donc déterministe pour un ensemble donné de termes, quelle que soit la manière dont l'opérateur a été construit. Les termes eux-mêmes restent inchangés : cela ne fait que les réorganiser, sans simplifier ni mettre l'opérateur en ordre normal.

1QfMajoranaOperator *op = qf_maj_op_zero();
2uint32_t modes_a[2] = {1, 0};
3QkComplex64 coeff_a = {1.0, 0.0};
4qf_maj_op_add_term(op, 2, modes_a, &coeff_a);
5uint32_t modes_b[2] = {0, 1};
6QkComplex64 coeff_b = {2.0, 0.0};
7qf_maj_op_add_term(op, 2, modes_b, &coeff_b);
8
9QfMajoranaOperator *ordered = qf_maj_op_canonical_order(op);

Paramètres

• op – Un pointeur vers l'opérateur dont les termes doivent être réorganisés.

Retours

Un pointeur vers l'opérateur créé.

QfEdgeVertexOperator *qf_edge_op_canonical_order(const QfEdgeVertexOperator *op)

Renvoie une copie d'un opérateur « arête-sommet » dont les termes sont classés selon un ordre canonique.

Les termes sont classés selon un ordre canonique qui dépend uniquement de la structure de chaque terme (la chaîne d'opérateurs qu'il représente) et non de son coefficient. L'ordre est donc déterministe pour un ensemble donné de termes, quelle que soit la manière dont l'opérateur a été construit. Les termes eux-mêmes restent inchangés : cela ne fait que les réorganiser, sans simplifier ni mettre l'opérateur en ordre normal.

 1QfEdgeVertexOperator *op = qf_edge_op_zero();
 2uint32_t left_a[1] = {1};
 3uint32_t right_a[1] = {2};
 4QkComplex64 coeff_a = {1.0, 0.0};
 5qf_edge_op_add_term(op, 1, left_a, right_a, &coeff_a);
 6uint32_t left_b[1] = {0};
 7uint32_t right_b[1] = {1};
 8QkComplex64 coeff_b = {2.0, 0.0};
 9qf_edge_op_add_term(op, 1, left_b, right_b, &coeff_b);
10
11QfEdgeVertexOperator *ordered = qf_edge_op_canonical_order(op);

Paramètres

• op – Un pointeur vers l'opérateur dont les termes doivent être réorganisés.

Retours

Un pointeur vers l'opérateur créé.

QfTransferVertexOperator *qf_transfer_op_canonical_order(const QfTransferVertexOperator *op)

Renvoie une copie d'un opérateur de transfert de sommets dont les termes sont classés selon un ordre canonique.

Les termes sont classés selon un ordre canonique qui dépend uniquement de la structure de chaque terme (la chaîne d'opérateurs qu'il représente) et non de son coefficient. L'ordre est donc déterministe pour un ensemble donné de termes, quelle que soit la manière dont l'opérateur a été construit. Les termes eux-mêmes restent inchangés : cela ne fait que les réorganiser, sans simplifier ni mettre l'opérateur en ordre normal.

 1QfTransferVertexOperator *op = qf_transfer_op_zero();
 2uint32_t left_a[1] = {1};
 3uint32_t right_a[1] = {2};
 4QkComplex64 coeff_a = {1.0, 0.0};
 5qf_transfer_op_add_term(op, 1, left_a, right_a, &coeff_a);
 6uint32_t left_b[1] = {0};
 7uint32_t right_b[1] = {1};
 8QkComplex64 coeff_b = {2.0, 0.0};
 9qf_transfer_op_add_term(op, 1, left_b, right_b, &coeff_b);
10
11QfTransferVertexOperator *ordered = qf_transfer_op_canonical_order(op);

Paramètres

• op – Un pointeur vers l'opérateur dont les termes doivent être réorganisés.

Retours

Un pointeur vers l'opérateur créé.

QfFermionOperator *qf_ferm_op_group_order(const QfFermionOperator *op)

Renvoie une copie d'un opérateur fermionique dont les termes sont classés par indice de groupe.

Les termes sont triés uniquement en fonction de leur indice de groupe, ce qui fait que chaque groupe forme une suite contiguë de termes et que les indices de groupe sont non décroissants. Le tri est stable, ce qui signifie que les éléments d'un même groupe conservent leur ordre relatif. Les termes eux-mêmes restent inchangés : cette opération se contente de les réorganiser, sans simplifier ni mettre l'opérateur en ordre normal.

Les indices de groupe indiquent uniquement quels termes vont ensemble; cela modifie donc la disposition de l'opérateur, mais pas sa valeur. Ce que cette structure permet de gagner, c'est le coût de la recherche : en général, qf_ferm_op_split_out_groups() il faut parcourir tous les termes pour trouver les groupes demandés, mais avec un opérateur ordonné par groupes, les termes de chaque groupe forment une plage que l'on peut localiser par recherche binaire; ainsi, une recherche coûte autant que les groupes demandés plutôt que les termes contenus.

 1QfFermionOperator *op = qf_ferm_op_zero();
 2bool actions[2] = {true, false};
 3uint32_t modes_a[2] = {0, 1};
 4QkComplex64 coeff_a = {1.0, 0.0};
 5qf_ferm_op_add_term(op, 2, actions, modes_a, &coeff_a);
 6uint32_t modes_b[2] = {1, 0};
 7QkComplex64 coeff_b = {2.0, 0.0};
 8qf_ferm_op_add_term(op, 2, actions, modes_b, &coeff_b);
 9uint32_t groups[2] = {1, 0};
10qf_ferm_op_set_groups(op, groups, 2);
11
12QfFermionOperator *ordered = qf_ferm_op_group_order(op);

Paramètres

• op – Un pointeur vers l'opérateur dont les termes doivent être réorganisés.

Retours

Un pointeur vers l'opérateur créé.

QfMajoranaOperator *qf_maj_op_group_order(const QfMajoranaOperator *op)

Renvoie une copie d'un opérateur de Majorana dont les termes sont classés par indice de groupe.

Les termes sont triés uniquement en fonction de leur indice de groupe, ce qui fait que chaque groupe forme une suite contiguë de termes et que les indices de groupe sont non décroissants. Le tri est stable, ce qui signifie que les éléments d'un même groupe conservent leur ordre relatif. Les termes eux-mêmes restent inchangés : cette opération se contente de les réorganiser, sans simplifier ni mettre l'opérateur en ordre normal.

Les indices de groupe indiquent uniquement quels termes vont ensemble; cela modifie donc la disposition de l'opérateur, mais pas sa valeur. Ce que cette structure permet de gagner, c'est le coût de la recherche : en général, qf_maj_op_split_out_groups() il faut parcourir tous les termes pour trouver les groupes demandés, mais avec un opérateur ordonné par groupes, les termes de chaque groupe forment une plage que l'on peut localiser par recherche binaire; ainsi, une recherche coûte autant que les groupes demandés plutôt que les termes contenus.

 1QfMajoranaOperator *op = qf_maj_op_zero();
 2uint32_t modes_a[2] = {0, 1};
 3QkComplex64 coeff_a = {1.0, 0.0};
 4qf_maj_op_add_term(op, 2, modes_a, &coeff_a);
 5uint32_t modes_b[2] = {2, 3};
 6QkComplex64 coeff_b = {2.0, 0.0};
 7qf_maj_op_add_term(op, 2, modes_b, &coeff_b);
 8uint32_t groups[2] = {1, 0};
 9qf_maj_op_set_groups(op, groups, 2);
10
11QfMajoranaOperator *ordered = qf_maj_op_group_order(op);

Paramètres

• op – Un pointeur vers l'opérateur dont les termes doivent être réorganisés.

Retours

Un pointeur vers l'opérateur créé.

QfEdgeVertexOperator *qf_edge_op_group_order(const QfEdgeVertexOperator *op)

Renvoie une copie d'un opérateur « arête-sommet » dont les termes sont classés par indice de groupe.

Les termes sont triés uniquement en fonction de leur indice de groupe, ce qui fait que chaque groupe forme une suite contiguë de termes et que les indices de groupe sont non décroissants. Le tri est stable, ce qui signifie que les éléments d'un même groupe conservent leur ordre relatif. Les termes eux-mêmes restent inchangés : cette opération se contente de les réorganiser, sans simplifier ni mettre l'opérateur en ordre normal.

Les indices de groupe indiquent uniquement quels termes vont ensemble; cela modifie donc la disposition de l'opérateur, mais pas sa valeur. Ce que cette structure permet de gagner, c'est le coût de la recherche : en général, qf_edge_op_split_out_groups() il faut parcourir tous les termes pour trouver les groupes demandés, mais avec un opérateur ordonné par groupes, les termes de chaque groupe forment une plage que l'on peut localiser par recherche binaire; ainsi, une recherche coûte autant que les groupes demandés plutôt que les termes contenus.

 1QfEdgeVertexOperator *op = qf_edge_op_zero();
 2uint32_t left_a[1] = {0};
 3uint32_t right_a[1] = {1};
 4QkComplex64 coeff_a = {1.0, 0.0};
 5qf_edge_op_add_term(op, 1, left_a, right_a, &coeff_a);
 6uint32_t left_b[1] = {1};
 7uint32_t right_b[1] = {2};
 8QkComplex64 coeff_b = {2.0, 0.0};
 9qf_edge_op_add_term(op, 1, left_b, right_b, &coeff_b);
10uint32_t groups[2] = {1, 0};
11qf_edge_op_set_groups(op, groups, 2);
12
13QfEdgeVertexOperator *ordered = qf_edge_op_group_order(op);

Paramètres

• op – Un pointeur vers l'opérateur dont les termes doivent être réorganisés.

Retours

Un pointeur vers l'opérateur créé.

QfTransferVertexOperator *qf_transfer_op_group_order(const QfTransferVertexOperator *op)

Renvoie une copie d'un opérateur de transfert de sommets dont les termes sont classés par indice de groupe.

Les termes sont triés uniquement en fonction de leur indice de groupe, ce qui fait que chaque groupe forme une suite contiguë de termes et que les indices de groupe sont non décroissants. Le tri est stable, ce qui signifie que les éléments d'un même groupe conservent leur ordre relatif. Les termes eux-mêmes restent inchangés : cette opération se contente de les réorganiser, sans simplifier ni mettre l'opérateur en ordre normal.

Les indices de groupe indiquent uniquement quels termes vont ensemble; cela modifie donc la disposition de l'opérateur, mais pas sa valeur. Ce que cette structure permet de gagner, c'est le coût de la recherche : en général, qf_transfer_op_split_out_groups() il faut parcourir tous les termes pour trouver les groupes demandés, mais avec un opérateur ordonné par groupes, les termes de chaque groupe forment une plage que l'on peut localiser par recherche binaire; ainsi, une recherche coûte autant que les groupes demandés plutôt que les termes contenus.

 1QfTransferVertexOperator *op = qf_transfer_op_zero();
 2uint32_t left_a[1] = {0};
 3uint32_t right_a[1] = {1};
 4QkComplex64 coeff_a = {1.0, 0.0};
 5qf_transfer_op_add_term(op, 1, left_a, right_a, &coeff_a);
 6uint32_t left_b[1] = {1};
 7uint32_t right_b[1] = {2};
 8QkComplex64 coeff_b = {2.0, 0.0};
 9qf_transfer_op_add_term(op, 1, left_b, right_b, &coeff_b);
10uint32_t groups[2] = {1, 0};
11qf_transfer_op_set_groups(op, groups, 2);
12
13QfTransferVertexOperator *ordered = qf_transfer_op_group_order(op);

Paramètres

• op – Un pointeur vers l'opérateur dont les termes doivent être réorganisés.

Retours

Un pointeur vers l'opérateur créé.