Sync docs for SDK version 1.3.0

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

.internal/docs/qmod-reference/api-reference/classical-functions.md

@@ -197,10 +197,10 @@ and populates `MyStruct` in its call to `foo`.
 ## Hamiltonians
 
 Qmod's Python embedding offers a specialized syntax for creating
-[sparse Hamiltonian](https://docs.classiq.io/latest/qmod-reference/api-reference/classical-types/#classiq.qmod.builtins.structs.SparsePauliOp)
+[sparse Hamiltonian](../../../sdk-reference/qmod/classical-types/#classiq.qmod.builtins.structs.SparsePauliOp)
 objects.
 Calling a
-[Pauli](https://docs.classiq.io/latest/qmod-reference/api-reference/classical-types/#classiq.qmod.builtins.enums.Pauli)
+[Pauli](../../../sdk-reference/qmod/classical-types/#classiq.qmod.builtins.enums.Pauli)
 enum value (e.g., `Pauli.X`) with an index (e.g., `Pauli.X(3)`) creates a
 single-qubit Pauli operator.
 The multiplication of single-qubit Pauli operators (e.g.,

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

@@ -8,15 +8,15 @@ search:
 Expressions in Qmod have syntax, semantics, and use, similar to expressions in
 conventional programming languages.
 They comprise literal values, variables, and operators applied to them.
-However, Qmod is unique in that variables can be of either [classical](https://docs.classiq.io/latest/qmod-reference/api-reference/classical-types) or
-[quantum](https://docs.classiq.io/latest/qmod-reference/language-reference/quantum-types) types, and quantum variables have states that can be a
+However, Qmod is unique in that variables can be of either [classical](../../../sdk-reference/qmod/classical-types) or
+[quantum](../quantum-types) types, and quantum variables have states that can be a
 superposition of values, entangled with the states of other variables.
 Expressions over quantum variables evaluate to a superposition of correlated
 values.
-For example, if `x` is a [classical variable](https://docs.classiq.io/latest/qmod-reference/language-reference/classical-variables)
+For example, if `x` is a [classical variable](../classical-variables)
 of type `CInt` (an integer), then `x + 1` is a classical expression of type
 `CInt` comprising the operator `+` (plus) applied to `x` and the literal `1`.
-Similarly, if `qarr` is a [quantum variable](https://docs.classiq.io/latest/qmod-reference/language-reference/quantum-variables)
+Similarly, if `qarr` is a [quantum variable](../quantum-variables)
 of type `QArray[QNum[3]]`, then `qarr[0] > x` is a quantum expression of type
 `QBit`.
 
@@ -170,7 +170,7 @@ Classical variables may have known values at [compile time, link time, or runtim
 Classical expressions with only compile-time variables are evaluated and
 simplified during compilation.
 This applies sub-expressions of quantum expressions too.
-Qmod supports several built-in classical [constants and functions](https://docs.classiq.io/latest/qmod-reference/api-reference/symbolic-functions/),
+Qmod supports several built-in classical [constants and functions](../../../sdk-reference/qmod/symbolic-functions/),
 such as `pi` and `sin`.
 
 ### Example

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

@@ -114,3 +114,91 @@ in the Classiq open-library.
       }
     }
     ```
+
+## Classical Foreach
+
+The _foreach_ statement iterates through the elements of a classical array.
+Its compilation and simulation are more efficient.
+
+<!-- prettier-ignore-start -->
+!!! warning
+    The `foreach` statement is an experimental feature. It is only supported in
+    Qmod Python.
+<!-- prettier-ignore-end -->
+
+### Syntax
+
+=== "Python"
+
+    [comment]: DO_NOT_TEST
+    ```python
+    def foreach(values: CArray | list, iteration: Callable) -> None:
+        pass
+    ```
+
+The `iteration` callable accepts one or more iteration variables.
+
+### Semantics
+
+-   Invoke the _iteration_ block once for every element of _values_.
+-   If the _iteration_ block accepts a single iteration variable, the elements
+    of _values_ will be bound to it sequentially.
+-   If _values_ is a nested array (`CArray[CArray]`), the length of _values_'
+    elements is $n$, $n>=2$, and the _iteration_ block has $n$ iteration
+    variables, then _values_' elements will be unpacked into the iteration
+    variables in each iteration.
+-   Inside the statement block, use of quantum variables declared outside it is restricted
+    to contexts where the variable is initialized and remains initialized (see [Quantum Variables](../quantum-variables.md))
+-   _values_ must be a value of type `CArray[CReal]` or `CArray[CArray[CReal]]`.
+
+### Examples
+
+In the following example, the `foreach` statement iterates through the elements
+of the classical list `[0.1, 0.2]` and assigns its elements into the iteration
+variable `i`.
+This is equivalent to calling `RX` and `Y` twice, once with angle `0.1` and
+once with `0.2`.
+
+=== "Python"
+
+    ```python
+    from classiq import *
+
+
+    @qfunc
+    def main(q: Output[QBit]) -> None:
+        allocate(q)
+        foreach(
+            [0.1, 0.2],
+            lambda i: [
+                RX(i, q),
+                Y(q),
+            ],
+        )
+    ```
+
+In the following example, the `foreach` statement iterates through the elements
+of the classical list `[[0.1, 0.2], [0.3, 0.4]]` and assigns its elements into the iteration
+variables `i` and `j`.
+In each iteration, the elements of the nested arrays are "unpacked" into the
+iteration variables.
+The first iteration assigns `0.1` into `i` and `0.2` into `j`, and the second
+iteration assigns `0.3` into `i` and `0.4` into `j`.
+
+=== "Python"
+
+    ```python
+    from classiq import *
+
+
+    @qfunc
+    def main(q: Output[QBit]) -> None:
+        allocate(q)
+        foreach(
+            [[0.1, 0.2], [0.3, 0.4]],
+            lambda i, j: [
+                RX(i, q),
+                RY(j, q),
+            ],
+        )
+    ```

.internal/docs/qmod-reference/language-reference/statements/classical-control-flow.md

@@ -10,4 +10,5 @@ These functions require the `cudaq` extra (install `classiq[cudaq]`).
 Note that the `cudaq` extra is only available in Classiq Studio and on any Linux
 Machine.
 
-::: classiq.qprog_to_cudaq
+::: classiq.cudaq.qprog_to_cudaq.qprog_to_cudaq_kernel
+::: classiq.cudaq.pauli_op_to_cudaq.pauli_operator_to_cudaq_spin_op

.internal/docs/sdk-reference/cudaq.md

@@ -4,8 +4,17 @@ search:
 ---
 
 This is a list of the classical types that are built-in in `Qmod`.
-For more information regarding classical types see: [classical types](../language-reference/classical-types.md).
+For more information regarding classical types see: [classical types](../../../qmod-reference/language-reference/classical-types/).
 
 ::: classiq.qmod.builtins.structs
+options:
+show_source: false
+show_if_no_docstring: false
 ::: classiq.qmod.builtins.constants
+options:
+show_source: false
+show_if_no_docstring: false
 ::: classiq.qmod.builtins.enums
+options:
+show_source: false
+show_if_no_docstring: false

.internal/docs/sdk-reference/modeling.md

@@ -14,5 +14,6 @@ search:
             - prepare_amplitudes
             - inplace_prepare_state
             - inplace_prepare_amplitudes
+            - assign_phase_table
 <!-- prettier-ignore-end -->
 <!-- spell-checker: enable -->