QkCircuit

QkCircuit *qk_circuit_new(uint32_t num_qubits, uint32_t num_clbits)

Costruire un nuovo circuito con il numero di qubit e di clbit indicato.

Esempio

QkCircuit *empty = qk_circuit_new(100, 100);

Parametri

• num_qubits - Il numero di qubit che il circuito contiene.
• num_clbits - Il numero di clbits contenuti nel circuito.

Ritorno

Un puntatore al circuito creato.

void qk_circuit_add_quantum_register(QkCircuit *circuit, const QkQuantumRegister *reg)

Aggiungere un registro quantistico a un determinato circuito quantistico

Esempio

QkCircuit *qc = qk_circuit_new(0, 0);
QkQuantumRegister *qr = qk_quantum_register_new(1024, "my_little_register");
qk_circuit_add_quantum_register(qc, qr);
qk_quantum_register_free(qr);
qk_circuit_free(qc);

Sicurezza

Il comportamento è indefinito se circuit non è un puntatore valido e non nullo a un QkCircuit e se reg non è un puntatore valido e non nullo a un QkQuantumRegister.

Parametri

• circuito - Un puntatore al circuito.
• reg - Un puntatore al registro quantum

size_t qk_circuit_num_quantum_registers(const QkCircuit *circuit)

Calcola il numero di registri quantistici presenti nel circuito.

Restituisce il numero di registri quantistici che sono stati aggiunti al circuito.

Esempio

QkCircuit *qc = qk_circuit_new(0, 0);
QkQuantumRegister *qr1 = qk_quantum_register_new(2, "qr1");
QkQuantumRegister *qr2 = qk_quantum_register_new(3, "qr2");
qk_circuit_add_quantum_register(qc, qr1);
qk_circuit_add_quantum_register(qc, qr2);

size_t num_qregs = qk_circuit_num_quantum_registers(qc);
printf("Number of quantum registers: %zu\n", num_qregs);  // Prints: 2

qk_quantum_register_free(qr1);
qk_quantum_register_free(qr2);
qk_circuit_free(qc);

Sicurezza

Il comportamento non è definito se circuit non è un puntatore valido e non nullo a un QkCircuit.

Parametri

• circuito - Un puntatore al circuito.

Ritorno

Il numero di registri quantistici presenti nel circuito.

const QkQuantumRegister *qk_circuit_get_quantum_register(const QkCircuit *circuit, size_t qreg_idx)

Restituisce il registro quantistico all'indice specificato.

Restituisce un puntatore preso in prestito al registro quantistico all'indice specificato. Il puntatore restituito è valido fintanto che il circuito esiste e non viene modificato. Chi chiama la funzione non deve liberare il puntatore restituito.

Esempio

QkCircuit *qc = qk_circuit_new(0, 0);
QkQuantumRegister *qr1 = qk_quantum_register_new(2, "qr1");
qk_circuit_add_quantum_register(qc, qr1);

const QkQuantumRegister *retrieved = qk_circuit_get_quantum_register(qc, 0);

qk_quantum_register_free(qr1);
qk_circuit_free(qc);

Sicurezza

Il comportamento è indefinito se circuit non è un puntatore valido e non nullo a un QkCircuit, oppure se qreg_idx è fuori dai limiti (maggiore o uguale al numero di registri quantistici nel circuito).

Parametri

• circuito - Un puntatore al circuito.
• qreg_idx – L'indice del registro quantistico da recuperare.

Ritorno

Un puntatore preso in prestito al registro quantistico all'indice specificato. Non liberare questo puntatore.

void qk_circuit_add_classical_register(QkCircuit *circuit, const QkClassicalRegister *reg)

Aggiungere un registro classico a un dato circuito quantistico

Esempio

QkCircuit *qc = qk_circuit_new(0, 0);
QkClassicalRegister *cr = qk_classical_register_new(24, "my_big_register");
qk_circuit_add_classical_register(qc, cr);
qk_classical_register_free(cr);
qk_circuit_free(qc);

Sicurezza

Il comportamento è indefinito se circuit non è un puntatore valido e non nullo a un QkCircuit e se reg non è un puntatore valido e non nullo a un QkClassicalRegister.

Parametri

• circuito - Un puntatore al circuito.
• reg - Un puntatore al registro classico

size_t qk_circuit_num_classical_registers(const QkCircuit *circuit)

Calcola il numero di registri classici presenti nel circuito.

Restituisce il numero di registri classici che sono stati aggiunti al circuito.

Esempio

QkCircuit *qc = qk_circuit_new(0, 0);
QkClassicalRegister *cr1 = qk_classical_register_new(2, "cr1");
QkClassicalRegister *cr2 = qk_classical_register_new(3, "cr2");
qk_circuit_add_classical_register(qc, cr1);
qk_circuit_add_classical_register(qc, cr2);

size_t num_cregs = qk_circuit_num_classical_registers(qc);
printf("Number of classical registers: %zu\n", num_cregs);  // Prints: 2

qk_classical_register_free(cr1);
qk_classical_register_free(cr2);
qk_circuit_free(qc);

Sicurezza

Il comportamento non è definito se circuit non è un puntatore valido e non nullo a un QkCircuit.

Parametri

• circuito - Un puntatore al circuito.

Ritorno

Il numero di registri classici presenti nel circuito.

const QkClassicalRegister *qk_circuit_get_classical_register(const QkCircuit *circuit, size_t creg_idx)

Restituisce il registro classico all'indice specificato.

Restituisce un puntatore preso in prestito al registro classico all'indice specificato. Il puntatore restituito è valido fintanto che il circuito esiste e non viene modificato. Chi chiama la funzione non deve liberare il puntatore restituito.

Esempio

QkCircuit *qc = qk_circuit_new(0, 0);
QkClassicalRegister *cr1 = qk_classical_register_new(2, "cr1");
qk_circuit_add_classical_register(qc, cr1);

const QkClassicalRegister *retrieved = qk_circuit_get_classical_register(qc, 0);

qk_classical_register_free(cr1);
qk_circuit_free(qc);

Sicurezza

Il comportamento è indefinito se circuit non è un puntatore valido e non nullo a un QkCircuit, oppure se creg_idx è fuori dai limiti (>= il numero di registri classici nel circuito).

Parametri

• circuito - Un puntatore al circuito.
• creg_idx – L'indice del registro classico da recuperare.

Ritorno

Un puntatore preso in prestito al registro classico all'indice specificato. Non liberare questo puntatore.

QkCircuit *qk_circuit_copy(const QkCircuit *circuit)

Creare una copia di un sito QkCircuit.

Esempio

QkCircuit *qc = qk_circuit_new(100, 100);
QkCircuit *copy = qk_circuit_copy(qc);

Sicurezza

Il comportamento non è definito se circuit non è un puntatore valido e non nullo a un QkCircuit.

Parametri

• circuito - Un puntatore al circuito da copiare.

Ritorno

Un nuovo puntatore a una copia dell'input circuit.

uint32_t qk_circuit_num_qubits(const QkCircuit *circuit)

Ottiene il numero di qubit che il circuito contiene.

Esempio

QkCircuit *qc = qk_circuit_new(100, 100);
uint32_t num_qubits = qk_circuit_num_qubits(qc);  // num_qubits==100

Sicurezza

Il comportamento non è definito se circuit non è un puntatore valido e non nullo a un QkCircuit.

Parametri

• circuito - Un puntatore al circuito.

Ritorno

Il numero di qubit su cui è definito il circuito.

uint32_t qk_circuit_num_clbits(const QkCircuit *circuit)

Ottiene il numero di bit del circuito.

Esempio

QkCircuit *qc = qk_circuit_new(100, 50);
uint32_t num_clbits = qk_circuit_num_clbits(qc);  // num_clbits==50

Sicurezza

Il comportamento non è definito se circuit non è un puntatore valido e non nullo a un QkCircuit.

Parametri

• circuito - Un puntatore al circuito.

Ritorno

Il numero di clbit su cui è definito il circuito.

size_t qk_circuit_num_param_symbols(const QkCircuit *circuit)

Calcola il numero di simboli non associati agli QkParam oggetti nel circuito.

Esempio

QkCircuit *qc = qk_circuit_new(2, 0);
QkParam *x = qk_param_new_symbol("x");
QkParam *y = qk_param_new_symbol("y");

uint32_t q0[1] = {0};
const QkParam *rx_param[1] = {x};
const QkParam *ry_param[1] = {y};

qk_circuit_parameterized_gate(qc, QkGate_RX, q0, rx_param);
qk_circuit_parameterized_gate(qc, QkGate_RY, q0, ry_param);

// check the number of QkParam symbols
size_t num_symbols = qk_circuit_num_param_symbols(qc); // == 2

qk_param_free(x);
qk_param_free(y);
qk_circuit_free(qc);

Sicurezza

Il comportamento non è definito se circuit non è un puntatore valido e non nullo a un QkCircuit.

Parametri

• circuito - Un puntatore al circuito.

Ritorno

Il numero di simboli QkParam non associati nel circuito.

QkParam *qk_circuit_global_phase(const QkCircuit *circuit)

Calcola la fase globale del circuito.

Questa funzione restituisce una copia della fase globale del circuito; il valore deve essere liberato tramite :c:func:qk_param_free dopo l'utilizzo.

Esempio

QkCircuit *qc = qk_circuit_new(100, 100);
QkParam *phase = qk_circuit_global_phase(qc);
qk_param_free(phase);
qk_circuit_free(qc);

Sicurezza

Il comportamento non è definito se circuit non è un puntatore valido e non nullo a un QkCircuit.

Parametri

• circuito - Un puntatore al circuito.

Ritorno

La fase globale del circuito.

QkExitCode qk_circuit_set_global_phase(QkCircuit *circuit, const QkParam *phase)

Impostare la fase globale del circuito.

Questa funzione copia la nuova fase globale al momento della sua impostazione, pertanto chi la chiama mantiene la proprietà della QkParam fase, e il valore della fase deve essere liberato tramite :c:func:qk_param_free dopo l'impostazione.

Esempio

QkCircuit *qc = qk_circuit_new(100, 100);
QkParam *new_global_phase = qk_param_from_double(1.23);
qk_circuit_set_global_phase(qc, new_global_phase);
qk_param_free(new_global_phase);
qk_circuit_free(qc);

Sicurezza

Il comportamento è indefinito se circuit non è un puntatore valido e non nullo a un QkCircuit e se phase non è un puntatore valido e non nullo a un QkParam.

Parametri

• circuito - Un puntatore al circuito.
• fase – Un puntatore alla fase globale da impostare.

Ritorno

QkExitCode_Success una volta impostata correttamente la fase globale. In caso di errore, QkExitCode_ParameterNameConflict indica che un nuovo simbolo di parametro presenta un conflitto di nomi con uno già esistente. QkExitCode_ParameterError descrive altri errori generici che si verificano quando si tenta di tracciare i simboli dei parametri.

void qk_circuit_free(QkCircuit *circuit)

Liberare il circuito.

Esempio

QkCircuit *qc = qk_circuit_new(100, 100);
qk_circuit_free(qc);

Sicurezza

Il comportamento è indefinito se circuit non è nullo o un puntatore valido a un QkCircuit.

Parametri

• circuito - Un puntatore al circuito da liberare.

QkExitCode qk_circuit_gate(QkCircuit *circuit, QkGate gate, const uint32_t *qubits, const double *params)

Aggiungere un QkGate al circuito.

Esempio

QkCircuit *qc = qk_circuit_new(100, 0);
uint32_t qubit[1] = {0};
qk_circuit_gate(qc, QkGate_H, qubit, NULL);

Sicurezza

I tipi qubits e params devono essere un puntatore a un array di uint32_t e double rispettivamente, la cui lunghezza corrisponde a quella prevista per il gate standard. Se l'array non è sufficientemente lungo, il comportamento di questa funzione non è definito, poiché la lettura avverrà al di fuori dei limiti dell'array. Può essere un puntatore nullo se non ci sono qubit o parametri per un determinato gate. È possibile controllare qk_gate_num_qubits e qk_gate_num_params per determinare quanti qubit e param sono necessari per un determinato gate.

Il comportamento non è definito se circuit non è un puntatore valido e non nullo a un QkCircuit.

Parametri

• circuito - Un puntatore al circuito a cui aggiungere il gate.
• gate - Il StandardGate da aggiungere al circuito.
• qubit - Il puntatore all'array di indici di qubit uint32_t su cui aggiungere il gate. Può essere un puntatore nullo se non ci sono qubit per gate (ad esempio QkGate_GlobalPhase).
• params - Puntatore all'array di valori double da utilizzare per i parametri del gate. Può essere un puntatore nullo se non ci sono parametri per gate (ad esempio QkGate_H).

Ritorno

Un codice di uscita.

QkExitCode qk_circuit_parameterized_gate(QkCircuit *circuit, QkGate gate, const uint32_t *qubits, const QkParam *const *params)

Aggiungere un QkGate con QkParam* parametri al circuito.

Esempio

QkCircuit *qc = qk_circuit_new(100, 0);
QkParam *theta = qk_param_new_symbol("theta");
uint32_t qubit[1] = {0};
const QkParam* params[1] = {theta};
qk_circuit_parameterized_gate(qc, QkGate_RX, qubit, params); // add RX(theta) to the circuit

Sicurezza

I tipi qubits``params e devono essere rispettivamente un puntatore a QkParam* un array di uint32_t e, dove la lunghezza corrisponde a quella prevista per il gate standard. Se l'array non è sufficientemente lungo, il comportamento di questa funzione è indefinito, poiché ciò comporterebbe una lettura al di fuori dei limiti dell'array. Può essere un puntatore nullo se non ci sono qubit o parametri per un determinato gate. È possibile consultare qk_gate_num_qubits e qk_gate_num_params per determinare quanti qubit e parametri sono necessari per un determinato gate.

Il comportamento è indefinito se non circuit è un puntatore valido e non nullo a un QkCircuit, oppure se uno qualsiasi degli elementi params dell'array non è un puntatore valido e non nullo a un QkParam.

Parametri

• circuito - Un puntatore al circuito a cui aggiungere il gate.
• gate – Il QkGate da aggiungere al circuito.
• qubit - Il puntatore all'array di indici di qubit uint32_t su cui aggiungere il gate. Può essere un puntatore nullo se non ci sono qubit per gate (ad esempio QkGate_GlobalPhase).
• params – Il puntatore all'array dei QkParam* parametri da utilizzare per i parametri del gate. Questo può essere un puntatore nullo se non ci sono parametri ( gate ad es. QkGate_H).

Ritorno

QkExitCode_Success una volta completata l'aggiunta. In caso di errore, QkExitCode_ParameterNameConflict indica che il nome di un nuovo simbolo di parametro è in conflitto con quello di uno esistente. QkExitCode_ParameterError descrive altri errori generici che si verificano quando si tenta di tracciare i simboli dei parametri.

uint32_t qk_gate_num_qubits(QkGate gate)

Ottenere il numero di qubit per un QkGate.

Esempio

uint32_t num_qubits = qk_gate_num_qubits(QkGate_CCX);

Parametri

• gate - Il sito QkGate per ottenere il numero di qubit.

Ritorno

Il numero di qubit su cui agisce il gate.

uint32_t qk_gate_num_params(QkGate gate)

Ottenere il numero di parametri per un QkGate.

Esempio

uint32_t num_params = qk_gate_num_params(QkGate_R);

Parametri

• gate - Il sito QkGate per ottenere il numero di qubit.

Ritorno

Il numero di parametri del gate.

QkExitCode qk_circuit_measure(QkCircuit *circuit, uint32_t qubit, uint32_t clbit)

Aggiungere una misura al circuito

Esempio

QkCircuit *qc = qk_circuit_new(100, 1);
qk_circuit_measure(qc, 0, 0);

Sicurezza

Il comportamento non è definito se circuit non è un puntatore valido e non nullo a un QkCircuit.

Parametri

• circuito - Un puntatore al circuito a cui aggiungere la misura
• qubit - Il sito uint32_t per il qubit da misurare
• clbit - Il sito uint32_t per il clbit in cui memorizzare il risultato della misurazione

Ritorno

Un codice di uscita.

QkExitCode qk_circuit_reset(QkCircuit *circuit, uint32_t qubit)

Aggiungere un reset al circuito

Esempio

QkCircuit *qc = qk_circuit_new(100, 0);
qk_circuit_reset(qc, 0);

Sicurezza

Il comportamento non è definito se circuit non è un puntatore valido e non nullo a un QkCircuit.

Parametri

• circuito - Un puntatore al circuito a cui aggiungere il reset
• qubit - Il sito uint32_t per il qubit da resettare

Ritorno

Un codice di uscita.

QkExitCode qk_circuit_barrier(QkCircuit *circuit, const uint32_t *qubits, uint32_t num_qubits)

Aggiungere una barriera al circuito.

Esempio

QkCircuit *qc = qk_circuit_new(100, 1);
uint32_t qubits[5] = {0, 1, 2, 3, 4};
qk_circuit_barrier(qc, qubits, 5);

Sicurezza

La lunghezza dell'array a cui punta qubits deve essere num_qubits. Se c'è una mancata corrispondenza, il comportamento è indefinito.

Il comportamento non è definito se circuit non è un puntatore valido e non nullo a un QkCircuit.

Parametri

• circuito - Un puntatore al circuito a cui aggiungere la barriera.
• num_qubits - Il numero di qubit di larghezza della barriera.
• qubits - Il puntatore all'array di indici di qubit uint32_t su cui aggiungere la barriera.

Ritorno

Un codice di uscita.

QkExitCode qk_circuit_unitary(QkCircuit *circuit, const QkComplex64 *matrix, const uint32_t *qubits, uint32_t num_qubits, bool check_input)

Aggiungere al circuito una matrice unitaria arbitraria.

Esempio

QkComplex64 c0 = {0, 0};  // 0+0i
QkComplex64 c1 = {1, 0};  // 1+0i

const uint32_t num_qubits = 1;
QkComplex64 unitary[2*2] = {c0, c1,  // row 0
                            c1, c0}; // row 1

QkCircuit *circuit = qk_circuit_new(1, 0);  // 1 qubit circuit
uint32_t qubit[1] = {0};  // qubit to apply the unitary on
qk_circuit_unitary(circuit, unitary, qubit, num_qubits, true);

Sicurezza

Il comportamento è indefinito se viene violato uno dei seguenti punti:

• circuit è un puntatore valido e non nullo a un oggetto QkCircuit
• matrix è un puntatore allineato ai valori 4**num_qubits QkComplex64 inizializzati
• qubits è un puntatore allineato ai valori num_qubits uint32_t inizializzati

Parametri

• circuito - Puntatore al circuito a cui aggiungere l'unità.
• matrice - Puntatore alla matrice QkComplex64 che rappresenta la matrice unitaria. Questa deve essere una matrice unitaria a maggioranza di righe di dimensione 2 ^ num_qubits x 2 ^ num_qubits. Più esplicitamente: il (i, j)-esimo elemento è dato da matrix[i * 2^n + j]. Il contenuto di matrix viene copiato all'interno di questa funzione prima di essere aggiunto al circuito, quindi il chiamante mantiene la proprietà della memoria originale a cui punta matrix e può riutilizzarla dopo la chiamata; il chiamante è responsabile della sua liberazione.
• qubit - Puntatore ad un array di indici di qubit, di lunghezza num_qubits.
• num_qubit - Il numero di qubit su cui agisce l'unità.
• check_input - Quando è vero, la funzione verifica che la matrice sia unitaria. Se è impostato su False, il chiamante è responsabile di garantire che la matrice sia unitaria; se la matrice non è unitaria, si tratta di un comportamento non definito e risulterà in un circuito corrotto.

Ritorno

Un codice di uscita.

void qk_circuit_inst_unitary(QkCircuit *circuit, size_t index, QkComplex64 *out)

Trascrivere la matrice unitaria corrispondente a una determinata istruzione del circuito.

Genera un errore se l'istruzione all'indice specificato non è un'operazione unitaria.

Sicurezza

Il comportamento è indefinito se si verifica una delle seguenti condizioni: se non circuit è un puntatore valido e non nullo a un QkCircuit, se index supera il limite massimo del numero di istruzioni nel circuito, se non out è valido per 4**num_qubits scritture su QkComplex64.

Parametri

• circuito – Un puntatore al circuito da cui ricavare l'operatore unitario.
• indice – L'indice dell'istruzione per cui si desidera ottenere l'unitario.
• out – Puntatore allocato e allineato su cui scrivere la matrice unitaria.

QkOperationKind qk_circuit_instruction_kind(const QkCircuit *circuit, size_t index)

Segui il corso di "tipologia" dei circuiti.

Sicurezza

Il comportamento è indefinito se non circuit è un puntatore valido e non nullo a un QkCircuit e se index supera il limite massimo del numero di istruzioni nel circuito.

Parametri

• circuito – Un puntatore al circuito da cui recuperare il tipo di istruzione.
• indice – L'indice dell'istruzione di cui si desidera ottenere il tipo.

Ritorno

Un valore QkOperationKind di enumerazione che rappresenta il tipo di istruzione all'indice specificato.

QkOpCounts qk_circuit_count_ops(const QkCircuit *circuit)

Restituisce un elenco di nomi di stringhe per le istruzioni di un circuito e il loro numero.

Per liberare correttamente la memoria allocata dalla struct, occorre chiamare qk_opcounts_clear. Se si elimina la struttura QkOpCounts senza farlo, l'array memorizzato di QkOpCount rimane allocato e si verifica una perdita di memoria.

Esempio

QkCircuit *qc = qk_circuit_new(100, 0);
uint32_t qubits[1] = {0};
qk_circuit_gate(qc, QkGate_H, qubits, NULL);
QkOpCounts counts = qk_circuit_count_ops(qc);
// .. once done
qk_opcounts_clear(&counts);

Sicurezza

Il comportamento non è definito se circuit non è un puntatore valido e non nullo a un QkCircuit.

Parametri

• circuito - Un puntatore al circuito per cui ottenere i conteggi.

Ritorno

Una struct QkOpCounts contenente i conteggi delle operazioni del circuito.

size_t qk_circuit_num_instructions(const QkCircuit *circuit)

Restituisce il numero totale di istruzioni nel circuito.

Esempio

QkCircuit *qc = qk_circuit_new(100, 0);
uint32_t qubit[1] = {0};
qk_circuit_gate(qc, QkGate_H, qubit, NULL);
size_t num = qk_circuit_num_instructions(qc); // 1

Sicurezza

Il comportamento non è definito se circuit non è un puntatore valido e non nullo a un QkCircuit.

Parametri

• circuito - Un puntatore al circuito per cui ottenere il numero totale di istruzioni.

Ritorno

Il numero totale di istruzioni nel circuito.

void qk_circuit_get_instruction(const QkCircuit *circuit, size_t index, QkCircuitInstruction *instruction)

Restituisce i dettagli dell'istruzione per un'istruzione del circuito.

Questa funzione viene utilizzata per ottenere i dettagli dell'istruzione per una determinata istruzione nel circuito.

Questa funzione alloca internamente la memoria per il sito QkCircuitInstruction fornito e quindi l'utente è responsabile di chiamare qk_circuit_instruction_clear per liberarla.

Esempio

QkCircuitInstruction inst;
QkCircuit *qc = qk_circuit_new(100, 0);
uint32_t qubit[1] = {0};
qk_circuit_gate(qc, QkGate_H, qubit, NULL);
qk_circuit_get_instruction(qc, 0, &inst);
qk_circuit_instruction_clear(&inst);

Sicurezza

Il comportamento non è definito se circuit non è un puntatore valido e non nullo a un QkCircuit. Il valore di index deve essere inferiore al valore restituito da qk_circuit_num_instructions , altrimenti la funzione va in panico. Il comportamento non è definito se instruction non è un puntatore valido e non nullo a un'allocazione di memoria con spazio sufficiente per un QkCircuitInstruction.

Parametri

• circuito - Un puntatore al circuito per il quale ottenere i dettagli dell'istruzione.
• indice - L'indice dell'istruzione di cui ottenere i dettagli.
• istruzione - Un puntatore al punto in cui scrivere l'istruzione QkCircuitInstruction

void qk_circuit_pauli_product_rotation(QkCircuit *circuit, const QkPauliProductRotation *rotation, const uint32_t *qubits)

Applicare un QkPauliProductRotation a un circuito.

Esempio

// build a IXYZ Pauli rotation
bool x[4] = {false, true, true, false};
bool z[4] = {false, false, true, true};
QkParam *angle = qk_param_from_double(1.0);
QkPauliProductRotation rotation = {x, z, 4, angle};
// append it to a circuit
QkCircuit *circuit = qk_circuit_new(10, 1);
uint32_t qubits[4] = {0, 1, 2, 3};
qk_circuit_pauli_product_rotation(circuit, &rotation, qubits);
// do something with the circuit... and then free it
qk_param_free(angle);
qk_circuit_free(circuit);

Sicurezza

Il comportamento è indefinito se viene violato uno dei seguenti punti:

• circuit è un puntatore valido e non nullo a un oggetto QkCircuit
• rotation è un puntatore valido e non nullo a un oggetto coerente QkPauliProductRotation. In particolare, gli array di rotation->z dati rotation->x e devono contenere rotation->len elementi.
• qubits è un puntatore allineato a valori rotation->len uint32_t inizializzati.

Parametri

• circuito – Il circuito su cui applicare l'operazione.
• rotazione – Un puntatore alla rotazione QkPauliProductRotation da applicare.
• qubit – Un puntatore all'array di qubit.

QkExitCode qk_circuit_inst_pauli_product_rotation(const QkCircuit *circuit, size_t index, QkPauliProductRotation *instruction)

Recupera i QkPauliProductRotation dati da un'istruzione di circuito.

Per un circuito con QkPauliProductRotation un'istruzione all'indice index, questa funzione assegnerà al instruction puntatore una copia dei QkPauliProductRotation dati. Si noti che questi dati sono indipendenti dal circuito e devono essere liberati manualmente con qk_pauli_product_rotation_clear.

Se l'istruzione all'indirizzo specificato **non **index è un QkPauliProductRotation, questa funzione restituirà QkExitCode_InvalidOperationKind un errore. È possibile verificare che l'istruzione sia del tipo corretto utilizzando qk_circuit_instruction_kind.

Sicurezza

Il comportamento è indefinito se non circuit è un puntatore valido e non nullo a un QkCircuit. Il valore di index deve essere inferiore al valore restituito da; in qk_circuit_num_instructions caso contrario, questa funzione genererà un errore. Il comportamento è indefinito se non instruction è un puntatore valido e non nullo a un'allocazione di memoria con spazio sufficiente per un QkPauliProductRotation.

Parametri

• circuito – Un puntatore al circuito da cui recuperare i dettagli dell'istruzione.
• indice – L'indice delle istruzioni del circuito.
• istruzione – Un puntatore a un'area di memoria allocata QkPauliProductRotation per memorizzare i dati.

Ritorno

QkExitCode_Success se il dato è stato scritto nell'istruzione, oppure QkExitCode_InvalidOperationKind se l'indice non puntava a un QkPauliProductRotation.

void qk_circuit_pauli_product_measurement(QkCircuit *circuit, const QkPauliProductMeasurement *measurement, const uint32_t *qubits, uint32_t clbit)

Applicare un QkPauliProductMeasurement a un circuito.

Esempio

// build a XZ Pauli measurement
bool x[2] = {true, false};
bool z[2] = {false, true};
QkPauliProductMeasurement measure = {x, z, 2, false};
// append it to a circuit
QkCircuit *circuit = qk_circuit_new(10, 1);
uint32_t qubits[2] = {0, 2};
uint32_t clbit = 0;
qk_circuit_pauli_product_measurement(circuit, &measure, qubits, clbit);
// do something with the circuit... and then free it
qk_circuit_free(circuit);

Sicurezza

Il comportamento è indefinito se viene violato uno dei seguenti punti:

• circuit è un puntatore valido e non nullo a un oggetto QkCircuit
• measurement è un puntatore valido e non nullo a un oggetto coerente QkPauliProductMeasurement. In particolare, gli array di measurement->z dati measurement->x e devono contenere measurement->len elementi.
• qubits è un puntatore allineato a valori rotation->len uint32_t inizializzati.

Parametri

• circuito – Il circuito su cui applicare l'operazione.
• misura – Un puntatore alla misura QkPauliProductMeasurement da applicare.
• qubit – Un puntatore all'array di qubit.
• clbit – Un singolo uint32_t parametro che specifica il qubit di misura.

QkExitCode qk_circuit_inst_pauli_product_measurement(const QkCircuit *circuit, size_t index, QkPauliProductMeasurement *instruction)

Recupera i QkPauliProductMeasurement dati da un'istruzione di circuito.

Per un circuito con QkPauliProductMeasurement un'istruzione all'indice index, questa funzione assegnerà al instruction puntatore una copia dei QkPauliProductMeasurement dati. Si noti che questi dati, essendo indipendenti dal circuito, devono essere liberati manualmente con qk_pauli_product_measurement_clear.

Se l'istruzione all'indirizzo specificato **non **index è un QkPauliProductMeasurement, questa funzione restituirà QkExitCode_InvalidOperationKind un errore. Verificare che l'istruzione sia del tipo corretto utilizzando qk_circuit_instruction_kind.

Sicurezza

Il comportamento è indefinito se non circuit è un puntatore valido e non nullo a un QkCircuit. Il valore di index deve essere inferiore al valore restituito da; in qk_circuit_num_instructions caso contrario, questa funzione genererà un errore. Il comportamento è indefinito se non instruction è un puntatore valido e non nullo a un'allocazione di memoria con spazio sufficiente per un QkPauliProductMeasurement.

Parametri

• circuito – Un puntatore al circuito da cui recuperare i dettagli dell'istruzione.
• indice – L'indice delle istruzioni del circuito.
• istruzione – Un puntatore a un'area di memoria allocata QkPauliProductMeasurement per memorizzare i dati.

Ritorno

QkExitCode_Success se il dato è stato scritto nell'istruzione, oppure QkExitCode_InvalidOperationKind se l'indice non puntava a un QkPauliProductMeasurement.

void qk_circuit_instruction_clear(QkCircuitInstruction *inst)

Cancella i dati nell'oggetto istruzione del circuito.

Questa funzione non libera l'allocazione per il puntatore QkCircuitInstruction fornito, ma libera solo l'allocazione interna per i dati contenuti nell'istruzione. L'utente è responsabile dell'allocazione e della liberazione dell'allocazione effettiva utilizzata per memorizzare un QkCircuitInstruction.

Esempio

QkCircuitInstruction *inst = malloc(sizeof(QkCircuitInstruction));
QkCircuit *qc = qk_circuit_new(100, 0);
uint32_t q0[1] = {0};
qk_circuit_gate(qc, QkGate_H, q0, NULL);
qk_circuit_get_instruction(qc, 0, inst);
qk_circuit_instruction_clear(inst); // clear internal allocations
free(inst); // free struct
qk_circuit_free(qc); // free the circuit

Sicurezza

Il comportamento non è definito se inst non è un puntatore valido e non nullo a un QkCircuitInstruction.

Parametri

• inst - Un puntatore all'istruzione da liberare.

void qk_opcounts_clear(QkOpCounts *op_counts)

Cancella il contenuto di un elenco di operazioni del circuito.

Sicurezza

Il comportamento è indefinito se op_counts non è l'oggetto restituito da qk_circuit_count_ops.

Parametri

• op_counts - L'elenco di op count restituito da qk_circuit_count_ops.

QkExitCode qk_circuit_delay(QkCircuit *circuit, uint32_t qubit, double duration, QkDelayUnit unit)

Aggiungere un'istruzione di ritardo al circuito.

Esempio

QkCircuit *qc = qk_circuit_new(1, 0);
qk_circuit_delay(qc, 0, 100.0, QkDelayUnit_NS);

Sicurezza

Il comportamento non è definito se circuit non è un puntatore valido e non nullo a un QkCircuit.

Parametri

• circuito - Un puntatore al circuito a cui aggiungere il ritardo.
• qubit - L'indice uint32_t del qubit a cui applicare il ritardo.
• durata - La durata del ritardo.
• unit - Un enum che rappresenta l'unità della durata.

Ritorno

Un codice di uscita.

char *qk_circuit_draw(const QkCircuit *circuit, const QkCircuitDrawerConfig *config)

Disegna lo schema sotto forma di testo.

Esempio

QkCircuit *circuit = qk_circuit_new(2, 1);

qk_circuit_gate(circuit, QkGate_H, (uint32_t[]){0}, NULL);
qk_circuit_gate(circuit, QkGate_CX, (uint32_t[]){0, 1}, NULL);
qk_circuit_measure(circuit, 0, 0);
qk_circuit_measure(circuit, 1, 0);

QkCircuitDrawerConfig config = {false, true, 0};

char *circ_str = qk_circuit_draw(circuit, &config);

printf("%s", circ_str);

qk_str_free(circ_str);
qk_circuit_free(circuit);

Sicurezza

Il comportamento è indefinito se non circuit è un puntatore valido e non nullo a una QkCircuit, oppure se non config è NULL e rappresenta un puntatore non valido a una QkCircuitDrawerConfig struct.

Parametri

• circuito – Un puntatore al circuito da disegnare.

• config – Un puntatore alla QkCircuitDrawerConfig struttura o NULL. Se il valore è NULL, il cassetto utilizzerà questi valori predefiniti:

  • bundle_cregs = true
  • merge_wires = true
  • fold = 0

Ritorno

Un puntatore a una stringa terminata da un carattere null contenente la rappresentazione del circuito. Una volta terminato, è necessario utilizzare qk_str_free per liberare la memoria allocata.

QkDag *qk_circuit_to_dag(const QkCircuit *circuit)

Converti un dato circuito in un DAG.

Il nuovo DAG viene copiato dal circuito; il riferimento circuit originale rimane di proprietà del chiamante e deve ancora essere liberato con qk_circuit_free. Una volta terminato, è qk_dag_free necessario liberare il DAG restituito con.

Esempio

QkCircuit *qc = qk_circuit_new(0, 0);
QkQuantumRegister *qr = qk_quantum_register_new(3, "qr");
qk_circuit_add_quantum_register(qc, qr);
qk_quantum_register_free(qr);

QkDag *dag = qk_circuit_to_dag(qc);

qk_dag_free(dag);
qk_circuit_free(qc);

Sicurezza

Il comportamento non è definito se circuit non è un puntatore valido e non nullo a un QkCircuit.

Parametri

• circuito – Un puntatore al circuito da cui creare il DAG.

Ritorno

Un puntatore al nuovo DAG.

QkCircuit *qk_circuit_copy_empty_like(const QkCircuit *circuit, QkVarsMode vars_mode, QkBlocksMode blocks_mode)

Restituisce una copia di sé stessa con la stessa struttura ma vuota.

Tale struttura comprende:

• fase globale
• tutti i qubit e i clbit, compresi i registri.

Esempio

QkCircuit *qc = qk_circuit_new(10, 10);
for (int i = 0; i < 10; i++) {
    qk_circuit_measure(qc, i, i);
    uint32_t qubits[1] = {i};
    qk_circuit_gate(qc, QkGate_H, qubits, NULL);
}

// As the circuit does not contain any control-flow instructions,
// vars_mode and blocks_mode do not have any effect.
QkCircuit *copy = qk_circuit_copy_empty_like(qc, QkVarsMode_Alike, QkBlocksMode_Drop);

size_t num_copy_instructions = qk_circuit_num_instructions(copy); // 0

// do something with the copy

qk_circuit_free(qc);
qk_circuit_free(copy);

Sicurezza

Il comportamento non è definito se circuit non è un puntatore valido e non nullo a un QkCircuit.

Parametri

• circuito - Un puntatore al circuito da copiare.
• vars_mode – La modalità per la gestione delle variabili classiche.
• blocks_mode – La modalità di gestione dei blocchi.

Ritorno

Il puntatore al circuito copiato.

double qk_circuit_estimate_fidelity(const QkCircuit *circuit, const QkTarget *target)

Stimare la fedeltà di un circuito fisico.

Questa funzione calcolerà il prodotto dei tassi di errore di ciascun gate del circuito per stimare la fedeltà del circuito. Questo metodo non è finalizzato a fornire una simulazione realistica della fedeltà di esecuzione su hardware reale. È stato progettato per fornire una stima del funzionamento del transpiler, tenendo conto del livello di fedeltà delle varie euristiche utilizzate nel suo funzionamento. In genere è utile solo per confrontare tra loro i risultati di diverse compilazioni, al fine di valutare quale di essi garantirebbe un'esecuzione di qualità superiore sull'hardware.

Sicurezza

Il comportamento è indefinito se circuit e target non sono rispettivamente puntatori validi e non nulli a e QkTarget``QkCircuit .

Parametri

• circuito – Un puntatore al circuito di cui si desidera stimare la fedeltà.
• target – Un puntatore al target su cui verrà eseguito il circuito. Questo serve a calcolare i tassi di errore delle istruzioni presenti nel circuito.

Ritorno

La fedeltà calcolata del circuito. Se il circuito non è fisico, verrà restituito " NaN ", il che significa che circuit sono presenti istruzioni non supportate da target.

QkControlFlowInstruction *qk_circuit_get_control_flow_instruction(const QkCircuit *circuit, size_t inst_idx, const QkControlFlowInstruction *parent_cf)

Recupera un'istruzione di flusso di controllo da un circuito all'indice specificato.

Questa funzione restituisce un puntatore a una struttura opaca QkControlFlowInstruction , che contiene informazioni relative a un'istruzione di flusso di controllo all'indice specificato. L'istruzione in inst_idx deve essere un'istruzione di controllo del flusso (ad esempio, IfElse,, ForLoop, ecc.).

Esempio

QkCircuit *circuit = ...; // Assume circuit contains a control flow instruction at index 0
QkControlFlowInstruction *cf_inst = qk_circuit_get_control_flow_instruction(circuit, 0, NULL);
QkControlFlowKind kind = qk_control_flow_kind(cf_inst);
qk_control_flow_instruction_free(cf_inst);

Sicurezza

Il comportamento è indefinito se circuit non è un puntatore valido a un QkCircuit oggetto, oppure se inst_idx non è un indice valido all'interno dell'elenco delle istruzioni del circuito, oppure se l'istruzione in inst_idx posizione non è un'istruzione di flusso di controllo. Se parent_cf non è nullo, deve essere un puntatore valido a un QkControlFlowInstruction.

Parametri

• circuito – Un puntatore al circuito contenente l'istruzione di controllo del flusso.
• inst_idx – L'indice dell'istruzione nell'elenco delle istruzioni del circuito.
• parent_cf – Un puntatore all'istruzione di flusso di controllo contenente, oppure NULL , se questa istruzione si trova al livello superiore del circuito. Questo serve a calcolare le corrette mappature dei qubit e dei clbit rispetto al circuito di livello superiore.

Ritorno

Un puntatore a un oggetto appena allocato QkControlFlowInstruction .

void qk_control_flow_instruction_free(QkControlFlowInstruction *cf_inst)

Libera un QkControlFlowInstruction oggetto.

Esempio

QkCircuit *circuit = ...; // Assume circuit contains a control flow instruction at index 0
QkControlFlowInstruction *cf_inst = qk_circuit_get_control_flow_instruction(circuit, 0, NULL);
qk_control_flow_instruction_free(cf_inst);

Sicurezza

Il comportamento è indefinito se cf_inst non è un puntatore valido restituito da qk_circuit_get_control_flow_instruction, oppure se questa funzione viene chiamata più di una volta sullo stesso puntatore.

Parametri

• cf_inst – Un puntatore all'istruzione di flusso di controllo da liberare.

PyObject *qk_circuit_to_python(QkCircuit *qc)

Trasferisci la proprietà di un QkCircuit oggetto a Python.

L'oggetto Python risultante non è QuantumCircuit, bensì il suo contenuto interno CircuitData, a cui in genere si accede come QuantumCircuit._data. È possibile utilizzare qk_circuit_to_python_full per creare un oggetto QuantumCircuit completo.

Non è sicuro utilizzare il QkCircuit puntatore dopo aver chiamato questa funzione. In particolare, non dovresti cercare di ripulirlo o liberarlo. Chi effettua la chiamata deve essere il proprietario dell'oggetto QkCircuit, non possedere un riferimento preso in prestito (ad esempio, un oggetto QkCircuit * recuperato da non qk_circuit_borrow_from_python è di sua proprietà).

Sicurezza

Chi chiama deve essere collegato a un interprete dell' Python. Il comportamento è indefinito se non circuit è un puntatore non nullo valido a un oggetto inizializzato e di proprietà dell'utente QkCircuit.

Parametri

• qc – L'oggetto di proprietà.

Ritorno

Un riferimento di tipo " Python " all'oggetto.

PyObject *qk_circuit_to_python_full(QkCircuit *qc)

Trasferisci la proprietà di un QkCircuit oggetto a Python e crea un. QuantumCircuit

Ciò comporta l'aggiunta di una logica nel spazio Python per ottenere il campo completo QuantumCircuit, poiché QkCircuit corrisponde solo al campo QuantumCircuit._data interno.

Non è sicuro utilizzare il QkCircuit puntatore dopo aver chiamato questa funzione. In particolare, non dovresti cercare di ripulirlo o liberarlo. Chi effettua la chiamata deve essere il proprietario dell'oggetto QkCircuit, non possedere un riferimento preso in prestito (ad esempio, un oggetto QkCircuit * recuperato da non qk_circuit_borrow_from_python è di sua proprietà).

Sicurezza

Chi chiama deve essere collegato a un interprete dell' Python. Il comportamento è indefinito se non circuit è un puntatore non nullo valido a un oggetto inizializzato e di proprietà dell'utente QkCircuit.

Parametri

• qc – L'oggetto di proprietà.

Ritorno

Un riferimento di tipo " Python " all'oggetto.

QkCircuit *qk_circuit_borrow_from_python(PyObject *ob)

Recupera un QkCircuit puntatore da un oggetto Python.

Si noti che l'argomento di questa funzione non deve essere QuantumCircuit, bensì l'output di QuantumCircuit._data. Ciò è necessario per garantire il corretto funzionamento della semantica del conteggio dei riferimenti.

Questa operazione prende in prestito un riferimento a un oggetto di tipo Python ed estrae il QkCircuit puntatore corrispondente, se è del tipo corretto. Il puntatore restituito viene preso in prestito dal ob puntatore. Se il non PyObject è del tipo corretto, il valore restituito è NULL e viene impostato lo stato di eccezione dell'interprete di Python.

Per chiamare questa funzione è necessario essere collegati a un interprete Python.

È inoltre possibile utilizzare qk_circuit_convert_from_python, che dal punto di vista logico è esattamente identico a questa funzione, ma può essere utilizzato direttamente come funzione di "conversione" per la PyArg_Parse* famiglia di funzioni di conversione di Python.

Sicurezza

Chi chiama deve essere collegato a un interprete dell' Python. Il comportamento è indefinito se non ob è un puntatore valido e non nullo a un oggetto Python.

Parametri

• ob – Un oggetto preso in prestito dall' Python.

Ritorno

Un puntatore all'oggetto nativo, oppure NULL se l'oggetto Python è di tipo errato.

int qk_circuit_convert_from_python(PyObject *object, void *address)

Recupera un QkCircuit puntatore da un oggetto Python.

Si noti che l'argomento di questa funzione non deve essere QuantumCircuit, bensì l'output di QuantumCircuit._data. Ciò è necessario per garantire il corretto funzionamento della semantica del conteggio dei riferimenti.

Questa operazione prende in prestito un riferimento di tipo Python ed estrae il QkCircuit puntatore corrispondente in address,, se è del tipo corretto. Il puntatore restituito viene preso in prestito dal object puntatore. Se il tipo PyObject non è corretto, il valore restituito è 0, viene impostato lo stato di eccezione dell'interprete di Python e e address rimane invariato.

Per chiamare questa funzione è necessario essere collegati a un interprete Python.

Puoi anche usare qk_circuit_borrow_from_python, che dal punto di vista logico è esattamente uguale a questo, ma presenta una sintassi più intuitiva per l'uso diretto.

Sicurezza

Chi chiama deve essere collegato a un interprete dell' Python. Il comportamento è indefinito se non object è un puntatore valido e non nullo a un oggetto Python, oppure se non address è un puntatore a dati scrivibili del tipo corretto.

Parametri

• oggetto – Un oggetto Python preso in prestito.
• destinazione – La posizione in cui scrivere l'output.

Ritorno

1 in caso di successo, 0 in caso di fallimento.

PyObject *qk_quantum_register_to_python(QkQuantumRegister *qr)

Trasferisci la proprietà di un QkQuantumRegister oggetto a Python.

Non è sicuro utilizzare il QkQuantumRegister puntatore dopo aver chiamato questa funzione. In particolare, non dovresti cercare di ripulirlo o liberarlo. Chi effettua la chiamata deve essere il proprietario dell'oggetto QkQuantumRegister, non possedere un riferimento preso in prestito (ad esempio, un oggetto QkQuantumRegister * recuperato da non qk_quantum_register_borrow_from_python è di sua proprietà).

Sicurezza

Chi chiama deve essere collegato a un interprete dell' Python. Il comportamento è indefinito se non qr è un puntatore non nullo valido a un oggetto inizializzato e di proprietà dell'utente QkQuantumRegister.

Parametri

• qr – L'oggetto di proprietà.

Ritorno

Un riferimento di tipo " Python " all'oggetto.

const QkQuantumRegister *qk_quantum_register_borrow_from_python(PyObject *ob)

Recupera un QkQuantumRegister puntatore da un oggetto Python.

Questa operazione prende in prestito un riferimento a un oggetto di tipo Python ed estrae il QkQuantumRegister puntatore corrispondente, se è del tipo corretto. Il puntatore restituito viene preso in prestito dal ob puntatore. Se il non PyObject è del tipo corretto, il valore restituito è NULL e viene impostato lo stato di eccezione dell'interprete di Python.

Per chiamare questa funzione è necessario essere collegati a un interprete Python.

È inoltre possibile utilizzare qk_quantum_register_convert_from_python, che dal punto di vista logico è esattamente identico a questa funzione, ma può essere utilizzato direttamente come funzione di "conversione" per la PyArg_Parse* famiglia di funzioni di conversione di Python.

Sicurezza

Chi chiama deve essere collegato a un interprete dell' Python. Il comportamento è indefinito se non ob è un puntatore valido e non nullo a un oggetto Python.

Parametri

• ob – Un oggetto preso in prestito dall' Python.

Ritorno

Un puntatore all'oggetto nativo, oppure NULL se l'oggetto Python è di tipo errato.

int qk_quantum_register_convert_from_python(PyObject *object, void *address)

Recupera un QkQuantumRegister puntatore da un oggetto Python.

Questa operazione prende in prestito un riferimento di tipo Python ed estrae il QkQuantumRegister puntatore corrispondente in address,, se è del tipo corretto. Il puntatore restituito viene preso in prestito dal object puntatore. Se il tipo PyObject non è corretto, il valore restituito è 0, viene impostato lo stato di eccezione dell'interprete di Python e e address rimane invariato.

Per chiamare questa funzione è necessario essere collegati a un interprete Python.

Puoi anche usare qk_quantum_register_borrow_from_python, che dal punto di vista logico è esattamente uguale a questo, ma presenta una sintassi più intuitiva per l'uso diretto.

Sicurezza

Chi chiama deve essere collegato a un interprete dell' Python. Il comportamento è indefinito se non object è un puntatore valido e non nullo a un oggetto Python, oppure se non address è un puntatore a dati scrivibili del tipo corretto.

Parametri

• oggetto – Un oggetto Python preso in prestito.
• destinazione – La posizione in cui scrivere l'output.

Ritorno

1 in caso di successo, 0 in caso di fallimento.

PyObject *qk_classical_register_to_python(QkClassicalRegister *cr)

Trasferisci la proprietà di un QkClassicalRegister oggetto a Python.

Non è sicuro utilizzare il QkClassicalRegister puntatore dopo aver chiamato questa funzione. In particolare, non dovresti cercare di ripulirlo o liberarlo. Chi effettua la chiamata deve essere il proprietario dell'oggetto QkClassicalRegister, non possedere un riferimento preso in prestito (ad esempio, un oggetto QkClassicalRegister * recuperato da non qk_classical_register_borrow_from_python è di sua proprietà).

Sicurezza

Chi chiama deve essere collegato a un interprete dell' Python. Il comportamento è indefinito se non cr è un puntatore non nullo valido a un oggetto inizializzato e di proprietà dell'utente QkClassicalRegister.

Parametri

• cr – L'oggetto di proprietà.

Ritorno

Un riferimento di tipo " Python " all'oggetto.

const QkClassicalRegister *qk_classical_register_borrow_from_python(PyObject *ob)

Recupera un QkClassicalRegister puntatore da un oggetto Python.

Questa operazione prende in prestito un riferimento a un oggetto di tipo Python ed estrae il QkClassicalRegister puntatore corrispondente, se è del tipo corretto. Il puntatore restituito viene preso in prestito dal ob puntatore. Se il non PyObject è del tipo corretto, il valore restituito è NULL e viene impostato lo stato di eccezione dell'interprete di Python.

Per chiamare questa funzione è necessario essere collegati a un interprete Python.

È inoltre possibile utilizzare qk_classical_register_convert_from_python, che dal punto di vista logico è esattamente identico a questa funzione, ma può essere utilizzato direttamente come funzione di "conversione" per la PyArg_Parse* famiglia di funzioni di conversione di Python.

Sicurezza

Chi chiama deve essere collegato a un interprete dell' Python. Il comportamento è indefinito se non ob è un puntatore valido e non nullo a un oggetto Python.

Parametri

• ob – Un oggetto preso in prestito dall' Python.

Ritorno

Un puntatore all'oggetto nativo, oppure NULL se l'oggetto Python è di tipo errato.

int qk_classical_register_convert_from_python(PyObject *object, void *address)

Recupera un QkClassicalRegister puntatore da un oggetto Python.

Questa operazione prende in prestito un riferimento di tipo Python ed estrae il QkClassicalRegister puntatore corrispondente in address,, se è del tipo corretto. Il puntatore restituito viene preso in prestito dal object puntatore. Se il tipo PyObject non è corretto, il valore restituito è 0, viene impostato lo stato di eccezione dell'interprete di Python e e address rimane invariato.

Per chiamare questa funzione è necessario essere collegati a un interprete Python.

Puoi anche usare qk_classical_register_borrow_from_python, che dal punto di vista logico è esattamente uguale a questo, ma presenta una sintassi più intuitiva per l'uso diretto.

Sicurezza

Chi chiama deve essere collegato a un interprete dell' Python. Il comportamento è indefinito se non object è un puntatore valido e non nullo a un oggetto Python, oppure se non address è un puntatore a dati scrivibili del tipo corretto.

Parametri

• oggetto – Un oggetto Python preso in prestito.
• destinazione – La posizione in cui scrivere l'output.

Ritorno

1 in caso di successo, 0 in caso di fallimento.