docs: def get_mirror(self, x, preserve_length=False):
          """return ``pheno(self.mean - (geno(x) - self.mean))``.
  
          >>> import cma
          >>> es = cma.CMAEvolutionStrategy(cma.np.random.randn(3), 1)
          >>> x = cma.np.random.randn(3)
          >>> assert cma.Mh.vequals_approximately(es.mean - (x - es.mean), es.get_mirror(x, preserve_length=True))
          >>> x = es.ask(1)[0]
          >>> vals = (es.get_mirror(x) - es.mean) / (x - es.mean)
          >>> assert cma.Mh.equals_approximately(sum(vals), len(vals) * vals[0])
  
          TODO: this implementation is yet experimental.
  
          TODO: this implementation includes geno-pheno transformation,
          however in general GP-transformation should be separated from
          specific code.
  
          Selectively mirrored sampling improves to a moderate extend but
          overadditively with active CMA for quite understandable reasons.
  
          Optimal number of mirrors are suprisingly small: 1,2,3 for
          maxlam=7,13,20 where 3,6,10 are the respective maximal possible
          mirrors that must be clearly suboptimal.
  
          """
          try:
              dx = self.sent_solutions[x]['geno'] - self.mean
          except:  # can only happen with injected solutions?!
              dx = self.gp.geno(x, from_bounds=self.boundary_handler.inverse,
                                copy_if_changed=True) - self.mean
  
          if not preserve_length:
              # dx *= sum(self.randn(self.N)**2)**0.5 / self.mahalanobis_norm(dx)
              dx *= self.random_rescaling_factor_to_mahalanobis_size(dx)
          x = self.mean - dx
          y = self.gp.pheno(x, into_bounds=self.boundary_handler.repair)
          # old measure: costs 25% in CPU performance with N,lambda=20,200
          self.sent_solutions.insert(y, geno=x, iteration=self.countiter)
          return y