Context Classe
Un ambiente di interprete Q# isolato.
Un contesto fornisce un ambiente di esecuzione Q# autonomo in cui il codice viene valutato, compilato ed eseguito in isolamento da altre istanze di Contesto. Ogni contesto mantiene il proprio spazio dei nomi del codice.
Un contesto ha un attributo code che è un modulo Python contenente tutte le operazioni e i tipi Q# definiti in questo contesto. In questo modo è possibile chiamare le operazioni Q# da Python.
Esempio:
ctx = qdk.Context()
ctx.eval("operation Main() : Result { use q = Qubit(); X(q); MResetZ(q) }")
assert ctx.run("Main()", 2) == [qdk.Result.One, qdk.Result.One]
assert ctx.code.Main() == qdk.Result.One
Inizializza un nuovo contesto Q# isolato.
Costruttore
Context(*, target_profile: TargetProfile = TargetProfile.Unrestricted, target_name: str | None = None, project_root: str | None = None, language_features: List[str] | None = None, _trace_circuit: bool | None = None, _is_global_context: bool = False)
Parametri di sole parole chiave
| Nome | Descrizione |
|---|---|
|
target_profile
|
L'impostazione del profilo di destinazione consente all'interprete Q# di generare programmi compatibili con una destinazione specifica. Vedete TargetProfile. Valore predefinito: Unrestricted
|
|
target_name
|
Nome facoltativo del computer di destinazione da usare per dedurre l'impostazione di target_profile compatibile. Valore predefinito: None
|
|
project_root
|
Percorso facoltativo di una directory radice con un progetto Q# da includere. Deve contenere un manifesto del progetto qsharp.json. Valore predefinito: None
|
|
language_features
|
Elenco facoltativo di flag di funzionalità della lingua da abilitare. Questi corrispondono alle funzionalità sperimentali o in anteprima del linguaggio Q#. I valori validi sono:
modulo a blocchi di allocazione qubit con ambito ( Valore predefinito: None
|
|
_trace_circuit
|
Valore predefinito: None
|
|
_is_global_context
|
Valore predefinito: False
|
Metodi
| circuit |
Esegue la sintesi di un circuito per un programma Q#. È necessario specificare un'espressione di voce o un'operazione. |
| compile |
Compila il codice sorgente Q# in un programma che può essere inviato a una destinazione. È necessario specificare un'espressione di voce o un oggetto chiamabile con argomenti. Esempio: |
| dump_machine |
Restituisce il vettore di stato sparse del simulatore come oggetto StateDump. |
| eval |
Valuta il codice sorgente Q#. L'output viene stampato nella console. |
| get_target_profile |
Restituisce il profilo di destinazione per questo contesto. |
| import_openqasm |
Importa il codice sorgente OpenQASM nell'interprete di questo contesto. |
| logical_counts |
Estrae i conteggi delle risorse logiche dal codice sorgente Q#. È necessario specificare un'espressione di voce o un oggetto chiamabile con argomenti. |
| run |
Esegue l'espressione Q# specificata per il numero specificato di scatti. Ogni scatto usa un'istanza indipendente del simulatore. |
| set_classical_seed |
Imposta il valore di inizializzazione per il generatore di numeri casuali utilizzato per le operazioni numeri casuali classiche della libreria standard. Questo vale per tutto il codice Q# eseguito, compilato o stimato in questo contesto. |
| set_quantum_seed |
Imposta il valore di inizializzazione per il generatore di numeri casuali usato per le misurazioni quantistiche. Questo vale per tutto il codice Q# eseguito, compilato o stimato in questo contesto. |
circuit
Esegue la sintesi di un circuito per un programma Q#. È necessario specificare un'espressione di voce o un'operazione.
circuit(entry_expr: str | Callable | GlobalCallable | Closure | None = None, *args, operation: str | None = None, generation_method: CircuitGenerationMethod | None = None, max_operations: int | None = None, source_locations: bool = False, group_by_scope: bool = True, prune_classical_qubits: bool = False) -> Circuit
Parametri
| Nome | Descrizione |
|---|---|
|
entry_expr
|
Espressione di immissione. In alternativa, è possibile specificare un oggetto chiamabile, che deve essere chiamabile Q#. Valore predefinito: None
|
|
*args
Necessario
|
Argomenti da passare all'oggetto chiamabile, se disponibile. |
Parametri di sole parole chiave
| Nome | Descrizione |
|---|---|
|
operation
|
Operazione da sintetizzare. Può trattarsi di un nome di un'operazione o di un'espressione lambda. L'operazione deve accettare solo qubit o matrici di qubit come parametri. Valore predefinito: None
|
|
generation_method
|
Metodo da utilizzare per la generazione di circuiti.
ClassicalEval valuta il flusso di controllo classico in fase di generazione del circuito.
Simulate esegue una simulazione completa per tracciare il circuito.
Static usa la valutazione parziale e richiede un profilo non Valore predefinito: None
|
|
max_operations
|
Numero massimo di operazioni da includere nel circuito. L'impostazione Valore predefinito: None
|
|
source_locations
|
Se Valore predefinito: False
|
|
group_by_scope
|
Se Valore predefinito: True
|
|
prune_classical_qubits
|
Se Valore predefinito: False
|
Valori restituiti
| Tipo | Descrizione |
|---|---|
|
<xref:Circuit>
|
Circuito sintetizzato. |
Eccezioni
| Tipo | Descrizione |
|---|---|
|
Se si verifica un errore durante la diffusione del circuito. |
compile
Compila il codice sorgente Q# in un programma che può essere inviato a una destinazione. È necessario specificare un'espressione di voce o un oggetto chiamabile con argomenti.
Esempio:
compile(entry_expr: str | Callable | GlobalCallable | Closure, *args) -> QirInputData
Parametri
| Nome | Descrizione |
|---|---|
|
entry_expr
Necessario
|
Espressione Q# che verrà usata come punto di ingresso per il programma. In alternativa, è possibile specificare un oggetto chiamabile, che deve essere chiamabile Q#. |
|
*args
Necessario
|
Argomenti da passare all'oggetto chiamabile, se disponibile. |
Valori restituiti
| Tipo | Descrizione |
|---|---|
|
<xref:QirInputData>
|
Programma compilato. Usare |
dump_machine
Restituisce il vettore di stato sparse del simulatore come oggetto StateDump.
dump_machine() -> StateDump
Valori restituiti
| Tipo | Descrizione |
|---|---|
|
Stato del simulatore. |
eval
Valuta il codice sorgente Q#.
L'output viene stampato nella console.
eval(source: str, *, save_events: bool = False) -> Any
Parametri
| Nome | Descrizione |
|---|---|
|
source
Necessario
|
Codice sorgente Q# da valutare. |
Parametri di sole parole chiave
| Nome | Descrizione |
|---|---|
|
save_events
|
Se true, tutti gli output verranno salvati e restituiti. Se false, verranno stampate. Valore predefinito: False
|
Valori restituiti
| Tipo | Descrizione |
|---|---|
|
Valore restituito dall'ultima istruzione nel codice sorgente o dall'output salvato se |
Eccezioni
| Tipo | Descrizione |
|---|---|
|
Se si verifica un errore durante la valutazione del codice sorgente. |
get_target_profile
Restituisce il profilo di destinazione per questo contesto.
get_target_profile() -> TargetProfile
import_openqasm
Importa il codice sorgente OpenQASM nell'interprete di questo contesto.
import_openqasm(source: str, **kwargs: Any) -> Any
Parametri
| Nome | Descrizione |
|---|---|
|
source
Necessario
|
Un programma o un frammento OpenQASM. |
|
**kwargs
Necessario
|
Argomenti di parole chiave aggiuntivi. Opzioni comuni:
|
Valori restituiti
| Tipo | Descrizione |
|---|---|
|
Valore restituito dall'ultima istruzione nel codice sorgente. |
Eccezioni
| Tipo | Descrizione |
|---|---|
|
Se si verifica un errore durante la generazione, l'analisi o l'analisi dell'origine OpenQASM. |
|
|
Se si verifica un errore durante la compilazione del programma. |
logical_counts
Estrae i conteggi delle risorse logiche dal codice sorgente Q#. È necessario specificare un'espressione di voce o un oggetto chiamabile con argomenti.
logical_counts(entry_expr: str | Callable | GlobalCallable | Closure, *args) -> LogicalCounts
Parametri
| Nome | Descrizione |
|---|---|
|
entry_expr
Necessario
|
Espressione di immissione. In alternativa, è possibile specificare un oggetto chiamabile, che deve essere chiamabile Q#. |
Valori restituiti
| Tipo | Descrizione |
|---|---|
|
Programmare le risorse in termini di conteggi di gate logici. |
run
Esegue l'espressione Q# specificata per il numero specificato di scatti. Ogni scatto usa un'istanza indipendente del simulatore.
run(entry_expr: str | Callable | GlobalCallable | Closure, shots: int, *args, on_result: Callable[[ShotResult], None] | None = None, save_events: bool = False, noise: Tuple[float, float, float] | PauliNoise | BitFlipNoise | PhaseFlipNoise | DepolarizingNoise | NoiseConfig | None = None, qubit_loss: float | None = None, seed: int | None = None, type: Literal['sparse', 'clifford'] | None = None, num_qubits: int | None = None) -> List[Any]
Parametri
| Nome | Descrizione |
|---|---|
|
entry_expr
Necessario
|
Espressione di immissione. In alternativa, è possibile specificare un oggetto chiamabile, che deve essere chiamabile Q#. |
|
shots
Necessario
|
Numero di colpi da eseguire. |
|
*args
Necessario
|
Argomenti da passare all'oggetto chiamabile, se disponibile. |
|
on_result
Necessario
|
Funzione di callback che verrà chiamata con ogni risultato. |
|
save_events
Necessario
|
Se true, l'output di ogni colpo verrà salvato. Se false, verranno stampate. |
|
noise
Necessario
|
Rumore da usare nella simulazione. |
|
qubit_loss
Necessario
|
Probabilità di perdita di qubit nella simulazione. |
|
seed
Necessario
|
Valore di inizializzazione da usare per il generatore di numeri casuali nella simulazione, se presente. |
|
type
Necessario
|
Tipo di simulatore da usare. Se non specificato, verrà usata la simulazione del vettore di stato sparse predefinita. |
|
num_qubits
Necessario
|
Numero di qubit da usare per il tipo di simulazione "clifford". Se non specificato, il simulatore Clifford presuppone un valore predefinito di 1000 qubit. |
Parametri di sole parole chiave
| Nome | Descrizione |
|---|---|
|
on_result
|
Valore predefinito: None
|
|
save_events
|
Valore predefinito: False
|
|
noise
|
Valore predefinito: None
|
|
qubit_loss
|
Valore predefinito: None
|
|
seed
|
Valore predefinito: None
|
|
type
|
Valore predefinito: None
|
|
num_qubits
|
Valore predefinito: None
|
Valori restituiti
| Tipo | Descrizione |
|---|---|
|
Elenco di risultati o errori di runtime. Se |
Eccezioni
| Tipo | Descrizione |
|---|---|
|
Se si verifica un errore durante l'interpretazione dell'input. |
|
|
Se il numero di colpi è minore di 1. |
set_classical_seed
Imposta il valore di inizializzazione per il generatore di numeri casuali utilizzato per le operazioni numeri casuali classiche della libreria standard. Questo vale per tutto il codice Q# eseguito, compilato o stimato in questo contesto.
set_classical_seed(seed: int | None) -> None
Parametri
| Nome | Descrizione |
|---|---|
|
seed
Necessario
|
Valore di inizializzazione da utilizzare per il generatore di numeri casuali classici. Se Nessuno, il valore di inizializzazione verrà generato dall'entropia. |
set_quantum_seed
Imposta il valore di inizializzazione per il generatore di numeri casuali usato per le misurazioni quantistiche. Questo vale per tutto il codice Q# eseguito, compilato o stimato in questo contesto.
set_quantum_seed(seed: int | None) -> None
Parametri
| Nome | Descrizione |
|---|---|
|
seed
Necessario
|
Valore di inizializzazione da usare per il generatore di numeri casuali quantistici. Se Nessuno, il valore di inizializzazione verrà generato dall'entropia. |
Attributi
code
code: Any