Funzioni di ordinamento
qf_ferm_op_canonical_order
QfFermionOperator *qf_ferm_op_canonical_order(const QfFermionOperator *op)
Restituisce una copia di un operatore fermionico con i suoi termini disposti in ordine canonico.
I termini sono ordinati secondo un ordine canonico che dipende esclusivamente dalla struttura di ciascun termine (la stringa di operatori che esso rappresenta) e non dal suo coefficiente. L'ordine è quindi deterministico per un dato insieme di termini, indipendentemente da come sia stato assemblato l'operatore. I termini stessi rimangono invariati: questa operazione si limita a riorganizzarli, senza semplificare né riportare l'operatore all'ordine normale.
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);Eventuali indici di gruppo (vedi qf_ferm_op_get_groups()) vengono conservati: ogni termine porta con sé il proprio indice di gruppo quando viene spostato, poiché un indice di gruppo è un’etichetta specifica per ogni termine, indipendente dall’ordine dei termini. Da quel momento in poi, i termini dello stesso gruppo semplicemente non sono più contigui. Se l'input non contiene gruppi, nemmeno il risultato ne contiene.
Parametri
- op – Un puntatore all’operatore i cui termini devono essere riordinati.
Risultati
Un puntatore all'operatore creato.
qf_maj_op_canonical_order
QfMajoranaOperator *qf_maj_op_canonical_order(const QfMajoranaOperator *op)
Restituisce una copia di un operatore di Majorana con i suoi termini disposti in ordine canonico.
I termini sono ordinati secondo un ordine canonico che dipende esclusivamente dalla struttura di ciascun termine (la stringa di operatori che esso rappresenta) e non dal suo coefficiente. L'ordine è quindi deterministico per un dato insieme di termini, indipendentemente da come sia stato assemblato l'operatore. I termini stessi rimangono invariati: questa operazione si limita a riorganizzarli, senza semplificare né riportare l'operatore all'ordine normale.
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);Eventuali indici di gruppo (vedi qf_maj_op_get_groups()) vengono conservati: ogni termine porta con sé il proprio indice di gruppo quando viene spostato, poiché un indice di gruppo è un’etichetta specifica per ogni termine, indipendente dall’ordine dei termini. Da quel momento in poi, i termini dello stesso gruppo semplicemente non sono più contigui. Se l'input non contiene gruppi, nemmeno il risultato ne contiene.
Parametri
- op – Un puntatore all’operatore i cui termini devono essere riordinati.
Risultati
Un puntatore all'operatore creato.
qf_edge_op_canonical_order
QfEdgeVertexOperator *qf_edge_op_canonical_order(const QfEdgeVertexOperator *op)
Restituisce una copia di un operatore bordo-vertice con i suoi termini in ordine canonico.
I termini sono ordinati secondo un ordine canonico che dipende esclusivamente dalla struttura di ciascun termine (la stringa di operatori che esso rappresenta) e non dal suo coefficiente. L'ordine è quindi deterministico per un dato insieme di termini, indipendentemente da come sia stato assemblato l'operatore. I termini stessi rimangono invariati: questa operazione si limita a riorganizzarli, senza semplificare né riportare l'operatore all'ordine normale.
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);Eventuali indici di gruppo (vedi qf_edge_op_get_groups()) vengono preservati: ogni termine porta con sé il proprio indice di gruppo quando viene spostato, poiché l’indice di gruppo è un’etichetta associata a ciascun termine, indipendente dall’ordine dei termini. Da quel momento in poi, i termini dello stesso gruppo non sono più contigui. Se l'input non contiene gruppi, nemmeno il risultato ne contiene.
Parametri
- op – Un puntatore all’operatore i cui termini devono essere riordinati.
Risultati
Un puntatore all'operatore creato.
qf_transfer_op_canonical_order
QfTransferVertexOperator *qf_transfer_op_canonical_order(const QfTransferVertexOperator *op)
Restituisce una copia di un operatore di trasferimento di vertici con i suoi termini disposti in ordine canonico.
I termini sono ordinati secondo un ordine canonico che dipende esclusivamente dalla struttura di ciascun termine (la stringa di operatori che esso rappresenta) e non dal suo coefficiente. L'ordine è quindi deterministico per un dato insieme di termini, indipendentemente da come sia stato assemblato l'operatore. I termini stessi rimangono invariati: questa operazione si limita a riorganizzarli, senza semplificare né riportare l'operatore all'ordine normale.
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);Eventuali indici di gruppo (vedi qf_transfer_op_get_groups()) vengono preservati: ogni termine porta con sé il proprio indice di gruppo quando viene spostato, poiché l’indice di gruppo è un’etichetta associata a ciascun termine, indipendente dall’ordine dei termini. Da quel momento in poi, i termini dello stesso gruppo non sono più contigui. Se l'input non contiene gruppi, nemmeno il risultato ne contiene.
Parametri
- op – Un puntatore all’operatore i cui termini devono essere riordinati.
Risultati
Un puntatore all'operatore creato.
qf_ferm_op_group_order
QfFermionOperator *qf_ferm_op_group_order(const QfFermionOperator *op)
Restituisce una copia di un operatore fermionico con i suoi termini ordinati in base all'indice di gruppo.
I termini sono ordinati esclusivamente in base al loro indice di gruppo, il che fa sì che ogni gruppo costituisca una sequenza contigua di termini e che gli indici di gruppo siano non decrescenti. L'ordinamento è stabile, quindi i termini all'interno di un gruppo mantengono il loro ordine relativo. I termini stessi rimangono invariati: questa operazione si limita a riorganizzarli, senza semplificare né riportare l'operatore all'ordine normale.
Gli indici di gruppo indicano solo quali termini vanno raggruppati, quindi ciò modifica la disposizione dell’operatore, non il suo valore. Ciò che il layout comporta è il costo della ricerca: in genere qf_ferm_op_split_out_groups() deve scansionare ogni termine per trovare i gruppi richiesti, ma su un operatore ordinato per gruppi i termini di ciascun gruppo formano un intervallo che può essere individuato tramite ricerca binaria, quindi una ricerca costa quanto i gruppi richiesti anziché quanto i termini contenuti.
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);Un operatore che non tiene traccia di indici di gruppo (vedi qf_ferm_op_get_groups()) non ha alcun criterio di ordinamento e viene restituito come copia inalterata. Il risultato non rileva nemmeno alcun gruppo.
Parametri
- op – Un puntatore all’operatore i cui termini devono essere riordinati.
Risultati
Un puntatore all'operatore creato.
qf_maj_op_group_order
QfMajoranaOperator *qf_maj_op_group_order(const QfMajoranaOperator *op)
Restituisce una copia di un operatore di Majorana con i suoi termini ordinati in base all'indice di gruppo.
I termini sono ordinati esclusivamente in base al loro indice di gruppo, il che fa sì che ogni gruppo costituisca una sequenza contigua di termini e che gli indici di gruppo siano non decrescenti. L'ordinamento è stabile, quindi i termini all'interno di un gruppo mantengono il loro ordine relativo. I termini stessi rimangono invariati: questa operazione si limita a riorganizzarli, senza semplificare né riportare l'operatore all'ordine normale.
Gli indici di gruppo indicano solo quali termini vanno raggruppati, quindi ciò modifica la disposizione dell’operatore, non il suo valore. Ciò che il layout comporta è il costo della ricerca: in genere qf_maj_op_split_out_groups() deve scansionare ogni termine per trovare i gruppi richiesti, ma su un operatore ordinato per gruppi i termini di ciascun gruppo formano un intervallo che può essere individuato tramite ricerca binaria, quindi una ricerca costa quanto i gruppi richiesti anziché quanto i termini contenuti.
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);Un operatore che non tiene traccia di indici di gruppo (vedi qf_maj_op_get_groups()) non ha alcun criterio di ordinamento e viene restituito come copia inalterata. Il risultato non rileva nemmeno alcun gruppo.
Parametri
- op – Un puntatore all’operatore i cui termini devono essere riordinati.
Risultati
Un puntatore all'operatore creato.
qf_edge_op_group_order
QfEdgeVertexOperator *qf_edge_op_group_order(const QfEdgeVertexOperator *op)
Restituisce una copia di un operatore bordo-vertice con i suoi termini ordinati in base all'indice di gruppo.
I termini sono ordinati esclusivamente in base al loro indice di gruppo, il che fa sì che ogni gruppo costituisca una sequenza contigua di termini e che gli indici di gruppo siano non decrescenti. L'ordinamento è stabile, quindi i termini all'interno di un gruppo mantengono il loro ordine relativo. I termini stessi rimangono invariati: questa operazione si limita a riorganizzarli, senza semplificare né riportare l'operatore all'ordine normale.
Gli indici di gruppo indicano solo quali termini vanno raggruppati, quindi ciò modifica la disposizione dell’operatore, non il suo valore. Ciò che il layout comporta è il costo della ricerca: in genere qf_edge_op_split_out_groups() deve scansionare ogni termine per trovare i gruppi richiesti, ma su un operatore ordinato per gruppi i termini di ciascun gruppo formano un intervallo che può essere individuato tramite ricerca binaria, quindi una ricerca costa quanto i gruppi richiesti anziché quanto i termini contenuti.
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);Un operatore che non tiene traccia di indici di gruppo (vedi qf_edge_op_get_groups()) non ha alcun criterio di ordinamento e viene restituito come copia inalterata. Il risultato non rileva nemmeno alcun gruppo.
Parametri
- op – Un puntatore all’operatore i cui termini devono essere riordinati.
Risultati
Un puntatore all'operatore creato.
qf_transfer_op_group_order
QfTransferVertexOperator *qf_transfer_op_group_order(const QfTransferVertexOperator *op)
Restituisce una copia di un operatore di trasferimento di vertici con i suoi termini ordinati in base all'indice di gruppo.
I termini sono ordinati esclusivamente in base al loro indice di gruppo, il che fa sì che ogni gruppo costituisca una sequenza contigua di termini e che gli indici di gruppo siano non decrescenti. L'ordinamento è stabile, quindi i termini all'interno di un gruppo mantengono il loro ordine relativo. I termini stessi rimangono invariati: questa operazione si limita a riorganizzarli, senza semplificare né riportare l'operatore all'ordine normale.
Gli indici di gruppo indicano solo quali termini vanno raggruppati, quindi ciò modifica la disposizione dell’operatore, non il suo valore. Ciò che il layout comporta è il costo della ricerca: in genere qf_transfer_op_split_out_groups() deve scansionare ogni termine per trovare i gruppi richiesti, ma su un operatore ordinato per gruppi i termini di ciascun gruppo formano un intervallo che può essere individuato tramite ricerca binaria, quindi una ricerca costa quanto i gruppi richiesti anziché quanto i termini contenuti.
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);Un operatore che non tiene traccia di indici di gruppo (vedi qf_transfer_op_get_groups()) non ha alcun criterio di ordinamento e viene restituito come copia inalterata. Il risultato non rileva nemmeno alcun gruppo.
Parametri
- op – Un puntatore all’operatore i cui termini devono essere riordinati.
Risultati
Un puntatore all'operatore creato.