Sync docs for SDK version 0.95.0

Author: classiq-library-bot-app[bot]

.internal/docs/qmod-reference/language-reference/classical-types.md

@@ -21,13 +21,6 @@ In Qmod, scalar types represent numeric values, Boolean values, and Pauli base e
 
 ### Syntax
 
-=== "Native"
-
-    - `int` represents integers
-    - `real` represents real numbers (using floating point encoding)
-    - `bool` represents the Boolean values `false` and `true`
-    - `Pauli` represents the Pauli base elements using the symbols `Pauli::I`, `Pauli::X`, `Pauli::Y`, and `Pauli::Z` (with the integer values 0, 1, 2, 3 respectively)
-
 === "Python"
 
     Python Classes are used to represent scalar types
@@ -37,22 +30,29 @@ In Qmod, scalar types represent numeric values, Boolean values, and Pauli base e
     - `CBool` represents the Boolean values `False` and `True`
     - `Pauli` represents the Pauli base elements using the symbols `Pauli.I`, `Pauli.X`, `Pauli.Y`, and `Pauli.Z` (with the integer values 0, 1, 2, 3 respectively)
 
+=== "Native"
+
+    - `int` represents integers
+    - `real` represents real numbers (using floating point encoding)
+    - `bool` represents the Boolean values `false` and `true`
+    - `Pauli` represents the Pauli base elements using the symbols `Pauli::I`, `Pauli::X`, `Pauli::Y`, and `Pauli::Z` (with the integer values 0, 1, 2, 3 respectively)
+
 ## Arrays
 
 Arrays are homogenous collections of scalars or structs with random access.
 
 ### Syntax
 
-=== "Native"
-
-    Array types have the form - _element-type_ **[** [ _length_expression_ ] **]**
-
 === "Python"
 
     Array types are represented with the generic class `CArray`. Arguments are declared with the type hint in the form:
 
     _name_ **:** **CArray** [ **[** _element-type_ [ **,** _length_expression_ ] **]** ]
 
+=== "Native"
+
+    Array types have the form - _element-type_ **[** [ _length_expression_ ] **]**
+
 ### Semantics
 
 _element-type_ is any scalar, array, or struct type.
@@ -75,6 +75,24 @@ takes an array of reals, and uses the `.len` attribute and array subscripting to
 the elements of the array. Note that index -1 signifies the last element in an array
 (similar to Python).
 
+=== "Python"
+
+    ```python
+    from classiq import qfunc, CArray, CReal, QBit, RX, allocate, if_
+
+
+    @qfunc
+    def foo(arr: CArray[CReal], qb: QBit) -> None:
+        if_(arr.len > 2, lambda: RX(arr[-1], qb), lambda: RX(arr[0], qb))
+
+
+    @qfunc
+    def main() -> None:
+        q0 = QBit()
+        allocate(q0)
+        foo([0.5, 1.0, 1.5], q0)
+    ```
+
 === "Native"
 
     ```
@@ -93,27 +111,17 @@ the elements of the array. Note that index -1 signifies the last element in an a
     }
     ```
 
-=== "Python"
-
-    ```python
-    from classiq import qfunc, CArray, CReal, QBit, RX, allocate, if_
-
-
-    @qfunc
-    def foo(arr: CArray[CReal], qb: QBit) -> None:
-        if_(arr.len > 2, lambda: RX(arr[-1], qb), lambda: RX(arr[0], qb))
+## Structs
 
+Structs are aggregates of variables, called _fields_, each with its own name and type.
 
-    @qfunc
-    def main() -> None:
-        q0 = QBit()
-        allocate(q0)
-        foo([0.5, 1.0, 1.5], q0)
-    ```
+=== "Python"
 
-## Structs
+    A Qmod classical struct is defined with a Python data class: A class decorated with
+    `@dataclasses.dataclass`.
 
-Structs are aggregates of variables, called _fields_, each with its own name and type.
+    Fields need to be declared with type-hints like classical arguments of functions.
+    Fields are initialized and accessed like attributes of Python object.
 
 === "Native"
 
@@ -126,45 +134,12 @@ Structs are aggregates of variables, called _fields_, each with its own name and
     _field-value-list_ is a list of zero or more comma-separated field initializations in the form -
     _name_ **=** _expression_.
 
-=== "Python"
-
-    A Qmod classical struct is defined with a Python data class: A class decorated with
-    `@dataclasses.dataclass`.
-
-    Fields need to be declared with type-hints like classical arguments of functions.
-    Fields are initialized and accessed like attributes of Python object.
-
 ### Example
 
 In the following example a struct type called `MyStruct` is defined. Function `foo`
 takes an argument of this type and accesses its fields. Function `main` instantiates
 and populates `MyStruct` in its call to `foo`.
 
-=== "Native"
-
-    ```
-    struct MyStruct {
-      loop_counts: int[];
-      angle: real;
-    }
-
-    qfunc foo(ms: MyStruct, qv: qbit[2]) {
-      H(qv[0]);
-      repeat (index: ms.loop_counts[1]) {
-        PHASE(ms.angle + 0.5, qv[1]);
-      }
-    }
-
-    qfunc main() {
-      qba: qbit[];
-      allocate(2, qba);
-      foo(MyStruct {
-        loop_counts = [1, 2],
-        angle = 0.1
-      }, qba);
-    }
-    ```
-
 === "Python"
 
     ```python
@@ -194,6 +169,31 @@ and populates `MyStruct` in its call to `foo`.
         foo(MyStruct(loop_counts=[1, 2], angle=0.1), qba)
     ```
 
+=== "Native"
+
+    ```
+    struct MyStruct {
+      loop_counts: int[];
+      angle: real;
+    }
+
+    qfunc foo(ms: MyStruct, qv: qbit[2]) {
+      H(qv[0]);
+      repeat (index: ms.loop_counts[1]) {
+        PHASE(ms.angle + 0.5, qv[1]);
+      }
+    }
+
+    qfunc main() {
+      qba: qbit[];
+      allocate(2, qba);
+      foo(MyStruct {
+        loop_counts = [1, 2],
+        angle = 0.1
+      }, qba);
+    }
+    ```
+
 ## Hamiltonians
 
 Qmod's Python embedding offers a specialized syntax for creating

.internal/docs/qmod-reference/language-reference/functions.md

@@ -14,14 +14,6 @@ The following example demonstrates how to define a simple Qmod function. Functio
 declares and uses a classical real-number parameter `p` and a quantum single-qubit
 parameter `q`.
 
-=== "Native"
-
-    ```
-    qfunc rotate(p: real, q: qbit) {
-      PHASE(p * pi, q);
-    }
-    ```
-
 === "Python"
 
     ```python
@@ -34,23 +26,20 @@ parameter `q`.
         PHASE(theta=p * pi, target=qv)
     ```
 
+=== "Native"
+
+    ```
+    qfunc rotate(p: real, q: qbit) {
+      PHASE(p * pi, q);
+    }
+    ```
+
 ## Syntax
 
 The signature of a function comprises the function's name and its parameters, that is,
 the arguments it expects when called. The function's body is the description of its
 implementation as a sequence of statements.
 
-=== "Native"
-
-    (**qfunc** | **qperm**) _name_ **(** _parameters_ **)** **{** _statements_ **}**
-
-    _parameters_ is a list of zero or more comma-separated declarations in one of the
-    three forms:
-
-    - \[ **output** | **input** \] \[ **const** \] _name_ **:** _quantum-type_
-    - _name_ **:** _classical-type_
-    - _name_ **:** (**qfunc** | **qperm**) [ **[** **]** ] **(** _parameters_ **)**
-
 === "Python"
 
     A quantum function is defined with a regular Python function decorated with `@qfunc`
@@ -65,6 +54,17 @@ implementation as a sequence of statements.
     `Input` and `Output`. The _const_ modifier for quantum arguments
     is represented with the generic class `Const`.
 
+=== "Native"
+
+    (**qfunc** | **qperm**) _name_ **(** _parameters_ **)** **{** _statements_ **}**
+
+    _parameters_ is a list of zero or more comma-separated declarations in one of the
+    three forms:
+
+    - \[ **output** | **input** \] \[ **const** \] _name_ **:** _quantum-type_
+    - _name_ **:** _classical-type_
+    - _name_ **:** (**qfunc** | **qperm**) [ **[** **]** ] **(** _parameters_ **)**
+
 ## Semantics
 
 -   A function definition introduces a new function symbol into the global namespace.
@@ -104,18 +104,6 @@ Statements can do one of the following:
 
 The following example demonstrates function declarations:
 
-=== "Native"
-
-    ```
-    qfunc foo(n: int, qba: qbit[2*n]) {
-      // ...
-    }
-
-    qfunc bar(x: qnum, y: qnum, output res: qnum) {
-      // ...
-    }
-    ```
-
 === "Python"
 
     ```python
@@ -132,6 +120,18 @@ The following example demonstrates function declarations:
         pass
     ```
 
+=== "Native"
+
+    ```
+    qfunc foo(n: int, qba: qbit[2*n]) {
+      // ...
+    }
+
+    qfunc bar(x: qnum, y: qnum, output res: qnum) {
+      // ...
+    }
+    ```
+
     Note that when classical arguments are used to specify subsequent arguments, as in the
     case where `qba` is a qubit array of size 2*n, the expression is specified as a string
     literal because the Python variable `n` is not in scope.
@@ -143,17 +143,6 @@ built-in function `H()` and then iteratively function `PHASE()` using the _repea
 statement (for more on `repeat` see
 [Classical Control Flow](statements/classical-control-flow.md)).
 
-=== "Native"
-
-    ```
-    qfunc foo(n: int, qv: qbit) {
-      H(qv);
-      repeat (index: n) {
-        PHASE((index / n) * pi, qv);
-      }
-    }
-    ```
-
 === "Python"
 
     A function decorated with `@qfunc` is executed by the Python interpreter to construct
@@ -170,3 +159,14 @@ statement (for more on `repeat` see
         H(qv)
         repeat(n, lambda i: PHASE(theta=(i / n) * pi, target=qv))
     ```
+
+=== "Native"
+
+    ```
+    qfunc foo(n: int, qv: qbit) {
+      H(qv);
+      repeat (index: n) {
+        PHASE((index / n) * pi, qv);
+      }
+    }
+    ```