def initialize_cma_es(self, **kwargs):
        """A strategy that will keep track of the basic parameters.

        Notes
        -----
        +------------+---------------------------+----------------------------+
        | Parameter  | Default                   | Details                    |
        +============+===========================+============================+
        | ``lambda_``| ``int(4 + 3 * log(N))``   | Number of children to      |
        |            |                           | produce at each generation,|
        |            |                           | ``N`` is the individual's  |
        |            |                           | size (integer).            |
        +------------+---------------------------+----------------------------+
        | ``mu``     | ``int(lambda_ / 2)``      | The number of parents to   |
        |            |                           | keep from the              |
        |            |                           | lambda children (integer). |
        +------------+---------------------------+----------------------------+
        | ``cmatrix``| ``identity(N)``           | The initial covariance     |
        |            |                           | matrix of the distribution |
        |            |                           | that will be sampled.      |
        +------------+---------------------------+----------------------------+
        | ``weights``| ``"superlinear"``         | Decrease speed, can be     |
        |            |                           | ``"superlinear"``,         |
        |            |                           | ``"linear"`` or            |
        |            |                           | ``"equal"``.               |
        +------------+---------------------------+----------------------------+
        | ``cs``     | ``(mueff + 2) /           | Cumulation constant for    |
        |            | (N + mueff + 3)``         | step-size.                 |
        +------------+---------------------------+----------------------------+
        | ``damps``  | ``1 + 2 * max(0, sqrt((   | Damping for step-size.     |
        |            | mueff - 1) / (N + 1)) - 1)|                            |
        |            | + cs``                    |                            |
        +------------+---------------------------+----------------------------+
        | ``ccum``   | ``4 / (N + 4)``           | Cumulation constant for    |
        |            |                           | covariance matrix.         |
        +------------+---------------------------+----------------------------+
        | ``ccov1``  | ``2 / ((N + 1.3)^2 +      | Learning rate for rank-one |
        |            | mueff)``                  | update.                    |
        +------------+---------------------------+----------------------------+
        | ``ccovmu`` | ``2 * (mueff - 2 + 1 /    | Learning rate for rank-mu  |
        |            | mueff) / ((N + 2)^2 +     | update.                    |
        |            | mueff)``                  |                            |
        +------------+---------------------------+----------------------------+

        Parameters
        ----------
        centroid:
            An iterable object that indicates where to start the
            evolution.
        sigma:
            The initial standard deviation of the distribution.
        parameter:
            One or more parameter to pass to the strategy as
            described in the following table, optional.
        """
        self.params = kwargs

        # Create a centroid as a numpy array
        self.centroid = numpy.array([0] * len(self._params['value_means']))

        self.dim = len(self.centroid)
        self.sigma = self.params.get("sigma", 0.5)
        self.pc = numpy.zeros(self.dim)
        self.ps = numpy.zeros(self.dim)
        self.chiN = numpy.sqrt(self.dim) * (
            1 - 1. / (4. * self.dim) + 1. / (21. * self.dim ** 2))

        self.C = self.params.get("cmatrix", numpy.identity(self.dim))
        self.diagD, self.B = numpy.linalg.eigh(self.C)

        indx = numpy.argsort(self.diagD)
        self.diagD = self.diagD[indx] ** 0.5
        self.B = self.B[:, indx]
        self.BD = self.B * self.diagD

        self.cond = self.diagD[indx[-1]] / self.diagD[indx[0]]

        self.lambda_ = self.params.get(
            "lambda_", int(4 + 3 * numpy.log(self.dim)))
        self.update_count = 0
        self.computeParams(self.params)
        return