manoelmarques
diff --git a/‎qiskit/aqua/algorithms/eigen_solvers/numpy_eigen_solver.py
+63-43 b/‎qiskit/aqua/algorithms/eigen_solvers/numpy_eigen_solver.py
+63-43
diff --git a/‎qiskit/aqua/algorithms/minimum_eigen_solvers/minimum_eigen_solver.py
+13-7 b/‎qiskit/aqua/algorithms/minimum_eigen_solvers/minimum_eigen_solver.py
+13-7
diff --git a/‎qiskit/aqua/algorithms/minimum_eigen_solvers/numpy_minimum_eigen_solver.py
+18-10 b/‎qiskit/aqua/algorithms/minimum_eigen_solvers/numpy_minimum_eigen_solver.py
+18-10
@@ -14,7 +14,7 @@
 
 """The Eigensolver algorithm."""
 
-from typing import List, Optional
+from typing import List, Optional, Union
 import logging
 import pprint
 import warnings
@@ -23,15 +23,19 @@
 
 from qiskit.aqua import AquaError
 from qiskit.aqua.algorithms import ClassicalAlgorithm
-from qiskit.aqua.operators import BaseOperator, op_converter
+from qiskit.aqua.operators import OperatorBase, LegacyBaseOperator, I, StateFn, ListOp
 from qiskit.aqua.utils.validation import validate_min
 from .eigen_solver_result import EigensolverResult
 
 logger = logging.getLogger(__name__)
 
 
+# pylint: disable=invalid-name
+
+
 class NumPyEigensolver(ClassicalAlgorithm):
-    r"""The NumPy Eigensolver algorithm.
+    r"""
+    The NumPy Eigensolver algorithm.
 
     NumPy Eigensolver computes up to the first :math:`k` eigenvalues of a complex-valued square
     matrix of dimension :math:`n \times n`, with :math:`k \leq n`.
@@ -42,8 +46,12 @@ class NumPyEigensolver(ClassicalAlgorithm):
         operator size, mostly in terms of number of qubits it represents, gets larger.
     """
 
-    def __init__(self, operator: Optional[BaseOperator] = None, k: int = 1,
-                 aux_operators: Optional[List[BaseOperator]] = None) -> None:
+    def __init__(self,
+                 operator: Optional[Union[OperatorBase, LegacyBaseOperator]] = None,
+                 k: int = 1,
+                 aux_operators: Optional[List[Optional[Union[OperatorBase,
+                                                             LegacyBaseOperator]]]] = None
+                 ) -> None:
         """
         Args:
             operator: Operator instance. If None is supplied it must be provided later before
@@ -56,50 +64,52 @@ def __init__(self, operator: Optional[BaseOperator] = None, k: int = 1,
         validate_min('k', k, 1)
         super().__init__()
 
-        self._in_operator = None
-        self._in_aux_operators = None
         self._operator = None
         self._aux_operators = None
         self._in_k = k
-        self._k = k  # pylint: disable=invalid-name
+        self._k = k
 
         self.operator = operator
         self.aux_operators = aux_operators
 
         self._ret = {}
 
     @property
-    def operator(self) -> BaseOperator:
+    def operator(self) -> Optional[OperatorBase]:
         """ returns operator """
-        return self._in_operator
+        return self._operator
 
     @operator.setter
-    def operator(self, operator: BaseOperator) -> None:
+    def operator(self, operator: Union[OperatorBase, LegacyBaseOperator]) -> None:
         """ set operator """
-        self._in_operator = operator
+        if isinstance(operator, LegacyBaseOperator):
+            operator = operator.to_opflow()
         if operator is None:
             self._operator = None
         else:
-            self._operator = op_converter.to_matrix_operator(operator)
+            self._operator = operator
             self._check_set_k()
 
     @property
-    def aux_operators(self) -> List[BaseOperator]:
+    def aux_operators(self) -> Optional[List[Optional[OperatorBase]]]:
         """ returns aux operators """
-        return self._in_aux_operators
+        return self._aux_operators
 
     @aux_operators.setter
-    def aux_operators(self, aux_operators: List[BaseOperator]) -> None:
+    def aux_operators(self,
+                      aux_operators: Optional[List[Optional[Union[OperatorBase,
+                                                                  LegacyBaseOperator]]]]) -> None:
         """ set aux operators """
-        self._in_aux_operators = aux_operators
         if aux_operators is None:
             self._aux_operators = []
         else:
             aux_operators = \
                 [aux_operators] if not isinstance(aux_operators, list) else aux_operators
-            self._aux_operators = \
-                [op_converter.to_matrix_operator(aux_op) if aux_op is not None else None
-                 for aux_op in aux_operators]
+            converted = [op.to_opflow() if op is not None else None for op in aux_operators]
+            # Chemistry passes aux_ops with 0 qubits and paulis sometimes
+            zero_op = I.tensorpower(self.operator.num_qubits) * 0.0
+            converted = [zero_op if op == 0 else op for op in converted]
+            self._aux_operators = converted
 
     @property
     def k(self) -> int:
@@ -119,28 +129,30 @@ def supports_aux_operators(self) -> bool:
 
     def _check_set_k(self):
         if self._operator is not None:
-            if self._in_k > self._operator.matrix.shape[0]:
-                self._k = self._operator.matrix.shape[0]
+            if self._in_k > 2**(self._operator.num_qubits):
+                self._k = 2**(self._operator.num_qubits)
                 logger.debug("WARNING: Asked for %s eigenvalues but max possible is %s.",
                              self._in_k, self._k)
             else:
                 self._k = self._in_k
 
     def _solve(self):
-        if self._operator is None:
-            raise ValueError('Operator is None but must be set!')
-        if self._operator.dia_matrix is None:
-            if self._k >= self._operator.matrix.shape[0] - 1:
-                logger.debug("SciPy doesn't support to get all eigenvalues, using NumPy instead.")
-                eigval, eigvec = np.linalg.eig(self._operator.matrix.toarray())
-            else:
-                eigval, eigvec = scisparse.linalg.eigs(self._operator.matrix, k=self._k, which='SR')
-        else:
-            eigval = np.sort(self._operator.matrix.data)[:self._k]
-            temp = np.argsort(self._operator.matrix.data)[:self._k]
-            eigvec = np.zeros((self._operator.matrix.shape[0], self._k))
+        sp_mat = self._operator.to_spmatrix()
+        # If matrix is diagonal, the elements on the diagonal are the eigenvalues. Solve by sorting.
+        if scisparse.csr_matrix(sp_mat.diagonal()).nnz == sp_mat.nnz:
+            diag = sp_mat.diagonal()
+            eigval = np.sort(diag)[:self._k]
+            temp = np.argsort(diag)[:self._k]
+            eigvec = np.zeros((sp_mat.shape[0], self._k))
             for i, idx in enumerate(temp):
                 eigvec[idx, i] = 1.0
+        else:
+            if self._k >= 2**(self._operator.num_qubits) - 1:
+                logger.debug("SciPy doesn't support to get all eigenvalues, using NumPy instead.")
+                eigval, eigvec = np.linalg.eig(self._operator.to_matrix())
+            else:
+                eigval, eigvec = scisparse.linalg.eigs(self._operator.to_spmatrix(),
+                                                       k=self._k, which='SR')
         if self._k > 1:
             idx = eigval.argsort()
             eigval = eigval[idx]
@@ -174,18 +186,24 @@ def _eval_aux_operators(self, wavefn, threshold=1e-12):
                 values.append(None)
                 continue
             value = 0.0
-            if not operator.is_empty():
-                value, _ = operator.evaluate_with_statevector(wavefn)
+            if operator.coeff != 0:
+                mat = operator.to_spmatrix()
+                # Terra doesn't support sparse yet, so do the matmul directly if so
+                # This is necessary for the particle_hole and other chemistry tests because the
+                # pauli conversions are 2^12th large and will OOM error if not sparse.
+                if isinstance(mat, scisparse.spmatrix):
+                    value = mat.dot(wavefn).dot(np.conj(wavefn))
+                else:
+                    value = StateFn(operator, is_measurement=True).eval(wavefn)
                 value = value.real if abs(value.real) > threshold else 0.0
             values.append((value, 0))
         return np.asarray(values)
 
     def _run(self):
-        """Run the algorithm to compute up to the requested k number of eigenvalues.
-
+        """
+        Run the algorithm to compute up to the requested k number of eigenvalues.
         Returns:
             dict: Dictionary of results
-
         Raises:
             AquaError: if no operator has been provided
         """
@@ -203,7 +221,7 @@ def _run(self):
         if 'eigvals' in self._ret:
             result.eigenvalues = self._ret['eigvals']
         if 'eigvecs' in self._ret:
-            result.eigenstates = self._ret['eigvecs']
+            result.eigenstates = ListOp([StateFn(vec) for vec in self._ret['eigvecs']])
         if 'aux_ops' in self._ret:
             result.aux_operator_eigenvalues = self._ret['aux_ops']
 
@@ -213,10 +231,12 @@ def _run(self):
 
 
 class ExactEigensolver(NumPyEigensolver):
-    """The deprecated Eigensolver algorithm."""
+    """
+    The deprecated Eigensolver algorithm.
+    """
 
-    def __init__(self, operator: BaseOperator, k: int = 1,
-                 aux_operators: Optional[List[BaseOperator]] = None) -> None:
+    def __init__(self, operator: LegacyBaseOperator, k: int = 1,
+                 aux_operators: Optional[List[LegacyBaseOperator]] = None) -> None:
         warnings.warn('Deprecated class {}, use {}.'.format('ExactEigensolver',
                                                             'NumPyEigensolver'),
                       DeprecationWarning)
 
@@ -13,13 +13,14 @@
 # that they have been altered from the originals.
 
 """The Minimum Eigensolver interface"""
+
 import warnings
 from abc import ABC, abstractmethod
 from typing import List, Optional, Union, Dict
 
 import numpy as np
 from qiskit.aqua.algorithms import AlgorithmResult
-from qiskit.aqua.operators import BaseOperator
+from qiskit.aqua.operators import OperatorBase, LegacyBaseOperator
 
 
 class MinimumEigensolver(ABC):
@@ -33,8 +34,11 @@ class MinimumEigensolver(ABC):
 
     @abstractmethod
     def compute_minimum_eigenvalue(
-            self, operator: Optional[BaseOperator] = None,
-            aux_operators: Optional[List[BaseOperator]] = None) -> 'MinimumEigensolverResult':
+            self,
+            operator: Optional[Union[OperatorBase, LegacyBaseOperator]] = None,
+            aux_operators: Optional[List[Optional[Union[OperatorBase,
+                                                        LegacyBaseOperator]]]] = None
+    ) -> 'MinimumEigensolverResult':
         """
         Computes minimum eigenvalue. Operator and aux_operators can be supplied here and
         if not None will override any already set into algorithm so it can be reused with
@@ -67,25 +71,27 @@ def supports_aux_operators(self) -> bool:
 
     @property
     @abstractmethod
-    def operator(self) -> BaseOperator:
+    def operator(self) -> Optional[Union[OperatorBase, LegacyBaseOperator]]:
         """ returns operator """
         pass
 
     @operator.setter
     @abstractmethod
-    def operator(self, operator: BaseOperator) -> None:
+    def operator(self, operator: Union[OperatorBase, LegacyBaseOperator]) -> None:
         """ set operator """
         pass
 
     @property
     @abstractmethod
-    def aux_operators(self) -> List[BaseOperator]:
+    def aux_operators(self) -> Optional[List[Optional[OperatorBase]]]:
         """ returns aux operators """
         pass
 
     @aux_operators.setter
     @abstractmethod
-    def aux_operators(self, aux_operators: List[BaseOperator]) -> None:
+    def aux_operators(self,
+                      aux_operators: Optional[List[Optional[Union[OperatorBase,
+                                                                  LegacyBaseOperator]]]]) -> None:
         """ set aux operators """
         pass
 
 
@@ -14,12 +14,12 @@
 
 """The Numpy Minimum Eigensolver algorithm."""
 
-from typing import List, Optional
+from typing import List, Optional, Union
 import logging
 import pprint
 
 from qiskit.aqua.algorithms import ClassicalAlgorithm, NumPyEigensolver
-from qiskit.aqua.operators import BaseOperator
+from qiskit.aqua.operators import OperatorBase, LegacyBaseOperator
 from .minimum_eigen_solver import MinimumEigensolver, MinimumEigensolverResult
 
 logger = logging.getLogger(__name__)
@@ -32,8 +32,11 @@ class NumPyMinimumEigensolver(ClassicalAlgorithm, MinimumEigensolver):
     The Numpy Minimum Eigensolver algorithm.
     """
 
-    def __init__(self, operator: Optional[BaseOperator] = None,
-                 aux_operators: Optional[List[BaseOperator]] = None) -> None:
+    def __init__(self,
+                 operator: Optional[Union[OperatorBase, LegacyBaseOperator]] = None,
+                 aux_operators: Optional[List[Optional[Union[OperatorBase,
+                                                             LegacyBaseOperator]]]] = None
+                 ) -> None:
         """
         Args:
             operator: Operator instance
@@ -43,27 +46,32 @@ def __init__(self, operator: Optional[BaseOperator] = None,
         self._ret = {}  # TODO remove
 
     @property
-    def operator(self) -> BaseOperator:
+    def operator(self) -> Optional[OperatorBase]:
         return self._ces.operator
 
     @operator.setter
-    def operator(self, operator: BaseOperator) -> None:
+    def operator(self, operator: Union[OperatorBase, LegacyBaseOperator]) -> None:
         self._ces.operator = operator
 
     @property
-    def aux_operators(self) -> List[BaseOperator]:
+    def aux_operators(self) -> Optional[List[Optional[OperatorBase]]]:
         return self._ces.aux_operators
 
     @aux_operators.setter
-    def aux_operators(self, aux_operators: List[BaseOperator]) -> None:
+    def aux_operators(self,
+                      aux_operators: Optional[List[Optional[Union[OperatorBase,
+                                                                  LegacyBaseOperator]]]]) -> None:
         self._ces.aux_operators = aux_operators
 
     def supports_aux_operators(self) -> bool:
         return self._ces.supports_aux_operators()
 
     def compute_minimum_eigenvalue(
-            self, operator: BaseOperator = None,
-            aux_operators: Optional[List[BaseOperator]] = None) -> MinimumEigensolverResult:
+            self,
+            operator: Optional[Union[OperatorBase, LegacyBaseOperator]] = None,
+            aux_operators: Optional[List[Optional[Union[OperatorBase,
+                                                        LegacyBaseOperator]]]] = None
+    ) -> MinimumEigensolverResult:
         super().compute_minimum_eigenvalue(operator, aux_operators)
         return self._run()