Klassische Ausdrücke
qiskit.circuit.classical
Dieses Modul enthält eine explorative Darstellung von Echtzeitoperationen auf klassischen Werten während der Ausführung von Schaltkreisen.
Derzeit werden nur einfache Ausdrücke mit Bits und Registern unterstützt, die einen booleschen Wert ergeben, und diese dürfen ausschließlich in den Bedingungen von QuantumCircuit.if_test() (IfElseOp) und QuantumCircuit.while_loop() (WhileLoopOp) sowie im Ziel von QuantumCircuit.switch() (SwitchCaseOp) verwendet werden.
Dies ist ein Versuchsmodul, und obwohl wir uns an die standardmäßige Qiskit-Abkündigungspolitik halten werden, sollten Sie sich darüber im Klaren sein, dass der Umfang des Moduls zu Beginn absichtlich begrenzt sein wird und frühe Versionen möglicherweise nicht sauber in die endgültige Version übergehen werden. Es ist möglich, dass verschiedene Komponenten dieses Moduls ersetzt werden (vorbehaltlich von Verwerfungen), anstatt sie in einer neuen Form zu verbessern.
Das Typsystem und der Ausdrucksbaum werden im Laufe der Zeit erweitert, und es ist möglich, dass sich die zulässigen Typen einiger Operationen zwischen den Versionen von Qiskit ändern müssen, wenn sich die klassischen Verarbeitungsmöglichkeiten weiterentwickeln.
Ausdrücke
qiskit.circuit.classical.expr
Die notwendigen Komponenten zur Erstellung von Ausdrücken werden alle aus dem expr namespace innerhalb von qiskit.circuit.classicalexportiert, so dass Sie wählen können, ob Sie den qualifizierten Zugriff verwenden (zum Beispiel expr.Value) oder die benötigten Namen direkt importieren und ohne das Präfix aufrufen.
Es gibt zwei Wege, um Ausdrücke zu konstruieren. Die Klassen, die das Ausdruckssystem repräsentieren, haben Konstruktoren, die keine Typüberprüfung durchführen; es obliegt dem Aufrufer, sicherzustellen, dass sie gültige Objekte erzeugen. Für eine benutzerfreundlichere Schnittstelle zur direkten Konstruktion gibt es Hilfsfunktionen, die mit den meisten Klassen verbunden sind und die Typüberprüfung und -inferenz durchführen. Diese werden im Folgenden unter Bauwesen beschrieben.
Darstellung
Das Ausdruckssystem basiert auf einer Baumdarstellung. Alle Knoten im Baum sind endgültige (unvererbbare) Instanzen der abstrakten Basisklasse:
Expr
class qiskit.circuit.classical.expr.Expr
Basen: object
Wurzel-Basisklasse aller Knoten im Ausdrucksbaum. Der Basisfall sollte niemals direkt instanziiert werden.
Die Unterklassen bilden die internen Daten für die Darstellung von Ausdrücken, und es ist nicht sinnvoll, weitere Unterklassen außerhalb des Qiskit-Bibliothekscodes hinzuzufügen.
__init__Alle Unterklassen sind dafür verantwortlich, ihr type Attribut in ihrer Konstruktorfunktion zu setzen, und sollten den Initialisierer der übergeordneten Klasse nicht aufrufen.
Diese Objekte sind veränderbar und sollten nicht ohne Kopie an einem anderen Ort wiederverwendet werden.
Alle Expr instanzen definieren ein boolean const Attribut, das angibt, ob der Ausdruck zur Kompilierzeit ausgewertet werden kann. Die meisten Ausdrucksklassen schließen dies während der Konstruktion auf der Grundlage der Konstante ihrer Operanden.
Die Basis für dynamische Variablen ist die Var, die entweder eine beliebig typisierte Echtzeitvariable oder ein Wrapper um eine Clbit oder ClassicalRegister.
Var.
class qiskit.circuit.classical.expr.Var(var, type, *, name=None)
Basen: Expr
Eine klassische Variable.
Diese Variablen gibt es in zwei Formen: eine Variable im neuen Stil, die ihren eigenen Speicherplatz besitzt und einen zugehörigen Namen hat, und eine Variable im alten Stil, die eine Clbit oder ClassicalRegister instanz umhüllt, die zu einer enthaltenen Schaltung gehört. Im Allgemeinen sollte die Konstruktion von Variablen zur Verwendung in Programmen mit Var.new() oder verwenden QuantumCircuit.add_var().
Variablen sind nach ihrer Erzeugung unveränderlich, sodass sie als Schlüssel in einem Wörterbuch verwendet werden können.
name
Der Name der Variablen. UUIDDies muss vorhanden sein, wenn das Attribut „backing“ var ein ist, d. h. wenn es sich um eine Variable im neuen Stil handelt, und muss sein None , wenn es sich um eine Variable im alten Stil handelt.
new
classmethod new(name, ty)
Erzeugen Sie eine neue benannte Variable, die über einen eigenen Sicherungsspeicher verfügt.
var
Ein Verweis auf den zugrunde liegenden Datenspeicher der Var Instanz. VarWenn man Instanzen des ClassicalRegister alten Typs Clbit in eine übernimmt, ist dies genau die Clbit oder ClassicalRegister. Wenn es sich bei der Variablen um eine klassische Variable neuen Typs handelt (d. h. eine, die über einen eigenen, vom alten ClassicalRegisterClbit /-Modell getrennten Speicherbereich verfügt), enthält dieses Feld einen UUID Wert, der sie eindeutig identifiziert.
In ähnlicher Weise sollten Literale, die in Ausdrücken verwendet werden (z. B. ganze Zahlen), zu Value knoten mit zugehörigen Typen überführt werden. A Value wird immer als konstanter Ausdruck betrachtet.
Wert
Streckungsvariablen zur Verwendung in Dauerausdrücken werden durch den Stretch knoten dargestellt.
Vergrößern
class qiskit.circuit.classical.expr.Stretch(var, name)
Basen: Expr
Eine Streckungsvariable.
Im Allgemeinen sollte die Konstruktion von Stretch-Variablen zur Verwendung in Programmen mit Stretch.new() oder verwenden QuantumCircuit.add_stretch()
name
Der Name der Stretch-Variable.
new
classmethod new(name)
Erzeugen Sie eine neue benannte Stretch-Variable.
var
A UUID zur eindeutigen Identifizierung dieser Strecke.
Die Operationen, die in der Programmierung traditionell mit Prä-, Post- oder Infix-Operatoren verbunden sind, werden durch die Symbole Unary und Binary knoten dargestellt. Diese nehmen jeweils einen Operationstyp-Code an, der als Aufzählungen innerhalb jeder Klasse als Unary.Op und Binary.Op offengelegt werden.
Unär
class qiskit.circuit.classical.expr.Unary(op, operand, type)
Basen: Expr
Ein unärer Ausdruck.
Parameter
- op - Der Opcode, der beschreibt, welche Operation durchgeführt wird.
- operand - Der Operand der Operation.
- type - Der aufgelöste Typ des Ergebnisses.
Operator
class Op(*values)
Basen: Enum
Aufzählung der Opcodes für unäre Operationen.
Die bitweise Negation BIT_NOT nimmt ein einzelnes Bit oder eine ganze Zahl ohne Vorzeichen mit bekannter Breite und gibt einen Wert desselben Typs zurück.
Die logische Negation LOGIC_NOT nimmt eine Eingabe, die implizit zu einem Boolean gezwungen wird, und gibt einen Boolean zurück.
Die arithmetische Negation NEGATE nimmt einen Wert vom Typ „float“ oder „Duration“ als Eingabe entgegen und gibt einen Wert desselben Typs zurück.
Binär
class qiskit.circuit.classical.expr.Binary(op, left, right, type)
Basen: Expr
Ein binärer Ausdruck.
Parameter
- op - Der Opcode, der beschreibt, welche Operation durchgeführt wird.
- left - Der linke Operand.
- right - Der rechte Operand.
- type - Der aufgelöste Typ des Ergebnisses.
Operator
class Op(*values)
Basen: Enum
Aufzählung der Opcodes für Binäroperationen.
Die bitweisen Operationen BIT_AND, BIT_OR und BIT_XOR gelten für zwei Operanden desselben Typs, der ein einzelnes Bit oder eine ganze Zahl ohne Vorzeichen mit fester Breite sein muss. Der resultierende Typ ist derselbe wie die beiden Eingabetypen.
Die logischen Operationen LOGIC_AND und LOGIC_OR wandeln ihre Argumente zunächst implizit in Boolesche Werte um und wenden dann die logische Operation an. Der Ergebnistyp ist immer Boolesch.
Die binären mathematischen Beziehungen EQUAL, NOT_EQUAL, LESS, LESS_EQUAL, GREATER und GREATER_EQUAL nehmen ganze Zahlen ohne Vorzeichen (mit einem impliziten Cast, damit sie die gleiche Breite haben) und geben einen Booleschen Wert zurück.
Die Bitshift-Operationen SHIFT_LEFT und SHIFT_RIGHT können bitähnliche Containertypen (z. B. ganze Zahlen ohne Vorzeichen) als linken Operanden und einen beliebigen Ganzzahltyp als rechten Operanden annehmen. In allen Fällen ist die Ausgangsbitbreite dieselbe wie die der Eingabe, und die "freiliegenden" Stellen werden mit Nullen aufgefüllt.
Die binären arithmetischen Operatoren ADD, SUB, MUL, und DIV können auf zwei Fließkommazahlen oder zwei vorzeichenlose Ganzzahlen angewendet werden, deren Breite bei der Erstellung durch einen Typumwandlung aneinander angepasst werden sollte. Die Operatoren ADD``DIV , SUB und können auf zwei Zeiträume angewendet werden und ergeben einen weiteren Zeitraum oder, im Falle von DIV, einen Fließkommawert. Der MUL Operator kann auch auf eine Dauer und einen numerischen Typ angewendet werden, wodurch eine weitere Dauer entsteht. Schließlich kann der DIV Operator verwendet werden, um eine Dauer durch einen numerischen Wert zu dividieren, wobei das Ergebnis eine Dauer ist.
Bit-ähnliche Typen (ganze Zahlen ohne Vorzeichen) können durch ganzzahlige Typen indiziert werden, dargestellt durch Index. Das Ergebnis ist ein einzelnes Bit. Der resultierende Ausdruck hat einen zugehörigen Speicherplatz (und kann daher als l-Wert für Storeusw. verwendet werden), wenn das Ziel ebenfalls ein l-Wert ist.
Inhalt
class qiskit.circuit.classical.expr.Index(target, index, type)
Basen: Expr
Ein Indizierungsausdruck.
Parameter
- target - Das zu indizierende Objekt.
- index - Der Ausdruck, der die Indizierung vornimmt.
- type - Der aufgelöste Typ des Ergebnisses.
Bei der Konstruktion von Ausdrücken ist darauf zu achten, dass die Typen für die Operation gültig sind. Der Versuch, Ausdrücke mit ungültigen Typen zu konstruieren, löst eine reguläre Python TypeError aus.
Die Ausdrücke in diesem System sind so definiert, dass sie nur auf bestimmte Gruppen von Typen wirken. Werte können jedoch in einen geeigneten Supertyp gecastet werden, um die Typisierungsanforderungen zu erfüllen. In diesen Fällen wird ein Knoten im Ausdrucksbaum verwendet, um die Beförderung darzustellen. In allen Fällen, in denen Operationen darauf hinweisen, dass sie ihre Argumente "implizit casten" oder "zwingen", muss der Ausdrucksbaum diesen Knoten enthalten, der die Umwandlung darstellt.
Umsetzung
class qiskit.circuit.classical.expr.Cast(operand, type, implicit=False)
Basen: Expr
Ein Cast von einem Typ zu einem anderen, der durch die Verwendung eines Ausdrucks in einem anderen Kontext impliziert wird.
Bauwesen
Die direkte Konstruktion der Baumdarstellung ist umständlich und man kann leicht einen Fehler bei der Eingabe machen. In vielen Fällen kann ein Großteil der Typisierung abgeleitet werden, skalare Werte können automatisch zu Value instanzen überführt werden, und alle erforderlichen Promotionen können in geeignete Cast knoten aufgelöst werden.
Die in diesem Abschnitt beschriebenen Funktionen und Methoden sind ein benutzerfreundlicherer Weg, um den Ausdrucksbaum zu erstellen, ohne die interne Darstellung zu verändern. Alle diese Funktionen heben automatisch gültige Python skalare Werte in entsprechende Var oder Value objekte und lösen alle erforderlichen impliziten Casts in Ihrem Namen auf. Wenn Sie einen skalaren Wert direkt als einen Expr knoten verwenden möchten, können Sie manuell lift() selbst erstellen.
lift
qiskit.circuit.classical.expr.lift(value, /, type=None)
Heben Sie die angegebene Python value auf ein Value oder Var.
Wenn eine explizite type angegeben wird, spiegelt sich das in der Ausgabe wider.
Beispiele
Einfache Schaltkreisobjekte zu Instanzen erheben Var instanzen:
>>> from qiskit.circuit import Clbit, ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.lift(Clbit())
Var(<clbit>, Bool())
>>> expr.lift(ClassicalRegister(3, "c"))
Var(ClassicalRegister(3, "c"), Uint(3))Der Typ des Rückgabewerts kann beeinflusst werden, wenn der angegebene Wert verlustfrei als der angegebene Typ interpretiert werden kann (verwenden Sie cast() , um alle Arten von Typumwandlungen durchzuführen, einschließlich solcher mit Datenverlust):
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr, types
>>> expr.lift(ClassicalRegister(3, "c"), types.Uint(5))
Var(ClassicalRegister(3, "c"), Uint(5))
>>> expr.lift(5, types.Uint(4))
Value(5, Uint(4))Parameter
Rückgabetyp
Normalerweise sollten Sie speichereigene Var instanzen erstellen, indem man die QuantumCircuit.add_var() methode, um sie in einem Schaltkreiskontext zu deklarieren, da eine QuantumCircuit nicht akzeptiert, dass eine Expr nicht akzeptiert, das Variablen enthält, die nicht bereits in ihm deklariert sind, da es wissen muss, wie der Speicher zugewiesen und die Variable initialisiert werden soll. Sollten Sie dies jedoch manuell tun wollen, sollten Sie den Low-Level Var.new() aufruf verwenden, um sicher eine benannte Variable für die Verwendung zu erzeugen.
In Fällen, in denen der Cast in expliziter Form erlaubt ist, aber verlustbehaftet sein kann (z. B. der Cast einer höheren Präzision in eine niedrigere Präzision), können Sie den Cast manuell angeben Uint in eine niedrigere Genauigkeit).
cast
qiskit.circuit.classical.expr.cast(operand, type, /)
Erzeugt einen expliziten Cast vom angegebenen Wert zum angegebenen Typ.
Beispiele
Hinzufügen eines expliziten Cast-Knotens, der explizit einen Typ mit höherer Genauigkeit in einen Typ mit niedrigerer Genauigkeit umwandelt:
>>> from qiskit.circuit.classical import expr, types
>>> value = expr.value(5, types.Uint(32))
>>> expr.cast(value, types.Uint(8))
Cast(Value(5, types.Uint(32)), types.Uint(8), implicit=False)Parameter
Rückgabetyp
Für jede der unären Operationen gibt es Hilfskonstruktorfunktionen.
bit_not
qiskit.circuit.classical.expr.bit_not(operand, /)
Erzeugt einen bitweisen 'nicht'-Ausdrucksknoten aus dem angegebenen Wert, wobei alle impliziten Zuordnungen aufgelöst werden und der Wert in einen Value knoten, falls erforderlich.
Beispiele
Bitweise Negation von a ClassicalRegister:
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.bit_not(ClassicalRegister(3, "c"))
Unary(Unary.Op.BIT_NOT, Var(ClassicalRegister(3, 'c'), Uint(3)), Uint(3))Parameter
operand (Any)
Rückgabetyp
logic_not
qiskit.circuit.classical.expr.logic_not(operand, /)
Erzeugt einen logischen 'nicht'-Ausdrucksknoten aus dem gegebenen Wert, wobei alle impliziten Übertragungen aufgelöst werden und der Wert in einen Value knoten, falls erforderlich.
Beispiele
Logische Negation von a ClassicalRegister:
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.logic_not(ClassicalRegister(3, "c"))
Unary(Unary.Op.LOGIC_NOT, Cast(Var(ClassicalRegister(3, 'c'), Uint(3)), Bool(), implicit=True), Bool())Parameter
operand (Any)
Rückgabetyp
negate
qiskit.circuit.classical.expr.negate(operand, /)
Wende auf einen Ausdrucksknoten den Negationsoperator auf den angegebenen Wert an, wobei alle impliziten Typumwandlungen aufgelöst und der Wert bei Bedarf in einen Value Knoten umgewandelt wird.
Beispiele
Negation einer Gleitkommazahl:
>>> from qiskit.circuit.classical import expr
>>> expr.negate(5.0)
Unary(Unary.Op.NEGATE, Value(5.0, Float()), Float())Verneinung einer Dauer:
>>> from qiskit.circuit import Duration
>>> from qiskit.circuit.classical import expr
>>> expr.negate(Duration.dt(1000))
Unary(Unary.Op.NEGATE, Value(Duration.dt(1000), Duration()), Duration())Parameter
operand (Any)
Rückgabetyp
Auch für die binären Operationen und Relationen sind Hilfsfunktionen definiert.
bit_and
qiskit.circuit.classical.expr.bit_and(left, right, /)
Erzeugt einen bitweisen 'und'-Ausdrucksknoten aus dem angegebenen Wert, wobei alle impliziten Übertragungen aufgelöst werden und die Werte in Value knoten, falls erforderlich.
Beispiele
Bitweises 'und' eines klassischen Registers und eines Integer-Literal:
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.bit_and(ClassicalRegister(3, "c"), 0b111)
Binary(Binary.Op.BIT_AND, Var(ClassicalRegister(3, 'c'), Uint(3)), Value(7, Uint(3)), Uint(3))Parameter
Rückgabetyp
bit_or
qiskit.circuit.classical.expr.bit_or(left, right, /)
Erzeugt einen bitweisen 'oder'-Ausdrucksknoten aus dem angegebenen Wert, wobei alle impliziten Übertragungen aufgelöst werden und die Werte in Value knoten, falls erforderlich.
Beispiele
Bitweises 'oder' eines klassischen Registers und eines Integer-Literal:
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.bit_or(ClassicalRegister(3, "c"), 0b101)
Binary(Binary.Op.BIT_OR, Var(ClassicalRegister(3, 'c'), Uint(3)), Value(5, Uint(3)), Uint(3))Parameter
Rückgabetyp
bit_xor
qiskit.circuit.classical.expr.bit_xor(left, right, /)
Erzeugt einen bitweisen 'exklusiven oder'-Ausdrucksknoten aus dem angegebenen Wert, wobei alle impliziten Übertragungen aufgelöst und die Werte in Value knoten, falls erforderlich.
Beispiele
Bitweises 'exklusives Oder' eines klassischen Registers und eines Integer-Literal:
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.bit_xor(ClassicalRegister(3, "c"), 0b101)
Binary(Binary.Op.BIT_XOR, Var(ClassicalRegister(3, 'c'), Uint(3)), Value(5, Uint(3)), Uint(3))Parameter
Rückgabetyp
logic_and
qiskit.circuit.classical.expr.logic_and(left, right, /)
Erzeugt einen logischen 'und'-Ausdrucksknoten aus dem angegebenen Wert, wobei alle impliziten Übertragungen aufgelöst werden und die Werte in Value knoten, falls erforderlich.
Beispiele
Logisches 'und' von zwei klassischen Bits:
>>> from qiskit.circuit import Clbit
>>> from qiskit.circuit.classical import expr
>>> expr.logic_and(Clbit(), Clbit())
Binary(Binary.Op.LOGIC_AND, Var(<clbit 0>, Bool()), Var(<clbit 1>, Bool()), Bool())Parameter
Rückgabetyp
logic_or
qiskit.circuit.classical.expr.logic_or(left, right, /)
Erzeugt einen logischen 'oder'-Ausdrucksknoten aus dem angegebenen Wert, wobei alle impliziten Zuordnungen aufgelöst und die Werte in Value knoten, falls erforderlich.
Beispiele
Logisches 'oder' von zwei klassischen Bits
>>> from qiskit.circuit import Clbit
>>> from qiskit.circuit.classical import expr
>>> expr.logic_or(Clbit(), Clbit())
Binary(Binary.Op.LOGIC_OR, Var(<clbit 0>, Bool()), Var(<clbit 1>, Bool()), Bool())Parameter
Rückgabetyp
equal
qiskit.circuit.classical.expr.equal(left, right, /)
Erzeugt einen 'equal'-Ausdrucksknoten aus dem gegebenen Wert, löst alle impliziten Übertragungen auf und hebt die Werte in Value knoten, falls erforderlich.
Beispiele
Gleichheit zwischen einem klassischen Register und einer Ganzzahl:
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.equal(ClassicalRegister(3, "c"), 7)
Binary(Binary.Op.EQUAL, Var(ClassicalRegister(3, "c"), Uint(3)), Value(7, Uint(3)), Uint(3))Parameter
Rückgabetyp
not_equal
qiskit.circuit.classical.expr.not_equal(left, right, /)
Erzeugt einen 'nicht gleich'-Ausdrucksknoten aus dem gegebenen Wert, löst alle impliziten Übertragungen auf und hebt die Werte in Value knoten, falls erforderlich.
Beispiele
Ungleichheit zwischen einem klassischen Register und einer Ganzzahl:
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.not_equal(ClassicalRegister(3, "c"), 7)
Binary(Binary.Op.NOT_EQUAL, Var(ClassicalRegister(3, "c"), Uint(3)), Value(7, Uint(3)), Uint(3))Parameter
Rückgabetyp
less
qiskit.circuit.classical.expr.less(left, right, /)
Erzeugt einen "kleiner als"-Ausdrucksknoten aus dem angegebenen Wert, wobei alle impliziten Übertragungen aufgelöst und die Werte in Value knoten, falls erforderlich.
Beispiele
Abfrage, ob ein klassisches Register kleiner als eine ganze Zahl ist:
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.less(ClassicalRegister(3, "c"), 5)
Binary(Binary.Op.LESS, Var(ClassicalRegister(3, "c"), Uint(3)), Value(5, Uint(3)), Uint(3))Parameter
Rückgabetyp
less_equal
qiskit.circuit.classical.expr.less_equal(left, right, /)
Erzeugt einen "kleiner gleich"-Ausdrucksknoten aus dem angegebenen Wert, wobei alle impliziten Übertragungen aufgelöst werden und die Werte in Value knoten, falls erforderlich.
Beispiele
Abfrage, ob ein klassisches Register kleiner oder gleich einem anderen ist:
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.less_equal(ClassicalRegister(3, "a"), ClassicalRegister(3, "b"))
Binary(Binary.Op.LESS_EQUAL, Var(ClassicalRegister(3, "a"), Uint(3)), Var(ClassicalRegister(3, "b"), Uint(3)), Uint(3))Parameter
Rückgabetyp
greater
qiskit.circuit.classical.expr.greater(left, right, /)
Erzeugt einen "Größer als"-Ausdrucksknoten aus dem angegebenen Wert, wobei alle impliziten Übertragungen aufgelöst werden und die Werte in Value knoten, falls erforderlich.
Beispiele
Abfrage, ob ein klassisches Register größer als eine ganze Zahl ist:
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.greater(ClassicalRegister(3, "c"), 5)
Binary(Binary.Op.GREATER, Var(ClassicalRegister(3, "c"), Uint(3)), Value(5, Uint(3)), Uint(3))Parameter
Rückgabetyp
greater_equal
qiskit.circuit.classical.expr.greater_equal(left, right, /)
Erzeugt einen 'größer als oder gleich'-Ausdrucksknoten aus dem angegebenen Wert, wobei alle impliziten Übertragungen aufgelöst und die Werte in Value knoten, falls erforderlich.
Beispiele
Abfrage, ob ein klassisches Register größer oder gleich einem anderen ist:
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.greater_equal(ClassicalRegister(3, "a"), ClassicalRegister(3, "b"))
Binary(Binary.Op.GREATER_EQUAL, Var(ClassicalRegister(3, "a"), Uint(3)), Var(ClassicalRegister(3, "b"), Uint(3)), Uint(3))Parameter
Rückgabetyp
shift_left
qiskit.circuit.classical.expr.shift_left(left, right, /, type=None)
Erzeugt einen 'bitshift left'-Ausdrucksknoten aus den beiden angegebenen Werten, wobei alle impliziten Übertragungen aufgelöst und die Werte in Value knoten, falls erforderlich.
Wenn type angegeben wird, wird der left -Operand zu diesem gezwungen (wenn möglich).
Beispiele
Verschiebt den Wert einer eigenständigen Variablen um einen bestimmten Betrag nach links:
>>> from qiskit.circuit.classical import expr, types
>>> a = expr.Var.new("a", types.Uint(8))
>>> expr.shift_left(a, 4)
Binary(Binary.Op.SHIFT_LEFT, Var(<UUID>, Uint(8), name='a'), Value(4, Uint(3)), Uint(8))Verschiebt ein Integer-Literal um einen variablen Betrag, wobei der Typ des Literals erzwungen wird:
>>> expr.shift_left(3, a, types.Uint(16))
Binary(Binary.Op.SHIFT_LEFT, Value(3, Uint(16)), Var(<UUID>, Uint(8), name='a'), Uint(16))Parameter
Rückgabetyp
shift_right
qiskit.circuit.classical.expr.shift_right(left, right, /, type=None)
Erzeugt einen 'bitshift right'-Ausdrucksknoten aus den gegebenen Werten, löst alle impliziten Casts auf und hebt die Werte in Value knoten, falls erforderlich.
Wenn type angegeben wird, wird der left -Operand zu diesem gezwungen (wenn möglich).
Beispiele
Verschiebt den Wert eines klassischen Registers um einen bestimmten Betrag nach rechts:
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.shift_right(ClassicalRegister(8, "a"), 4)
Binary(Binary.Op.SHIFT_RIGHT, Var(ClassicalRegister(8, "a"), Uint(8)), Value(4, Uint(3)), Uint(8))Parameter
Rückgabetyp
add
qiskit.circuit.classical.expr.add(left, right, /)
Erzeugt einen Additionsausdrucksknoten aus den angegebenen Werten, wobei alle impliziten Übertragungen aufgelöst und die Werte in Value knoten, falls erforderlich.
Beispiele
Addition von zwei Fließkommazahlen:
>>> from qiskit.circuit.classical import expr
>>> expr.add(5.0, 2.0)
Binary(Binary.Op.ADD, Value(5.0, Float()), Value(2.0, Float()), Float())Addition von zwei Laufzeiten:
>>> from qiskit.circuit import Duration
>>> from qiskit.circuit.classical import expr
>>> expr.add(Duration.dt(1000), Duration.dt(1000))
Binary(Binary.Op.ADD, Value(Duration.dt(1000), Duration()), Value(Duration.dt(1000), Duration()), Duration())Parameter
Rückgabetyp
sub
qiskit.circuit.classical.expr.sub(left, right, /)
Erzeugt einen Subtraktionsausdrucksknoten aus den gegebenen Werten, wobei alle impliziten Übertragungen aufgelöst werden und die Werte in Value knoten, falls erforderlich.
Beispiele
Subtraktion von zwei Fließkommazahlen:
>>> from qiskit.circuit.classical import expr
>>> expr.sub(5.0, 2.0)
Binary(Binary.Op.SUB, Value(5.0, Float()), Value(2.0, Float()), Float())Subtraktion von zwei Dauern:
>>> from qiskit.circuit import Duration
>>> from qiskit.circuit.classical import expr
>>> expr.add(Duration.dt(1000), Duration.dt(1000))
Binary(Binary.Op.SUB, Value(Duration.dt(1000), Duration()), Value(Duration.dt(1000), Duration()), Duration())Parameter
Rückgabetyp
mul
qiskit.circuit.classical.expr.mul(left, right)
Erstellt einen Multiplikationsausdrucksknoten aus den gegebenen Werten, wobei alle impliziten Übertragungen aufgelöst und die Werte in Value knoten, falls erforderlich.
Damit können numerische Operanden des gleichen Typs multipliziert werden oder ein Daueroperand mit einem numerischen Operanden multipliziert werden.
Beispiele
Multiplikation von zwei Fließkommazahlen:
>>> from qiskit.circuit.classical import expr
>>> expr.mul(5.0, 2.0)
Binary(Binary.Op.MUL, Value(5.0, Float()), Value(2.0, Float()), Float())Multiplikation einer Dauer mit einem Float:
>>> from qiskit.circuit import Duration
>>> from qiskit.circuit.classical import expr
>>> expr.mul(Duration.dt(1000), 0.5)
Binary(Binary.Op.MUL, Value(Duration.dt(1000), Duration()), Value(0.5, Float()), Duration())Parameter
Rückgabetyp
div
qiskit.circuit.classical.expr.div(left, right)
Erzeugt einen Divisionsausdrucksknoten aus den angegebenen Werten, wobei alle impliziten Übertragungen aufgelöst und die Werte in Value knoten, falls erforderlich.
Dies kann verwendet werden, um numerische Operanden des gleichen Typs zu dividieren, um einen Duration operanden durch einen numerischen Operanden oder zur Division von zwei Duration operanden, die einen Ausdruck des Typs Float.
Beispiele
Division von zwei Fließkommazahlen:
>>> from qiskit.circuit.classical import expr
>>> expr.div(5.0, 2.0)
Binary(Binary.Op.DIV, Value(5.0, Float()), Value(2.0, Float()), Float())Teilung von zwei Zeiträumen:
>>> from qiskit.circuit import Duration
>>> from qiskit.circuit.classical import expr
>>> expr.div(Duration.dt(10000), Duration.dt(1000))
Binary(Binary.Op.DIV, Value(Duration.dt(10000), Duration()), Value(Duration.dt(1000), Duration()), Float())Division einer Dauer durch einen Float:
>>> from qiskit.circuit import Duration
>>> from qiskit.circuit.classical import expr
>>> expr.div(Duration.dt(10000), 12.0)
Binary(Binary.Op.DIV, Value(Duration.dt(10000), Duration()), Value(12.0, types.Float()), Duration())Parameter
Rückgabetyp
Sie können in vorzeichenlosen Ganzzahlen und Bit-ähnlichen Werten mit einer anderen vorzeichenlosen Ganzzahl beliebiger Breite indizieren. Dies gilt auch für Speicheroperationen, wenn das Ziel des Indexes beschreibbar ist.
index
qiskit.circuit.classical.expr.index(target, index, /)
Index in die target mit der angegebenen Ganzzahl index, wobei die Werte in Value knoten, falls erforderlich.
Dieser kann als Ziel von a verwendet werden Storeverwendet werden, wenn die target selbst ein l-Wert ist.
Beispiele
Index in ein klassisches Register mit einem Literal:
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.index(ClassicalRegister(8, "a"), 3)
Index(Var(ClassicalRegister(8, "a"), Uint(8)), Value(3, Uint(2)), Bool())Parameter
Rückgabetyp
Die herkömmliche Methode von Qiskit zur Angabe von Gleichheitsbedingungen für die Verwendung in Konditionalen ist die Verwendung eines Zwei-Tupels aus einem Clbit oder ClassicalRegister und einer Ganzzahl. Dies stellt eine exakte Gleichheitsbedingung dar, und es gibt keine Möglichkeit, andere Beziehungen anzugeben. Die Hilfsfunktion lift_legacy_condition() wandelt dieses alte Format in die neue Ausdruckssyntax um.
lift_legacy_condition
qiskit.circuit.classical.expr.lift_legacy_condition(condition, /)
Eine alte Zwei-Tupel-Gleichheitsbedingung in eine neue Form umwandeln Expr.
Parameter
condition (tuple[qiskit.circuit.Clbit |qiskit.circuit.ClassicalRegister, int])
Rückgabetyp
Arbeiten mit dem Ausdrucksbaum
Ein typischer Nutzer des Ausdrucksbaums möchte den Baum rekursiv durchlaufen, möglicherweise mit einem Zustand, der sich je nach Typ auf jeden Knoten anders auswirkt. Dies ist natürlich ein doppeltes Problem: Die Logik dessen, "was zu tun ist", ist wahrscheinlich zustandsabhängig, und die Benutzer sollten die Freiheit haben, ihre eigenen Operationen zu definieren, aber jeder Knoten definiert, "was getan wird". Wir ermöglichen diese doppelte Abfertigung, indem wir eine Basis-Besucherklasse für den Ausdrucksbaum bereitstellen.
ExprVisitor
class qiskit.circuit.classical.expr.ExprVisitor
Basen: Generic[_T_co]
Basisklasse für Besucher des Expr baum. Unterklassen sollten die Methoden von visit_* überschreiben, die sie beherrschen, und sollten so organisiert sein, dass nicht existierende Methoden niemals aufgerufen werden.
visit_binary
visit_cast
visit_generic
visit_index
visit_stretch
visit_unary
visit_value
visit_var
Verbraucher des Ausdrucksbaums sollten den Besucher als Unterklasse einordnen und die Methoden von visit_* , die sie behandeln wollen, überschreiben. Alle Methoden, die nicht überschrieben werden, rufen visit_generic()auf, die, sofern sie nicht überschrieben wird, eine RuntimeError auslöst, um sicherzustellen, dass Sie wissen, ob dem Ausdrucksbaum neue Knoten hinzugefügt wurden, die Sie noch nicht bearbeiten.
Für die Bequemlichkeit einfacher Besucher, die nur die Variablen in einem Ausdruck und nicht die allgemeine Struktur untersuchen müssen, wird die Iteratormethode iter_vars() zur Verfügung gestellt.
iter_vars
qiskit.circuit.classical.expr.iter_vars(node)
Ermittelt einen Iterator über die Var knoten, auf die auf einer beliebigen Ebene in der angegebenen Expr.
Beispiele
Drucken Sie den Namen jedes ClassicalRegister begegneten:
from qiskit.circuit import ClassicalRegister
from qiskit.circuit.classical import expr
cr1 = ClassicalRegister(3, "a")
cr2 = ClassicalRegister(3, "b")
for node in expr.iter_vars(expr.bit_and(expr.bit_not(cr1), cr2)):
if isinstance(node.var, ClassicalRegister):
print(node.var.name)Parameter
node (Expr)
Rückgabetyp
Zur Iteration über alle Variablen, einschließlich der Streckungsvariablen, steht die Iterator-Methode iter_identifiers() zur Verfügung.
iter_identifiers
qiskit.circuit.classical.expr.iter_identifiers(node)
Holt einen Iterator über die Var und Stretch knoten, auf die auf einer beliebigen Ebene in der angegebenen Expr.
Beispiele
Drucken Sie den Namen jedes ClassicalRegister begegneten:
from qiskit.circuit import ClassicalRegister
from qiskit.circuit.classical import expr
cr1 = ClassicalRegister(3, "a")
cr2 = ClassicalRegister(3, "b")
for node in expr.iter_vars(expr.bit_and(expr.bit_not(cr1), cr2)):
if isinstance(node.var, ClassicalRegister):
print(node.var.name)Holt einen Iterator über nur die Var knoten des Ausdrucks.
Parameter
node (Expr)
Rückgabetyp
Zwei Ausdrücke können mit Hilfe des eingebauten Python == Operators auf direkte strukturelle Gleichheit verglichen werden. Im Allgemeinen sollte man jedoch zwei Ausdrücke etwas semantischer vergleichen, indem man zulässt, dass die Var knoten in ihnen an unterschiedliche Speicherplatzbeschreibungen zwischen zwei verschiedenen Schaltkreisen gebunden sind. In diesem Fall kann man mit structurally_equivalent() mit zwei geeigneten "Schlüssel"-Funktionen verwenden, um den Vergleich durchzuführen.
structurally_equivalent
qiskit.circuit.classical.expr.structurally_equivalent(left, right, left_var_key=None, right_var_key=None)
Haben diese beiden Ausdrücke genau die gleiche Baumstruktur, bis hin zu einer Schlüsselfunktion für die Var objekte?
Mit anderen Worten, es handelt sich bei diesen beiden Ausdrücken um genau dieselben Bäume, außer dass wir die Var.var felder vergleichen, indem wir die entsprechende Funktion *_var_key aufrufen und die Ausgabe auf Gleichheit überprüfen. Diese Funktion lässt keine semantischen "Äquivalenzen" zu, wie z. B. die Behauptung, dass a == b äquivalent zu b == a ist; die Auswertungsreihenfolge der Operanden könnte im Allgemeinen dazu führen, dass eine solche Aussage falsch ist (man denke an hypothetische extern Funktionen, die auf den globalen Zustand zugreifen).
Es gibt keine Anforderungen an die Schlüsselfunktionen, außer dass ihre Ausgaben allgemeine __eq__ Methoden haben sollten. Wenn eine Tastenfunktion None zurückgibt, wird stattdessen die Variable wortwörtlich verwendet.
Parameter
- left (Expr) – einer der
ExprKnoten. - right (Expr) – der andere
ExprKnoten. - left_var_key (Callable[[Any], Any] | None) – eine Callable, deren Ausgabe beim Vergleich von
Var.varattributen verwendet werden soll. Wenn dieses ArgumentNoneist oder seine AusgabeNonefür eine bestimmte Variable inleftist, wird die Variable wortwörtlich verwendet. - right_var_key (Callable[[Any], Any] | None) – wie
left_var_key, wird jedoch auf die Variablen inrightangewendet.
Rückgabetyp
Beispiele
Vergleich von zwei Ausdrücken auf strukturelle Äquivalenz, ohne Neuzuordnung der Variablen. Diese sind unterschiedlich, weil die verschiedenen Clbit instanzen unterschiedlich vergleichen:
>>> from qiskit.circuit import Clbit
>>> from qiskit.circuit.classical import expr
>>> left_bits = [Clbit(), Clbit()]
>>> right_bits = [Clbit(), Clbit()]
>>> left = expr.logic_and(expr.logic_not(left_bits[0]), left_bits[1])
>>> right = expr.logic_and(expr.logic_not(right_bits[0]), right_bits[1])
>>> expr.structurally_equivalent(left, right)
FalseVergleich der beiden gleichen Ausdrücke, aber diesmal unter Verwendung von Mapping-Funktionen, die die Bits mit einfachen Indizes verknüpfen:
>>> left_key = {var: i for i, var in enumerate(left_bits)}.get
>>> right_key = {var: i for i, var in enumerate(right_bits)}.get
>>> expr.structurally_equivalent(left, right, left_key, right_key)
TrueEinige Ausdrücke sind mit Speicherplätzen verknüpft, andere wiederum sind nur vorübergehend. Sie können mit is_lvalue() können Sie feststellen, ob ein Ausdruck einen zugehörigen Speicherplatz hat.
is_lvalue
qiskit.circuit.classical.expr.is_lvalue(node, /)
Gibt zurück, ob dieser Ausdruck in l-Wert-Positionen verwendet werden kann, d.h. ob er einen wohldefinierten Speicherplatz hat, der z.B. beschreibbar ist.
Dass es sich um einen L-Wert handelt, ist zwar eine notwendige, aber keine hinreichende Voraussetzung dafür, dass dieser Speicherplatz beschreibbar ist; es ist möglich, dass ein übergeordneter Objekt, das diesen Speicherplatz enthält, das Schreiben aus dem Bereich, der den Schreibvorgang versucht, nicht zulässt. Dies wäre jedoch eine Zugriffseigenschaft des übergeordneten Programms und keine inhärente Eigenschaft des Ausdruckssystems.
Ein konstanter Ausdruck ist niemals ein l-Wert.
Beispiele
Literalwerte sind nie l-Werte; es gibt keinen Speicherplatz, der (zum Beispiel) mit der Konstante 1 verbunden ist:
>>> from qiskit.circuit.classical import expr
>>> expr.is_lvalue(expr.lift(2))
FalseVar knoten sind immer l-Werte, da sie immer einen zugehörigen Speicherplatz haben:
>>> from qiskit.circuit.classical import types
>>> from qiskit.circuit import Clbit
>>> expr.is_lvalue(expr.Var.new("a", types.Bool()))
True
>>> expr.is_lvalue(expr.lift(Clbit()))
TrueDerzeit gibt es keine unären oder binären Operationen auf Variablen, die einen l-Wert-Ausdruck erzeugen können, aber es ist wahrscheinlich, dass in Zukunft eine Art von "Indexierungs"-Operation hinzugefügt wird, die l-Werte erzeugen könnte:
>>> a = expr.Var.new("a", types.Uint(8))
>>> b = expr.Var.new("b", types.Uint(8))
>>> expr.is_lvalue(a) and expr.is_lvalue(b)
True
>>> expr.is_lvalue(expr.bit_and(a, b))
FalseParameter
node (Expr)
Rückgabetyp
typing
qiskit.circuit.classical.types
Darstellung
Das Typsystem des Ausdrucksbaums wird durch diesen Baustein offengelegt. Dies ist von Natur aus mit dem Ausdruckssystem im expr modul verbunden, da die meisten Ausdrücke nur im Zusammenhang mit den Typen verstanden werden können, auf die sie wirken.
Alle Typen erben von einer abstrakten Basisklasse:
Typ
class qiskit.circuit.classical.types.Type
Basen: object
Wurzelbasisklasse aller Knoten im Typbaum. Der Basisfall sollte niemals direkt instanziiert werden.
Die Unterklassen bilden die internen Daten für die Darstellung von Ausdrücken, und es ist nicht sinnvoll, weitere Unterklassen außerhalb des Qiskit-Bibliothekscodes hinzuzufügen.
Typen sollten als unveränderliche Objekte betrachtet werden, die nicht verändert werden dürfen. Es ist zulässig, ein Type wiederzuverwenden, das Sie von einem anderen Objekt übernommen haben, ohne es zu kopieren, und im Allgemeinen ist dies auch der beste Ansatz für die Leistung. Type objekte sind als kleine Datenmengen konzipiert, und es ist am besten, auf dieselbe Instanz der Daten zu verweisen, wenn dies möglich ist, anstatt eine neue Version desselben Objekts auf dem Heap zuzuweisen. Wenn möglich, geben die Klassenkonstruktoren Singleton-Instanzen zurück, um dies zu erleichtern.
Der Bool typ repräsentiert Clbit und die Literale True und False, der Uint typ repräsentiert ClassicalRegister und Python Ganzzahlen, der Typ Float typ repräsentiert Python Floats, und der Duration typ repräsentiert eine Dauer für die Verwendung in zeitabhängigen Schaltkreisoperationen.
Boolesch
class qiskit.circuit.classical.types.Bool
Basen: Type
Der boolesche Typ. Dieser hat genau zwei Werte: True und False.
Uint
class qiskit.circuit.classical.types.Uint(width)
Basen: Type
Eine Ganzzahl ohne Vorzeichen mit fester Bitbreite.
Gleitkommazahl
class qiskit.circuit.classical.types.Float
Basen: Type
Eine IEEE-754 doppelpräzise Gleitkommazahl.
Künftig kann dies auch zur Darstellung anderer Floats mit fester Breite verwendet werden.
Dauer
Arbeiten mit Typen
In den folgenden Abschnitten sind einige zusätzliche Funktionen zu diesen Typen dokumentiert. Es wird erwartet, dass diese nur bei Manipulationen des Ausdrucksbaums verwendet werden; Benutzer, die Ausdrücke über die benutzerorientierte Konstruktionsschnittstelle erstellen, sollten diese nicht verwenden müssen.
Teilordnung von Typen
Das Typsystem ist mit einer partiellen Ordnung ausgestattet, wobei als " ist ein strikter Subtyp von " interpretiert wird. Beachten Sie, dass die partielle Ordnung eine Teilmenge des gerichteten Graphen ist, der die zulässigen expliziten Gussoperationen zwischen Typen beschreibt. Die partielle Ordnung legt fest, wann ein Typ verlustfrei direkt als ein anderer interpretiert werden kann.
Die Low-Level-Schnittstelle zur Abfrage der Subtypisierungsbeziehung ist die order() funktion.
order
qiskit.circuit.classical.types.order(left, right, /)
Ermittelt die Ordnungsbeziehung zwischen den beiden Typen als Aufzählungswert.
Beispiele
Vergleichen Sie zwei Uint typen mit unterschiedlicher Breite:
>>> from qiskit.circuit.classical import types
>>> types.order(types.Uint(8), types.Uint(16))
Ordering.LESSVergleichen Sie zwei Typen, zwischen denen keine Reihenfolge besteht:
>>> types.order(types.Uint(8), types.Bool())
Ordering.NONEParameter
Rückgabetyp
Der Rückgabewert ist eine Aufzählung Ordering die beschreibt, welche Subtypisierungsbeziehung, wenn überhaupt, zwischen den beiden Typen besteht.
Reihenfolge
class qiskit.circuit.classical.types.Ordering(*values)
Basen: Enum
Aufzählung, die die möglichen Beziehungen zwischen zwei Typen auflistet. Typen haben nur eine partielle Ordnung, so dass es möglich ist, dass zwei Typen keine Untertypisierungsbeziehung haben.
Beachten Sie, dass die Sub-/Supertyp-Beziehung nicht dasselbe ist wie die Frage, ob ein Typ explizit von einem in einen anderen gecastet werden kann.
Einige Hilfsmethoden werden dann in Bezug auf dieses Low-Level order() primitivs definiert:
is_subtype
qiskit.circuit.classical.types.is_subtype(left, right, /, strict=False)
Gilt die Beziehung ? Wenn es keine Ordnungsbeziehung zwischen den beiden Typen gibt, dann wird False zurückgegeben. Wenn strict, dann ist auch die Gleichheit verboten.
Beispiele
Prüfen, ob ein Typ eine Unterklasse eines anderen ist:
>>> from qiskit.circuit.classical import types
>>> types.is_subtype(types.Uint(8), types.Uint(16))
TruePrüfen, ob ein Typ eine strikte Unterklasse eines anderen ist:
>>> types.is_subtype(types.Bool(), types.Bool())
True
>>> types.is_subtype(types.Bool(), types.Bool(), strict=True)
FalseParameter
Rückgabetyp
is_supertype
qiskit.circuit.classical.types.is_supertype(left, right, /, strict=False)
Gilt die Beziehung ? Wenn es keine Ordnungsbeziehung zwischen den beiden Typen gibt, dann wird False zurückgegeben. Wenn strict, dann ist auch die Gleichheit verboten.
Beispiele
Prüfen, ob ein Typ eine Oberklasse eines anderen ist:
>>> from qiskit.circuit.classical import types
>>> types.is_supertype(types.Uint(8), types.Uint(16))
FalsePrüfen, ob ein Typ eine strenge Oberklasse eines anderen ist:
>>> types.is_supertype(types.Bool(), types.Bool())
True
>>> types.is_supertype(types.Bool(), types.Bool(), strict=True)
FalseParameter
Rückgabetyp
greater
qiskit.circuit.classical.types.greater(left, right, /)
Ermitteln Sie den größeren der beiden Typen, vorausgesetzt, es besteht eine Ordnungsbeziehung zwischen ihnen. Technisch gesehen handelt es sich dabei um eine leicht eingeschränkte Version des Konzepts der "Begegnung" der beiden Typen, da der Rückgabewert einer der Eingänge sein muss. In der Praxis gibt es im Typensystem kein Konzept eines "Summen"-Typs, so dass das "meet" nur dann existiert, wenn es eine Ordnung zwischen den beiden Typen gibt, und gleich dem größeren der beiden Typen ist.
Rückgabe
Der größere der beiden Typen.
Erhöht
TypeError - wenn es keine Ordnungsbeziehung zwischen den beiden Typen gibt.
Parameter
Rückgabetyp
Beispiele
Finden Sie den größeren von zwei Uint typen:
>>> from qiskit.circuit.classical import types
>>> types.greater(types.Uint(8), types.Uint(16))
types.Uint(16)Umwandlung zwischen Typen
Es kommt häufig vor, dass man Werte eines Typs in einen anderen Typ umwandeln muss. Die Gießregeln dafür sind in das types modul eingebettet. Sie können die Gussarten abfragen mit cast_kind():
cast_kind
qiskit.circuit.classical.types.cast_kind(from_, to_, /)
Bestimmen Sie die Art der Besetzung, die erforderlich ist, um vom linken Typ zum rechten Typ zu wechseln.
Beispiele
>>> from qiskit.circuit.classical import types
>>> types.cast_kind(types.Bool(), types.Bool())
<CastKind.EQUAL: 1>
>>> types.cast_kind(types.Uint(8), types.Bool())
<CastKind.IMPLICIT: 2>
>>> types.cast_kind(types.Bool(), types.Uint(8))
<CastKind.LOSSLESS: 3>
>>> types.cast_kind(types.Uint(16), types.Uint(8))
<CastKind.DANGEROUS: 4>Parameter
Rückgabetyp
Die Rückgabewerte dieser Funktion sind eine Aufzählung, die erklärt, welche Arten von Casts vom linken Typ zum rechten Typ zulässig sind.
Beachten Sie, dass Würfe zwischen Float und Uint in beiden Richtungen als gefährlich gelten und explizit durchgeführt werden müssen.