improve structure

Author: declanmillar

qiskit/algorithms/eigensolvers/numpy_eigensolver.py

@@ -107,7 +107,7 @@ def _check_set_k(self, operator: BaseOperator | PauliSumOp) -> None:
             else:
                 self._k = self._in_k
 
-    def _solve(self, operator: BaseOperator | PauliSumOp) -> None:
+    def _solve(self, operator: BaseOperator | PauliSumOp) -> tuple[np.ndarray, np.ndarray]:
         if isinstance(operator, Operator):
             # Sparse SciPy matrix not supported, use dense NumPy computation.
             op_matrix = operator.data
@@ -147,11 +147,7 @@ def _solve(self, operator: BaseOperator | PauliSumOp) -> None:
         indices = np.argsort(eigval)[: self._k]
         eigval = eigval[indices]
         eigvec = eigvec[:, indices]
-
-        result = NumPyEigensolverResult()
-        result.eigenvalues = eigval
-        result.eigenstates = eigvec.T
-        return result
+        return eigval, eigvec.T
 
     @staticmethod
     def _eval_aux_operators(
@@ -171,18 +167,20 @@ def _eval_aux_operators(
             values = {}
             key_op_iterator = aux_operators.items()
         for key, operator in key_op_iterator:
+            value = 0.0
+            op_matrix = None
             if operator is None:
                 continue
-            value = 0.0
-            if isinstance(operator, Operator):
+            elif isinstance(operator, Operator):
                 value = Statevector(wavefn).expectation_value(operator)
             else:
                 if isinstance(operator, PauliSumOp):
                     if operator.coeff != 0:
                         op_matrix = operator.to_spmatrix()
-                        value = op_matrix.dot(wavefn).dot(np.conj(wavefn))
                 else:
                     op_matrix = operator.to_matrix(sparse=True)
+
+                if op_matrix is not None:
                     value = op_matrix.dot(wavefn).dot(np.conj(wavefn))
 
             value = value if np.abs(value) > threshold else 0.0
@@ -221,48 +219,49 @@ def compute_eigenvalues(
             # need to consider all elements if a filter is set
             self._k = 2**operator.num_qubits
 
-        result = self._solve(operator)
+        eigvals, eigvecs = self._solve(operator)
 
         # compute energies before filtering, as this also evaluates the aux operators
         if aux_operators is not None:
-            aux_op_vals = []
-            for i in range(self._k):
-                aux_op_vals.append(self._eval_aux_operators(aux_operators, result.eigenstates[i]))
-            result.aux_operators_evaluated = aux_op_vals
+            aux_op_vals = [
+                self._eval_aux_operators(aux_operators, eigvecs[i]) for i in range(self._k)
+            ]
+        else:
+            aux_op_vals = None
 
         # if a filter is set, loop over the given values and only keep
         if self._filter_criterion:
 
-            eigvecs = []
-            eigvals = []
-            aux_ops = []
-            cnt = 0
-            for i in range(len(result.eigenvalues)):
-                eigvec = result.eigenstates[i]
-                eigval = result.eigenvalues[i]
-                if result.aux_operators_evaluated is not None:
-                    aux_op = result.aux_operators_evaluated[i]
+            filt_eigvals = []
+            filt_eigvecs = []
+            filt_aux_op_vals = []
+            count = 0
+            for i in range(len(eigvals)):
+                eigvec = eigvecs[i]
+                eigval = eigvals[i]
+                if aux_op_vals is not None:
+                    aux_op_val = aux_op_vals[i]
                 else:
-                    aux_op = None
-                if self._filter_criterion(eigvec, eigval, aux_op):
-                    cnt += 1
-                    eigvecs += [eigvec]
-                    eigvals += [eigval]
-                    if result.aux_operators_evaluated is not None:
-                        aux_ops += [aux_op]
-                if cnt == k_orig:
+                    aux_op_val = None
+                if self._filter_criterion(eigvec, eigval, aux_op_val):
+                    count += 1
+                    filt_eigvecs.append(eigvec)
+                    filt_eigvals.append(eigval)
+                    if aux_op_vals is not None:
+                        filt_aux_op_vals.append(aux_op_val)
+                if count == k_orig:
                     break
 
-            result.eigenstates = np.array(eigvecs)
-            result.eigenvalues = np.array(eigvals)
-            # conversion to np.array breaks in case of aux_ops
-            result.aux_operators_evaluated = aux_ops
+            eigvals = np.array(filt_eigvals)
+            eigvecs = np.array(filt_eigvecs)
+            aux_op_vals = filt_aux_op_vals
 
             self._k = k_orig
 
-        if result.eigenstates is not None:
-            # convert eigenstates from arrays to Statevectors
-            result.eigenstates = [Statevector(vec) for vec in result.eigenstates]
+        result = NumPyEigensolverResult()
+        result.eigenvalues = eigvals
+        result.eigenstates = [Statevector(vec) for vec in eigvecs]
+        result.aux_operators_evaluated = aux_op_vals
 
         logger.debug("NumpyEigensolverResult:\n%s", result)
         return result