QfMajoranaOperator

QfMajoranaOperator *qf_maj_op_new(uint64_t num_terms, uint64_t num_modes, const QkComplex64 *coeffs, const uint32_t *modes, const uint32_t *boundaries)

Crea un nuovo operatore.

Qualsiasi argomento di tipo puntatore può essere NULL se e solo se la sua lunghezza corrispondente è pari a zero.

Esempio

1uint64_t num_terms = 3;
2uint64_t num_modes = 4;
3uint32_t modes[4] = {0, 1, 2, 3};
4QkComplex64 coeffs[3] = {{1.0, 0.0}, {-1.0, 0.0}, {0.0, -1.0}};
5uint32_t boundaries[4] = {0, 0, 2, 4};
6QfMajoranaOperator *op = qf_maj_op_new(num_terms, num_modes, coeffs,
7                                       modes, boundaries);

Parametri

• num_terms – Il numero di termini presenti nell'operatore.
• num_modes – Il numero di modi sommati su tutti i termini.
• coeffs – Un puntatore a un array di coefficienti dei termini. La lunghezza di questo array dovrebbe essere num_terms.
• modalità – Un puntatore a un array di modalità relative a tutti i termini. La lunghezza di questo array dovrebbe essere num_modes.
• confini – Un puntatore a un array contenente i confini tra i termini. La lunghezza di questo array dovrebbe essere num_terms + 1.

void qf_maj_op_free(QfMajoranaOperator *op)

Rilascia un operatore esistente.

Esempio

1QfMajoranaOperator *op = qf_maj_op_one();
2qf_maj_op_free(op);

Parametri

• op – Un puntatore all’operatore di Majorana da liberare.

void qf_maj_op_get_coeffs(const QfMajoranaOperator *op, QkComplex64 **coeffs_out, uint64_t *coeffs_len)

Fornisce accesso in sola lettura ai coefficienti dell'operatore.

Esempio

 1uint64_t num_terms = 2;
 2uint64_t num_modes = 0;
 3QkComplex64 coeffs[2] = {{1.0, 0.0}, {0.0, -1.0}};
 4uint32_t boundaries[3] = {0, 0, 0};
 5QfMajoranaOperator *op =
 6    qf_maj_op_new(num_terms, num_modes, coeffs, NULL, boundaries);
 7
 8QkComplex64 *coeffs_out;
 9uint64_t *coeffs_len;
10
11qf_maj_op_get_coeffs(op, &coeffs_out, &coeffs_len);
12
13assert(coeffs_len == 2);

Parametri

• op – Un puntatore all’operatore di Majorana di cui si desidera accedere ai coefficienti.
• coeffs_out – Un puntatore all'array di valori complessi in cui scrivere i coefficienti.
• coeffs_len – Un puntatore all’intero in cui scrivere la lunghezza dell’array di output.

void qf_maj_op_get_modes(const QfMajoranaOperator *op, uint32_t **modes_out, uint64_t *modes_len)

Fornisce accesso in sola lettura agli indici delle modalità su cui l'operatore ha agito.

Esempio

 1uint64_t num_terms = 2;
 2bool actions[2] = {true, false};
 3uint32_t modes[2] = {0, 1};
 4QkComplex64 coeffs[2] = {{1.0, 0.0}, {0.0, -1.0}};
 5uint32_t boundaries[3] = {0, 0, 2};
 6QfMajoranaOperator *op =
 7    qf_maj_op_new(num_terms, num_actions, coeffs, modes, boundaries);
 8
 9QkComplex64 *modes_out;
10uint64_t *modes_len;
11
12qf_maj_op_get_modes(op, &modes_out, &modes_len);
13
14assert(modes_len == 2);

Parametri

• op – Un puntatore all’operatore di Majorana di cui si desidera accedere alle modalità.
• modes_out – Un puntatore all'array di valori booleani in cui scrivere le modalità.
• modes_len – Un puntatore all'intero in cui scrivere la lunghezza dell'array di output.

void qf_maj_op_get_boundaries(const QfMajoranaOperator *op, size_t **boundaries_out, uint64_t *boundaries_len)

Fornisce un accesso in sola lettura agli indici che indicano i confini tra i termini dell'operatore.

Esempio

 1uint64_t num_terms = 2;
 2uint64_t num_modes = 2;
 3uint32_t modes[2] = {0, 1};
 4QkComplex64 coeffs[2] = {{1.0, 0.0}, {0.0, -1.0}};
 5uint32_t boundaries[3] = {0, 0, 2};
 6QfMajoranaOperator *op =
 7    qf_maj_op_new(num_terms, num_modes, coeffs, modes, boundaries);
 8
 9QkComplex64 *boundaries_out;
10uint64_t *boundaries_len;
11
12qf_maj_op_get_boundaries(op, &boundaries_out, &boundaries_len);
13
14assert(boundaries_len == 3);

Parametri

• op – Un puntatore all’operatore di Majorana a cui si desidera accedere.
• boundaries_out – Un puntatore all'array di valori booleani in cui scrivere i limiti.
• boundaries_len – Un puntatore all'intero in cui scrivere la lunghezza dell'array di output.

QfMajoranaOperator *qf_maj_op_zero(void)

Costruisce l'operatore di identità additiva.

L'aggiunta di un operatore costruito con questo metodo a un altro operatore non ha alcun effetto.

Esempio

1QfMajoranaOperator *zero = qf_maj_op_zero();
2
3QfMajoranaOperator *op_plus_zero = qf_maj_op_add(op, zero);
4
5assert(qf_maj_op_equal(op, op_plus_zero));

Risultati

Un puntatore all'operatore creato.

QfMajoranaOperator *qf_maj_op_one(void)

Crea l'operatore identità moltiplicativo.

La composizione dell’operatore ottenuto con questo metodo con un altro operatore non ha alcun effetto.

Esempio

1QfMajoranaOperator *one = qf_maj_op_one();
2
3QfMajoranaOperator *op_times_one = qf_maj_op_compose(op, one);
4
5assert(qf_maj_op_equal(op, op_times_one));

Risultati

Un puntatore all'operatore creato.

bool qf_maj_op_has_groups(const QfMajoranaOperator *op)

Verifica se questo operatore tiene traccia degli indici di gruppo.

Esempio

1QfMajoranaOperator *op = ...;
2
3bool has_groups = qf_maj_op_has_groups(op);

Parametri

• op – Un puntatore all’operatore di Majorana da verificare.

Risultati

Se l'operatore fornito possiede un attributo groups .

uint32_t qf_maj_op_num_groups(const QfMajoranaOperator *op)

Recupera il numero di gruppi associati a un operatore.

Esempio

1QfMajoranaOperator *op = ...;
2
3uint32_t num_groups = qf_maj_op_num_groups(op);

Parametri

• op – Un puntatore all’operatore di Majorana il cui numero di gruppi si desidera ottenere.

Risultati

Il numero di indici di gruppo derivante dall'attributo groups dell'operatore.

void qf_maj_op_group_weights(const QfMajoranaOperator *op, double *weights_out)

Calcola la media del modulo assoluto del coefficiente per ciascun gruppo.

La i-esima voce è la somma di abs(coeff) sui termini del gruppo i, divisa per il numero di termini di quel gruppo. Si tratta del peso di campionamento di una formula di prodotto randomizzata (ad esempio qDRIFT ) che estrae interi gruppi anziché singoli termini, e viene calcolato in un unico passaggio sull’operatore anziché riducendo e qf_maj_op_get_coeffs() ( qf_maj_op_get_groups() un valore per ciascun termine non raggruppato ) dal lato del chiamante.

Esempio

 1uint64_t num_terms = 4;
 2uint64_t num_modes = 8;
 3uint32_t modes[8] = {0, 1, 2, 3, 1, 0, 3, 2};
 4QkComplex64 coeffs[4] = {{1.0, 0.0}, {2.0, 0.0}, {-1.0, 0.0}, {-2.0, 0.0}};
 5uint32_t boundaries[5] = {0, 2, 4, 6, 8};
 6QfMajoranaOperator *op = qf_maj_op_new(num_terms, num_modes, coeffs, modes, boundaries);
 7
 8uint32_t groups_in[4] = {0, 1, 0, 1};
 9qf_maj_op_set_groups(op, groups_in, num_terms);
10
11double weights[2];
12qf_maj_op_group_weights(op, weights);
13
14assert(weights[0] == 1.0);
15assert(weights[1] == 2.0);

Parametri

• op – Un puntatore all’operatore di Majorana i cui pesi di gruppo devono essere calcolati.
• weights_out – Un puntatore all'array di valori di tipo double in cui scrivere i pesi. Deve essere dimensionato in base a :c:funcqf_maj_op_num_groups:.

void qf_maj_op_get_groups(const QfMajoranaOperator *op, uint32_t **groups_out, uint64_t *groups_len)

Recupera gli indici di gruppo per tutti i termini dell’operatore.

Esempio

1QfMajoranaOperator *op = ...;
2uint32_t *groups_out;
3uint32_t groups_len;
4
5qf_maj_op_get_groups(op, &groups_out, &groups_len);

Parametri

• op – Un puntatore all’operatore di Majorana di cui si desidera ottenere gli indici di gruppo.
• groups_out – Un puntatore all'array di interi in cui scrivere gli indici dei gruppi.
• groups_len – Un puntatore all’intero in cui scrivere la lunghezza dell’array di output.

void qf_maj_op_set_groups(QfMajoranaOperator *op, const uint32_t *groups_in, uint64_t groups_len)

Imposta l'attributo groups dell'operatore specificato.

Esempio

1QfMajoranaOperator *op = ...;
2
3uint32_t num_terms = 4;
4uint32_t groups_in[4] = {0, 1, 0, 1};
5qf_maj_op_set_groups(op, groups_in, num_terms);

Parametri

• op – Un puntatore all'operatore di Majorana di cui si desidera scrivere l'attributo groups .
• groups_in – Un puntatore all'array di interi groups in cui scrivere nell'operatore.
• groups_len – Il numero di elementi presenti nell'array groups_in .

void qf_maj_op_del_groups(QfMajoranaOperator *op)

Elimina l'attributo groups dall'operatore specificato.

Esempio

1QfMajoranaOperator *op = ...;
2
3qf_maj_op_del_groups(op);

Parametri

• op – Un puntatore all'operatore di Majorana di cui si desidera eliminare l'attributo groups .

void qf_maj_op_split_out_groups(const QfMajoranaOperator *op, const uint32_t *group_indices, uint64_t num_indices, QfMajoranaOperator **group_ops_out)

Suddividi questo operatore in un elenco di nuovi operatori in base al suo attributo groups .

Un indice duplicato in group_indices viene scritto una volta per ogni occorrenza in group_ops_out. Richiedere solo un numero limitato di gruppi su un totale molto più ampio è notevolmente più economico che richiederli tutti, poiché i termini appartenenti a un gruppo non richiesto vengono saltati anziché essere aggiunti in qualsiasi punto.

Esempio

 1uint64_t num_terms = 4;
 2uint64_t num_modes = 8;
 3uint32_t modes[8] = {0, 1, 2, 3, 1, 0, 3, 2};
 4QkComplex64 coeffs[4] = {{1.0, 0.0}, {1.0, 0.0}, {1.0, 0.0}, {1.0, 0.0}};
 5uint32_t boundaries[5] = {0, 2, 4, 6, 8};
 6QfMajoranaOperator *op = qf_maj_op_new(num_terms, num_modes, coeffs, modes, boundaries);
 7
 8uint32_t groups_in[4] = {0, 1, 0, 1};
 9qf_maj_op_set_groups(op, groups_in, num_terms);
10
11// build every group, in index order
12QfMajoranaOperator *group_ops[2];
13qf_maj_op_split_out_groups(op, NULL, 0, group_ops);
14
15// build only group 1
16uint32_t group_indices[1] = {1};
17QfMajoranaOperator *group_op[1];
18qf_maj_op_split_out_groups(op, group_indices, 1, group_op);

Parametri

• op – Un puntatore all’operatore di Majorana groups da separare.
• group_indices – Un puntatore all’array degli indici dei gruppi per i quali costruire gli operatori, nell’ordine di output desiderato. È possibile che NULL, in tal caso, ogni gruppo venga costruito in ordine di indice (il che equivale a passare ogni indice da 0 a :c:func:qf_maj_op_num_groups - 1).
• num_indices – Il numero di indici presenti nell'array group_indices . Viene ignorato se è group_indices NULL.
• group_ops_out – Un puntatore all’array di :c:struct:QfMajoranaOperator in cui scrivere gli operatori per ciascun gruppo richiesto. Deve essere dimensionato in base a num_indices quando group_indices è diverso da NULL, oppure in base a :c:func:qf_maj_op_num_groups quando è NULL.

void qf_maj_op_add_term(QfMajoranaOperator *op, uint64_t num_modes, const uint32_t *modes, const QkComplex64 *coeff)

Aggiunge un termine a un operatore esistente.

Qualsiasi argomento di tipo puntatore può essere NULL se e solo se la sua lunghezza corrispondente è pari a zero.

Esempio

1QfMajoranaOperator *one = qf_maj_op_one();
2
3QfMajoranaOperator *op = qf_maj_op_zero();
4uint32_t modes[0] = {};
5QkComplex64 coeff = {1.0, 0.0};
6
7qf_maj_op_add_term(op, 0, modes, &coeff);
8
9assert(qf_maj_op_equal(op, one));

Parametri

• op – Un puntatore all’operatore di Majorana da modificare.
• num_modes – La lunghezza dell'array delle modalità.
• modalità – Un puntatore a un array di indici di modalità. La lunghezza di questo array dovrebbe essere num_modes.
• coeff – Un puntatore al coefficiente complesso.

QfMajoranaOperator *qf_maj_op_add(const QfMajoranaOperator *left, const QfMajoranaOperator *right)

Somma due operatori.

Esempio

1QfMajoranaOperator *one = qf_maj_op_one();
2QfMajoranaOperator *zero = qf_maj_op_zero();
3
4QfMajoranaOperator *result = qf_maj_op_add(one, zero);
5
6assert(qf_maj_op_equal(result, one));

Parametri

• sinistra – Un puntatore all'operatore di spostamento a sinistra.
• right – Un puntatore all'operatore "a destra".

Risultati

Un puntatore all'operatore risultante.

QfMajoranaOperator *qf_maj_op_mul(const QfMajoranaOperator *op, const QkComplex64 *scalar)

Moltiplica un operatore per uno scalare.

Esempio

1QfMajoranaOperator *one = qf_maj_op_one();
2QkComplex64 coeff = {2.0, 0.0};
3QfMajoranaOperator *result = qf_maj_op_mul(one, &coeff);
4
5QfMajoranaOperator *expected = qf_maj_op_zero();
6uint32_t modes[0] = {};
7qf_maj_op_add_term(expected, 0, modes, &coeff);
8
9assert(qf_maj_op_equal(result, expected));

Parametri

• op – Un puntatore all'operatore.
• scalare – Un puntatore allo scalare.

Risultati

Un puntatore all'operatore risultante.

QfMajoranaOperator *qf_maj_op_compose(const QfMajoranaOperator *left, const QfMajoranaOperator *right)

Combina due operatori tra loro.

Esempio

1QfMajoranaOperator *one = qf_maj_op_one();
2QfMajoranaOperator *zero = qf_maj_op_zero();
3
4QfMajoranaOperator *result = qf_maj_op_compose(one, zero);
5
6assert(qf_maj_op_equal(result, zero));

Parametri

• sinistra – Un puntatore all'operatore di spostamento a sinistra.
• right – Un puntatore all'operatore "a destra".

Risultati

Un puntatore all'operatore risultante.

QfMajoranaOperator *qf_maj_op_adjoint(const QfMajoranaOperator *op)

Restituisce il coniugato ermitiano (o aggiunto) di un operatore.

Ciò influisce sui termini e sui coefficienti come segue:

• le azioni di ciascun termine invertono il loro ordine
• i coefficienti sono coniugati complessi

Esempio

 1QfMajoranaOperator *op = qf_maj_op_zero();
 2uint32_t modes[0] = {};
 3QkComplex64 coeff = {0.0, 1.0};
 4qf_maj_op_add_term(op, 0, modes, &coeff);
 5
 6QfMajoranaOperator *adjoint = qf_maj_op_adjoint(op);
 7
 8QfMajoranaOperator *expected = qf_maj_op_zero();
 9QkComplex64 coeff_adj = {0.0, -1.0};
10qf_maj_op_add_term(expected, 0, modes, &coeff_adj);
11
12assert(qf_maj_op_equal(adjoint, expected));

Parametri

• op – Un puntatore all'operatore.

Risultati

Un puntatore all'operatore creato.

void qf_maj_op_ichop(QfMajoranaOperator *op, double atol)

Rimuove i termini il cui valore assoluto del coefficiente è inferiore alla soglia specificata.

Esempio

 1QfMajoranaOperator *op = qf_maj_op_zero();
 2uint32_t modes[0] = {};
 3QkComplex64 coeff = {1e-8};
 4qf_maj_op_add_term(op, 0, modes, &coeff);
 5
 6qf_maj_op_ichop(op, 1e-6);
 7
 8QfMajoranaOperator *expected = qf_maj_op_zero();
 9
10assert(qf_maj_op_equal(op, expected));

Parametri

• op – Un puntatore all'operatore.
• atol – La tolleranza assoluta per il troncamento del coefficiente.

QfMajoranaOperator *qf_maj_op_simplify(const QfMajoranaOperator *op, double atol)

Restituisce un operatore equivalente ma semplificato.

Il processo di semplificazione somma innanzitutto tutti i coefficienti appartenenti a termini uguali e poi mantiene solo quelli il cui coefficiente totale supera la tolleranza specificata (proprio come qf_maj_op_ichop()).

Quando un operatore è stato manipolato aritmeticamente o costruito in modo tale da non garantire l'unicità dei termini, è opportuno richiamare questo metodo prima di applicare qualsiasi metodo che filtri i coefficienti numericamente piccoli, al fine di evitare la perdita di informazioni. Si veda l'esempio riportato di seguito, che illustra come qf_maj_op_ichop() sia possibile troncare i termini la cui somma dà luogo a un coefficiente totale che non dovrebbe essere troncato:

 1uint64_t num_terms = 100000;
 2uint64_t num_modes = 0;
 3uint32_t modes[0] = {};
 4QkComplex64 coeffs[100000];
 5uint32_t boundaries[100001];
 6for (int i = 0; i < 100000; i++) {
 7  coeffs[i].re = 1e-5;
 8  coeffs[i].im = 0.0;
 9  boundaries[i] = 0;
10}
11boundaries[100000] = 0;
12QfMajoranaOperator *op =
13    qf_maj_op_new(num_terms, num_modes, coeffs, modes, boundaries);
14
15QfMajoranaOperator *canon = qf_maj_op_simplify(op, 1e-4);
16
17QfMajoranaOperator *one = qf_maj_op_one();
18bool canon_is_equal = qf_maj_op_equiv(canon, one, 1e-6);
19
20qf_maj_op_ichop(op, 1e-4);
21
22QfMajoranaOperator *zero = qf_maj_op_zero();
23bool ichop_is_equal = qf_maj_op_equiv(op, zero, 1e-6);

Parametri

• op – Un puntatore all’operatore di Majorana da semplificare.
• atol – La tolleranza assoluta per il troncamento del coefficiente.

Risultati

Un operatore equivalente ma semplificato.

QfMajoranaOperator *qf_maj_op_normal_ordered(const QfMajoranaOperator *op, bool ascending, bool reduce)

Restituisce un operatore equivalente con termini ordinati normalmente.

L'ordine normale di un termine operatore è definito in modo tale che tutte le azioni siano ordinate in ordine lessicografico. Il fatto che salgano o scendano dipende dal valore del parametro ascending .

Esempio

 1QfMajoranaOperator *op = qf_maj_op_zero();
 2uint32_t modes[4] = {0, 2, 1, 3};
 3QkComplex64 coeff = {1.0, 0.0};
 4qf_maj_op_add_term(op, 4, modes, &coeff);
 5
 6QfMajoranaOperator *normal_ordered = qf_maj_op_normal_ordered(op, false, true);
 7
 8QkComplex64 coeff_minus = {-1.0, 0.0};
 9QfMajoranaOperator *expected = qf_maj_op_zero();
10uint32_t modes_exp[4] = {3, 2, 1, 0};
11qf_maj_op_add_term(expected, 4, modes_exp, &coeff_minus);
12
13assert(qf_maj_op_equal(normal_ordered, expected));

Parametri

• op – Un puntatore all'operatore.
• ascendente – Se gli indici debbano aumentare o diminuire.
• riduci – Se ridurre ogni termine alla sua forma minima eliminando le azioni che si elevano al quadrato a identità.

Risultati

Un puntatore all'operatore creato.

bool qf_maj_op_is_hermitian(const QfMajoranaOperator *op, double atol)

Verifica se un operatore è ermitiano.

Esempio

 1QfMajoranaOperator *op = qf_maj_op_zero();
 2uint32_t modes1[2] = {0, 1};
 3QkComplex64 coeff1 = {0.0, 1.00001};
 4qf_maj_op_add_term(op, 2, modes1, &coeff1);
 5uint32_t modes2[2] = {0, 1};
 6QkComplex64 coeff2 = {0.0, -1};
 7qf_maj_op_add_term(op, 2, modes2, &coeff2);
 8
 9assert(qf_maj_op_is_hermitian(op, 1e-4));
10assert(!qf_maj_op_is_hermitian(op, 1e-8));

Parametri

• op – Un puntatore all’operatore di Majorana da verificare.
• atol – La tolleranza assoluta entro la quale i coefficienti sono considerati uguali.

Risultati

Se l'operatore fornito è ermitiano.

uint32_t qf_maj_op_max_rank(const QfMajoranaOperator *op)

Verifica il grado massimo di un operatore.

Esempio

1QfMajoranaOperator *op = qf_maj_op_zero();
2uint32_t modes[4] = {0, 1, 2, 3};
3QkComplex64 coeff = {1.0, 0.0};
4qf_maj_op_add_term(op, 4, modes, &coeff);
5
6assert(qf_maj_op_max_rank(op), 4);

Parametri

• op – Un puntatore all’operatore di Majorana da verificare.

Risultati

Il grado massimo dell'operatore.

bool qf_maj_op_is_even(const QfMajoranaOperator *op)

Verifica se un operatore è pari.

Esempio

 1QfMajoranaOperator *op = qf_maj_op_zero();
 2QkComplex64 coeff = {1.0, 0.0};
 3uint32_t modes1[2] = {0, 1};
 4qf_maj_op_add_term(op, 2, modes1, &coeff);
 5
 6assert(qf_maj_op_is_even(op));
 7
 8uint32_t modes2[1] = {2};
 9qf_maj_op_add_term(op, 2, modes2, &coeff);
10
11assert(!qf_maj_op_is_even(op));

Parametri

• op – Un puntatore all’operatore di Majorana da verificare.

Risultati

Se l'operatore fornito è pari.

bool qf_maj_op_equal(const QfMajoranaOperator *left, const QfMajoranaOperator *right)

Confronta due operatori per verificare se sono uguali.

Esempio

1QfMajoranaOperator *one = qf_maj_op_one();
2QfMajoranaOperator *zero = qf_maj_op_zero();
3
4assert(qf_maj_op_equal(one, one));
5assert(!qf_maj_op_equal(one, zero));

Parametri

• sinistra – Un puntatore all'operatore di spostamento a sinistra.
• right – Un puntatore all'operatore "a destra".

Risultati

Se i due operatori sono uguali.

bool qf_maj_op_equiv(const QfMajoranaOperator *left, const QfMajoranaOperator *right, double atol)

Confronta due operatori per verificare se sono equivalenti.

In questo contesto, per “equivalenza” si intende un’uguaglianza approssimativa entro i limiti della tolleranza assoluta specificata. Per essere più precisi, questo metodo restituisce True, quando tutti i valori assoluti dei coefficienti della differenza other - self sono inferiori alla soglia specificata atol.

Esempio

1QfMajoranaOperator *zero = qf_maj_op_zero();
2
3QfMajoranaOperator *op = qf_maj_op_zero();
4uint32_t modes[0] = {};
5QkComplex64 coeff = {1e-7, 0.0};
6qf_maj_op_add_term(op, 0, modes, &coeff);
7
8assert(qf_maj_op_equiv(op, zero, 1e-6));
9assert(!qf_maj_op_equiv(op, zero, 1e-8));

Parametri

• sinistra – Un puntatore all'operatore di spostamento a sinistra.
• right – Un puntatore all'operatore "a destra".
• atol – La tolleranza assoluta per l'equivalenza dei coefficienti.

Risultati

Se i due operatori sono equivalenti.

size_t qf_maj_op_len(const QfMajoranaOperator *op)

Restituisce la lunghezza (ovvero il numero di termini) dell'operatore specificato.

Esempio

1QfMajoranaOperator *op = qf_maj_op_zero();
2uint32_t modes[4] = {0, 1, 2, 3};
3QkComplex64 coeff = {1.0, 0.0};
4qf_maj_op_add_term(op, 4, modes, &coeff);
5
6assert(qf_maj_op_len(op) == 1);

Parametri

• op – Un puntatore all’operatore di Majorana.

Risultati

La lunghezza (o il numero di termini) dell'operatore.

QfExitCode qf_maj_op_relabel_modes(QfMajoranaOperator *op, uint64_t num_modes, const uint32_t *permutation)

Rinomina le modalità dell'operatore specificato.

Esempio

 1QfMajoranaOperator *op = qf_maj_op_zero();
 2uint32_t modes[4] = {0, 1, 2, 3};
 3QkComplex64 coeff = {1.0, 0.0};
 4qf_maj_op_add_term(op, 4, modes, &coeff);
 5
 6uint32_t permutation[4] = {3, 2, 1, 0};
 7
 8QfExitCode exit = qf_maj_op_relabel_modes(op, 4, permutation);
 9
10assert(exit == QfExitCode_Success);

Parametri

• op – Un puntatore all’operatore di Majorana.
• num_modes – Il numero di indici di modalità presenti nell'elenco di permutazioni fornito.
• permutazione – L'elenco delle permutazioni degli indici.

Risultati

Un codice di uscita.

• QfExitCode_Success in caso di successo
• QfExitCode_DuplicateIndexError se nella permutazione sono stati rilevati indici duplicati
• QfExitCode_IndexError per eventuali altri errori relativi agli indici, come ad esempio indici non validi.