fix lint

Author: donghufeng

ccsrc/include/math/tensor/ops_cpu/memory_operator.h

@@ -53,10 +53,10 @@ void destroy(Tensor* t);
 // -----------------------------------------------------------------------------
 
 template <TDtype src, TDtype des>
-Tensor cast_to(void* data, size_t len) {
+Tensor cast_to(const void* data, size_t len) {
     using d_src = to_device_t<src>;
     using d_des = to_device_t<des>;
-    auto c_data = reinterpret_cast<d_src*>(data);
+    auto c_data = reinterpret_cast<const d_src*>(data);
     auto out = cpu::init<des>(len);
     auto c_out = reinterpret_cast<d_des*>(out.data);
     auto caster = cast_value<to_device_t<src>, to_device_t<des>>();
@@ -71,13 +71,13 @@ Tensor cast_to(const Tensor& t, TDtype des);
 // -----------------------------------------------------------------------------
 
 template <TDtype dtype>
-std::string to_string(void* data, size_t dim, bool simplify = false) {
+std::string to_string(const void* data, size_t dim, bool simplify = false) {
     std::string out = "";
     if (!simplify) {
         out = "array(dtype: " + dtype_to_string(dtype) + ", device: " + device_to_string(TDevice::CPU) + ", data: [";
     }
     using calc_t = to_device_t<dtype>;
-    calc_t* data_ = reinterpret_cast<calc_t*>(data);
+    const calc_t* data_ = reinterpret_cast<const calc_t*>(data);
     for (size_t i = 0; i < dim; i++) {
         if constexpr (is_complex_v<calc_t>) {
             out += "(" + std::to_string(data_[i].real()) + ", " + std::to_string(data_[i].imag()) + ")";
@@ -118,7 +118,7 @@ Tensor init_with_vector(const std::vector<T>& a) {
 // -----------------------------------------------------------------------------
 
 template <TDtype dtype>
-Tensor copy(void* data, size_t len) {
+Tensor copy(const void* data, size_t len) {
     using calc_t = to_device_t<dtype>;
     auto out = init<dtype>(len);
     mindquantum::safe_copy(out.data, sizeof(calc_t) * len, data, sizeof(calc_t) * len);
@@ -128,7 +128,7 @@ Tensor copy(void* data, size_t len) {
 Tensor copy(const Tensor& t);
 
 template <TDtype dtype>
-void* copy_mem(void* data, size_t len) {
+void* copy_mem(const void* data, size_t len) {
     using calc_t = to_device_t<dtype>;
     auto res = reinterpret_cast<void*>(malloc(sizeof(calc_t) * len));
     if (res == nullptr) {
@@ -137,7 +137,7 @@ void* copy_mem(void* data, size_t len) {
     mindquantum::safe_copy(res, sizeof(calc_t) * len, data, sizeof(calc_t) * len);
     return res;
 }
-void* copy_mem(void* data, TDtype dtype, size_t len);
+void* copy_mem(const void* data, TDtype dtype, size_t len);
 
 // -----------------------------------------------------------------------------
 template <typename src, typename T>
@@ -185,8 +185,8 @@ Tensor get(const Tensor& t, size_t idx);
 // -----------------------------------------------------------------------------
 
 template <TDtype src_dtype>
-std::vector<to_device_t<src_dtype>> to_vector(void* data, size_t len) {
-    auto c_data = reinterpret_cast<to_device_t<src_dtype>*>(data);
+std::vector<to_device_t<src_dtype>> to_vector(const void* data, size_t len) {
+    auto c_data = reinterpret_cast<const to_device_t<src_dtype>*>(data);
     std::vector<to_device_t<src_dtype>> out;
     for (size_t i = 0; i < len; i++) {
         out.push_back(c_data[i]);
@@ -204,8 +204,8 @@ std::vector<T> to_vector(const Tensor& ori) {
 }
 
 template <TDtype src_dtype>
-std::vector<std::vector<to_device_t<src_dtype>>> to_vector(void* data, size_t n_row, size_t n_col) {
-    auto c_data = reinterpret_cast<to_device_t<src_dtype>*>(data);
+std::vector<std::vector<to_device_t<src_dtype>>> to_vector(const void* data, size_t n_row, size_t n_col) {
+    auto c_data = reinterpret_cast<const to_device_t<src_dtype>*>(data);
     std::vector<std::vector<to_device_t<src_dtype>>> out;
     for (size_t i = 0; i < n_row; i++) {
         std::vector<to_device_t<src_dtype>> tmp;

ccsrc/lib/math/tensor/ops_cpu/memory_operator.cpp

@@ -111,7 +111,7 @@ Tensor copy(const Tensor& t) {
     return Tensor();
 }
 
-void* copy_mem(void* data, TDtype dtype, size_t len) {
+void* copy_mem(const void* data, TDtype dtype, size_t len) {
     switch (dtype) {
         case (TDtype::Float32):
             return copy_mem<TDtype::Float32>(data, len);

ccsrc/lib/simulator/vector/detail/runtime/cmd.cpp

@@ -30,7 +30,7 @@
 #include "simulator/vector/runtime/rt_gate.h"
 #include "simulator/vector/runtime/utils.h"
 #include "simulator/vector/vector_state.h"
-#define MAX_SHOTS 100000
+constexpr int MAX_SHOTS = 100000;
 
 namespace mindquantum::sim::rt {
 int cmd(const std::vector<std::string> &args) {
@@ -216,7 +216,6 @@ int cmd_file(const char *filename) {
     file.open(filename);
     if (!file.is_open()) {
         throw std::runtime_error(fmt::format("Cannot open file {}", filename));
-        return 0;
     }
     std::vector<std::string> cmds = {"", "cmd"};
     std::string current_cmd = "";

mindquantum/algorithm/compiler/decompose/utils.py

@@ -68,7 +68,10 @@ def kron_factor_4x4_to_2x2s(mat: np.ndarray):
     f2 /= np.sqrt(np.linalg.det(f2)) or 1
 
     # Determine global phase.
-    g = mat[a, b] / (f1[a >> 1, b >> 1] * f2[a & 1, b & 1])
+    denominator = f1[a >> 1, b >> 1] * f2[a & 1, b & 1]
+    if denominator == 0:
+        raise ZeroDivisionError("denominator cannot be zero.")
+    g = mat[a, b] / denominator
     if np.real(g) < 0:
         f1 *= -1
         g = -g
@@ -222,6 +225,8 @@ def glob_phase(mat: np.ndarray) -> float:
         Global phase rad, in range of (-pi, pi].
     """
     d = mat.shape[0]
+    if d == 0:
+        raise ZeroDivisionError("Dimension of mat can not be zero.")
     exp_alpha = linalg.det(mat) ** (1 / d)
     return np.angle(exp_alpha)
 

mindquantum/algorithm/error_mitigation/mitigation.py

@@ -59,7 +59,10 @@ def zne(
             product = 1
             for i in range(0, len(y)):
                 if k != i:
-                    product = product * (scaling[i] / (scaling[i] - scaling[k]))
+                    try:
+                        product = product * (scaling[i] / (scaling[i] - scaling[k]))
+                    except ZeroDivisionError as exc:
+                        raise ZeroDivisionError(f"Error scaling: {scaling}") from exc
             mitigated = mitigated + y_k * product
         return mitigated
     if order is None:

mindquantum/algorithm/library/amplitude_encoder.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-
 """Amplitude encoder for quantum machine learning."""
 
 import math
@@ -41,6 +40,7 @@ def controlled_gate(circuit, gate, t_qubit, c_qubits, zero_qubit):
             circuit += X.on(abs(control))
 
 
+# pylint: disable=too-many-locals
 def amplitude_encoder(x, n_qubits):
     """
     Quantum circuit for amplitude encoding.
@@ -109,7 +109,10 @@ def amplitude_encoder(x, n_qubits):
             controls.append(tmp_j * j)
         theta = 0
         if tree[(i - 1) // 2] > 1e-10:
-            amp_0 = tree[i] / tree[(i - 1) // 2]
+            try:
+                amp_0 = tree[i] / tree[(i - 1) // 2]
+            except ZeroDivisionError as exc:
+                raise ZeroDivisionError("Failed to set amplitude encoding.") from exc
             theta = 2 * math.acos(amp_0)
             if tree[i + 1] < 0 < math.sin(theta / 2):
                 theta = -theta

mindquantum/algorithm/nisq/barren_plateau.py

@@ -99,7 +99,10 @@ def run(grad_ops, n_sampling):
         half_l = len(gradients) // 2
         ori_var = np.var(gradients[:half_l])
         this_var = np.var(gradients[half_l:])
-        var_i = np.abs(ori_var - this_var) / ori_var
+        try:
+            var_i = np.abs(ori_var - this_var) / ori_var
+        except ZeroDivisionError as exc:
+            raise ZeroDivisionError("ori_val cannot be zero.") from exc
         step += 1
 
     return np.var(gradients)

mindquantum/core/operators/fermion_operator.py

@@ -225,10 +225,14 @@ def __rmul__(self, other: typing.Union["FermionOperator", PRConvertible]) -> "Fe
 
     def __truediv__(self, other: PRConvertible) -> "FermionOperator":
         """Divide a number."""
+        if other == 0.0:
+            raise ZeroDivisionError("other cannot be zero.")
         return self * (1.0 / other)
 
     def __itruediv__(self, other: PRConvertible) -> "FermionOperator":
         """Divide a number."""
+        if other == 0.0:
+            raise ZeroDivisionError("other cannot be zero.")
         self.__imul__(1.0 / other)
         return self
 

mindquantum/core/operators/qubit_operator.py

@@ -157,10 +157,14 @@ def __rmul__(self, other: typing.Union["QubitOperator", PRConvertible]) -> "Qubi
 
     def __truediv__(self, other: PRConvertible) -> "QubitOperator":
         """Divide a number."""
+        if other == 0.0:
+            raise ZeroDivisionError("other cannot be zero.")
         return self * (1.0 / other)
 
     def __itruediv__(self, other: PRConvertible) -> "QubitOperator":
         """Divide a number."""
+        if other == 0.0:
+            raise ZeroDivisionError("other cannot be zero.")
         self.__imul__(1.0 / other)
         return self
 

mindquantum/io/display/bloch_plt_drawer.py

@@ -345,8 +345,10 @@ def state_to_cor(amp: np.ndarray):
         _check_input_type('amp', np.ndarray, amp)
         if amp.shape != (2,):
             raise ValueError(f"amp requires shape (2, ), but get {amp.shape}")
-        if np.sqrt(np.vdot(amp, amp)) != 0:
+        try:
             amp = amp / np.sqrt(np.vdot(amp, amp))
+        except ZeroDivisionError as exc:
+            raise ZeroDivisionError("Mode of amp is zero.") from exc
         global_phase = np.angle(amp[0])
         amp = amp / np.exp(1j * global_phase)
         theta = 2 * np.arccos(np.real(amp[0]))