diff --git a/.gitignore b/.gitignore
index fe9a206..85d9c78 100644
--- a/.gitignore
+++ b/.gitignore
@@ -108,4 +108,11 @@ deploy.sh
 x.py
 run.py
 install
-.vs/
\ No newline at end of file
+.vs/
+
+scripts/distributions/*pdf
+scripts/distributions/*png
+scripts/distributions/*pkl
+scripts/distributions/figures
+
+data_old
\ No newline at end of file
diff --git a/include/bounds.hpp b/include/bounds.hpp
index a75640b..944ff30 100644
--- a/include/bounds.hpp
+++ b/include/bounds.hpp
@@ -11,11 +11,13 @@ namespace parameters
 	struct Parameters;
 }
 
-
 namespace bounds
 {
 	using Mask = Eigen::Array<bool, Eigen::Dynamic, 1>;
 
+	Mask is_out_of_bounds(const Vector &xi, const Vector &lb, const Vector &ub);
+	bool any_out_of_bounds(const Vector &xi, const Vector &lb, const Vector &ub);
+
 	struct BoundCorrection
 	{
 		virtual ~BoundCorrection() = default;
@@ -26,68 +28,73 @@ namespace bounds
 		BoundCorrection(const Vector &lb, const Vector &ub) : lb(lb), ub(ub), db(ub - lb),
 															  diameter((ub - lb).norm()) {}
 
-		void correct(const Eigen::Index i, parameters::Parameters& p);
+		void correct(const Eigen::Index i, parameters::Parameters &p);
 
-		virtual Vector correct_x(const Vector& xi, const Mask& oob) = 0;
+		virtual Vector correct_x(const Vector &xi, const Mask &oob) = 0;
 
-		[[nodiscard]] Mask is_out_of_bounds(const Vector& xi) const;
+		[[nodiscard]] Mask is_out_of_bounds(const Vector &xi) const;
 
-		[[nodiscard]] Vector delta_out_of_bounds(const Vector& xi, const Mask& oob) const;
+		[[nodiscard]] Vector delta_out_of_bounds(const Vector &xi, const Mask &oob) const;
 
 		[[nodiscard]] bool any_out_of_bounds() const
 		{
 			return n_out_of_bounds > 0;
-		}		
+		}
 	};
 
-	struct NoCorrection final : BoundCorrection
+	struct NoCorrection : BoundCorrection
 	{
 		using BoundCorrection::BoundCorrection;
 
-		Vector correct_x(const Vector& xi, const Mask& oob) override
+		Vector correct_x(const Vector &xi, const Mask &oob) override
 		{
 			return xi;
 		}
 	};
 
+	struct Resample final : NoCorrection
+	{
+		using NoCorrection::NoCorrection;
+	};
+
 	struct COTN final : BoundCorrection
 	{
 		sampling::Gaussian sampler;
 
 		COTN(Eigen::Ref<const Vector> lb, Eigen::Ref<const Vector> ub) : BoundCorrection(lb, ub), sampler(static_cast<size_t>(lb.size()), rng::normal<double>(0, 1.0 / 3.)) {}
 
-		Vector correct_x(const Vector& xi, const Mask& oob) override;
+		Vector correct_x(const Vector &xi, const Mask &oob) override;
 	};
 
 	struct Mirror final : BoundCorrection
 	{
 		using BoundCorrection::BoundCorrection;
 
-		Vector correct_x(const Vector& xi, const Mask& oob) override;
+		Vector correct_x(const Vector &xi, const Mask &oob) override;
 	};
 
 	struct UniformResample final : BoundCorrection
 	{
-		sampling::Random<std::uniform_real_distribution<>> sampler;
+		sampling::Uniform sampler;
 
 		UniformResample(Eigen::Ref<const Vector> lb, Eigen::Ref<const Vector> ub) : BoundCorrection(lb, ub), sampler(static_cast<size_t>(lb.size())) {}
 
-		Vector correct_x(const Vector& xi, const Mask& oob) override;
+		Vector correct_x(const Vector &xi, const Mask &oob) override;
 	};
 
 	struct Saturate final : BoundCorrection
 	{
 		using BoundCorrection::BoundCorrection;
 
-		Vector correct_x(const Vector& xi, const Mask& oob) override;
+		Vector correct_x(const Vector &xi, const Mask &oob) override;
 	};
 
 	struct Toroidal final : BoundCorrection
 	{
 		using BoundCorrection::BoundCorrection;
 
-		Vector correct_x(const Vector& xi, const Mask& oob) override;
-	};	
+		Vector correct_x(const Vector &xi, const Mask &oob) override;
+	};
 
 	inline std::shared_ptr<BoundCorrection> get(const parameters::CorrectionMethod &m, const Vector &lb, const Vector &ub)
 	{
@@ -104,7 +111,8 @@ namespace bounds
 			return std::make_shared<Saturate>(lb, ub);
 		case CorrectionMethod::TOROIDAL:
 			return std::make_shared<Toroidal>(lb, ub);
-
+		case CorrectionMethod::RESAMPLE:
+			return std::make_shared<Resample>(lb, ub);
 		default:
 		case CorrectionMethod::NONE:
 			return std::make_shared<NoCorrection>(lb, ub);
diff --git a/include/common.hpp b/include/common.hpp
index c0bb051..8ddabb2 100644
--- a/include/common.hpp
+++ b/include/common.hpp
@@ -273,7 +273,7 @@ namespace rng
 	struct uniform
 	{
 		/**
-		 * @brief Generate a random uniform number in the closed interval [-1, 1]
+		 * @brief Generate a random uniform number in the closed interval [0, 1]
 		 *
 		 * @tparam G the type of the generator
 		 * @param gen the generator instance
@@ -282,7 +282,7 @@ namespace rng
 		template <typename G>
 		T operator()(G &gen)
 		{
-			return static_cast<T>(2.0 * gen() - gen.min()) / gen.max() - gen.min() - 1;
+			return static_cast<T>(gen() - gen.min()) / gen.max() - gen.min();
 		}
 	};
 
@@ -320,8 +320,8 @@ namespace rng
 
 			if (generate)
 			{
-				T u1 = std::abs(rng(gen));
-				T u2 = std::abs(rng(gen));
+				T u1 = rng(gen);
+				T u2 = rng(gen);
 				const T root_log_u1 = std::sqrt(-2.0 * std::log(u1));
 				const T two_pi_u2 = 2.0 * M_PI * u2;
 				r1 = (sigma * (root_log_u1 * std::sin(two_pi_u2))) + mu;
diff --git a/include/es.hpp b/include/es.hpp
new file mode 100644
index 0000000..b679196
--- /dev/null
+++ b/include/es.hpp
@@ -0,0 +1,104 @@
+#pragma once
+
+#include "sampling.hpp"
+#include "stats.hpp"
+#include "bounds.hpp"
+
+namespace es
+{
+    struct OnePlusOneES
+    {
+        OnePlusOneES(
+            const size_t d,
+            const Vector &x0,
+            const double f0,
+            const double sigma0,
+            const size_t budget,
+            const double target,
+            const parameters::Modules &modules)
+            : d(d), sigma(sigma0), decay(1.0 / std::sqrt(static_cast<double>(d) + 1)),
+              x(x0), f(f0), t(1), budget(budget), target(target),
+              rejection_sampling(modules.bound_correction == parameters::CorrectionMethod::RESAMPLE),
+              sampler(sampling::get(d, modules, 1)),
+              corrector(bounds::get(modules.bound_correction, Vector::Ones(d) * -5.0, Vector::Ones(d) * 5.0))
+        {
+        }
+
+        Vector sample();
+        void step(FunctionType &objective);
+        void operator()(FunctionType &objective);
+
+        size_t d;
+        double sigma;
+        double decay;
+        Vector x;
+        double f;
+        size_t t;
+        size_t budget;
+        double target;
+        bool rejection_sampling;
+
+        std::shared_ptr<sampling::Sampler> sampler;
+        std::shared_ptr<bounds::BoundCorrection> corrector;
+    };
+
+    struct MuCommaLambdaES
+    {
+
+        MuCommaLambdaES(
+            const size_t d,
+            const Vector &x0,
+            const double sigma0, 
+            const size_t budget,
+            const double target,
+            const parameters::Modules &modules)
+            : d(d), lambda(d * 5), mu(std::floor(lambda / 4)),
+              tau(1.0 / std::sqrt(static_cast<double>(d))), // v1 ->
+              tau_i(1.0 / pow(static_cast<double>(d), .25)), 
+              mu_inv(1.0 / mu),
+              m(x0), sigma(sigma0 * Vector::Ones(d)),
+              f(Vector::Constant(lambda, std::numeric_limits<double>::infinity())),
+              X(d, lambda), S(d, lambda),
+              f_min(std::numeric_limits<double>::infinity()),
+              x_min(Vector::Constant(d, std::numeric_limits<double>::signaling_NaN())),
+              t(0), e(0), budget(budget), target(target),
+              sampler(sampling::get(d, modules, lambda)),
+              sigma_sampler(std::make_shared<sampling::Gaussian>(d)),
+              rejection_sampling(modules.bound_correction == parameters::CorrectionMethod::RESAMPLE),
+              corrector(bounds::get(modules.bound_correction, Vector::Ones(d) * -5.0, Vector::Ones(d) * 5.0))
+        {
+            // tau = 1.0 / sampler->expected_length();
+            // tau_i = 1.0 / std::sqrt(sampler->expected_length());
+        }
+
+        Vector sample(const Vector si);
+        void step(FunctionType &objective);
+        void operator()(FunctionType &objective);
+
+        size_t d;
+        size_t lambda;
+        size_t mu;
+        double tau;
+        double tau_i;
+        double mu_inv;
+
+        Vector m;
+        Vector sigma;
+        Vector f;
+        Matrix X;
+        Matrix S;
+
+        double f_min;
+        Vector x_min;
+        size_t t;
+        size_t e;
+        size_t budget;
+        double target;
+
+        std::shared_ptr<sampling::Sampler> sampler;
+        std::shared_ptr<sampling::Sampler> sigma_sampler;
+
+        bool rejection_sampling;
+        std::shared_ptr<bounds::BoundCorrection> corrector;
+    };
+}
\ No newline at end of file
diff --git a/include/matrix_adaptation.hpp b/include/matrix_adaptation.hpp
index 0a88176..cb42431 100644
--- a/include/matrix_adaptation.hpp
+++ b/include/matrix_adaptation.hpp
@@ -12,14 +12,13 @@ namespace matrix_adaptation
 	{
 		Vector m, m_old, dm, ps;
 		double dd;
-		double chiN;
+		double expected_length_z;
 		Matrix inv_C;
 
-		Adaptation(const size_t dim, const Vector& x0, const Vector& ps) :
+		Adaptation(const size_t dim, const Vector& x0, const Vector& ps, const double expected_length_z) :
 			m(x0), m_old(dim), dm(Vector::Zero(dim)),
 			ps(ps), dd(static_cast<double>(dim)),
-			chiN(sqrt(dd)* (1.0 - 1.0 / (4.0 * dd) + 1.0
-				/ (21.0 * pow(dd, 2.0)))),
+			expected_length_z(expected_length_z),
 			inv_C(Matrix::Identity(dim, dim))
 		{
 		}
@@ -43,7 +42,7 @@ namespace matrix_adaptation
 
 	struct None final : Adaptation
 	{
-		None(const size_t dim, const Vector& x0) : Adaptation(dim, x0, Vector::Ones(dim))
+		None(const size_t dim, const Vector& x0, const double expected_length_z) : Adaptation(dim, x0, Vector::Ones(dim), expected_length_z)
 		{
 		}
 
@@ -72,7 +71,7 @@ namespace matrix_adaptation
 
 		bool hs = true;
 
-		CovarianceAdaptation(const size_t dim, const Vector& x0) : Adaptation(dim, x0, Vector::Zero(dim)),
+		CovarianceAdaptation(const size_t dim, const Vector& x0, const double expected_length_z) : Adaptation(dim, x0, Vector::Zero(dim), expected_length_z),
 			pc(Vector::Zero(dim)),
 			d(Vector::Ones(dim)),
 			B(Matrix::Identity(dim, dim)),
@@ -112,7 +111,7 @@ namespace matrix_adaptation
 		Matrix M;
 		Matrix M_inv;
 
-		MatrixAdaptation(const size_t dim, const Vector& x0) : Adaptation(dim, x0, Vector::Ones(dim)),
+		MatrixAdaptation(const size_t dim, const Vector& x0, const double expected_length_z) : Adaptation(dim, x0, Vector::Ones(dim), expected_length_z),
 			M(Matrix::Identity(dim, dim)),
 			M_inv(Matrix::Identity(dim, dim))
 		{
@@ -132,20 +131,20 @@ namespace matrix_adaptation
 		Vector invert_y(const Vector&) override;
 	};
 
-	inline std::shared_ptr<Adaptation> get(const parameters::Modules& m, const size_t dim, const Vector& x0)
+	inline std::shared_ptr<Adaptation> get(const parameters::Modules& m, const size_t dim, const Vector& x0, const double expected_z)
 	{
 		using namespace parameters;
 		switch (m.matrix_adaptation)
 		{
 		case MatrixAdaptationType::MATRIX:
-			return std::make_shared<MatrixAdaptation>(dim, x0);
+			return std::make_shared<MatrixAdaptation>(dim, x0, expected_z);
 		case MatrixAdaptationType::NONE:
-			return std::make_shared<None>(dim, x0);
+			return std::make_shared<None>(dim, x0, expected_z);
 		case MatrixAdaptationType::SEPERABLE:
-			return std::make_shared<SeperableAdaptation>(dim, x0);
+			return std::make_shared<SeperableAdaptation>(dim, x0, expected_z);
 		default:
 		case MatrixAdaptationType::COVARIANCE:
-			return std::make_shared<CovarianceAdaptation>(dim, x0);
+			return std::make_shared<CovarianceAdaptation>(dim, x0, expected_z);
 		}
 	}
 } // namespace parameters
diff --git a/include/modules.hpp b/include/modules.hpp
index a05f3fd..de0e506 100644
--- a/include/modules.hpp
+++ b/include/modules.hpp
@@ -11,12 +11,23 @@ namespace parameters
 
     enum class BaseSampler
     {
-        GAUSSIAN,
+        UNIFORM,
         SOBOL,
         HALTON,
         TESTER
     };
 
+    enum class SampleTranformerType
+    {
+        NONE,
+        GAUSSIAN,
+        SCALED_UNIFORM,
+        LAPLACE,
+        LOGISTIC,
+        CAUCHY,
+        DOUBLE_WEIBULL
+    };
+
     enum class Mirror
     {
         NONE,
@@ -42,7 +53,8 @@ namespace parameters
         COTN,
         UNIFORM_RESAMPLE,
         SATURATE,
-        TOROIDAL
+        TOROIDAL, 
+        RESAMPLE
     };
 
     enum class RestartStrategyType
@@ -54,14 +66,16 @@ namespace parameters
         BIPOP
     };
 
-    enum class MatrixAdaptationType {
+    enum class MatrixAdaptationType
+    {
         NONE,
         COVARIANCE,
         MATRIX,
-        SEPERABLE        
+        SEPERABLE
     };
 
-    enum class CenterPlacement {
+    enum class CenterPlacement
+    {
         X0,
         ZERO,
         UNIFORM,
@@ -77,12 +91,13 @@ namespace parameters
         bool sample_sigma = false;
         bool repelling_restart = false;
         RecombinationWeights weights = RecombinationWeights::DEFAULT;
-        BaseSampler sampler = BaseSampler::GAUSSIAN;
+        BaseSampler sampler = BaseSampler::UNIFORM;
         Mirror mirrored = Mirror::NONE;
         StepSizeAdaptation ssa = StepSizeAdaptation::CSA;
         CorrectionMethod bound_correction = CorrectionMethod::NONE;
         RestartStrategyType restart_strategy = RestartStrategyType::NONE;
         MatrixAdaptationType matrix_adaptation = MatrixAdaptationType::COVARIANCE;
         CenterPlacement center_placement = CenterPlacement::X0;
+        SampleTranformerType sample_transformation = SampleTranformerType::GAUSSIAN;
     };
 }
\ No newline at end of file
diff --git a/include/mutation.hpp b/include/mutation.hpp
index e9c457e..74fb28e 100644
--- a/include/mutation.hpp
+++ b/include/mutation.hpp
@@ -13,7 +13,8 @@ namespace parameters
     struct Strategy;
     struct Modules;
 }
-namespace matrix_adaptation {
+namespace matrix_adaptation
+{
     struct Adaptation;
 }
 namespace bounds
@@ -33,7 +34,7 @@ namespace mutation
 
     struct NoThresholdConvergence : ThresholdConvergence
     {
-        Vector scale(const Vector& zi, const double diameter, const size_t budget, const size_t evaluations) override
+        Vector scale(const Vector &zi, const double diameter, const size_t budget, const size_t evaluations) override
         {
             return zi;
         }
@@ -46,7 +47,7 @@ namespace mutation
 
     public:
         SequentialSelection(const parameters::Mirror &m, const size_t mu, const double seq_cutoff_factor = 1.0) : seq_cutoff_factor(m == parameters::Mirror::PAIRWISE ? std::max(2., seq_cutoff_factor) : seq_cutoff_factor),
-                                                                                                                seq_cutoff(static_cast<size_t>(mu * seq_cutoff_factor))
+                                                                                                                  seq_cutoff(static_cast<size_t>(mu * seq_cutoff_factor))
         {
         }
         virtual bool break_conditions(const size_t i, const double f, double fopt, const parameters::Mirror &m);
@@ -98,8 +99,7 @@ namespace mutation
             const std::shared_ptr<SigmaSampler> &sigma_sampler,
             const double cs, const double sigma0) : tc(threshold_covergence), sq(sequential_selection), ss(sigma_sampler), cs(cs), sigma(sigma0) {}
 
-
-        virtual void mutate(FunctionType& objective, const size_t n_offspring, parameters::Parameters& p) = 0;
+        virtual void mutate(FunctionType &objective, const size_t n_offspring, parameters::Parameters &p) = 0;
 
         virtual void adapt(const parameters::Weights &w, std::shared_ptr<matrix_adaptation::Adaptation> adaptation, Population &pop,
                            const Population &old_pop, const parameters::Stats &stats, const size_t lambda) = 0;
@@ -108,13 +108,14 @@ namespace mutation
     struct CSA : Strategy
     {
         double damps;
+        double expected_length_z;
 
         CSA(const std::shared_ptr<ThresholdConvergence> &threshold_covergence,
             const std::shared_ptr<SequentialSelection> &sequential_selection,
             const std::shared_ptr<SigmaSampler> &sigma_sampler,
-            const double cs, const double damps, const double sigma0) : Strategy(threshold_covergence, sequential_selection, sigma_sampler, cs, sigma0), damps(damps) {}
+            const double cs, const double damps, const double sigma0, const double expected_z) : Strategy(threshold_covergence, sequential_selection, sigma_sampler, cs, sigma0), damps(damps), expected_length_z(expected_z) {}
 
-        void mutate(FunctionType& objective, const size_t n_offspring, parameters::Parameters& p) override;
+        void mutate(FunctionType &objective, const size_t n_offspring, parameters::Parameters &p) override;
 
         void adapt(const parameters::Weights &w, std::shared_ptr<matrix_adaptation::Adaptation> adaptation, Population &pop,
                    const Population &old_pop, const parameters::Stats &stats, const size_t lambda) override;
@@ -128,7 +129,7 @@ namespace mutation
         double b_tpa = 0.0;
         double rank_tpa = 0.0;
 
-        void mutate(FunctionType& objective, const size_t n_offspring, parameters::Parameters &p) override;
+        void mutate(FunctionType &objective, const size_t n_offspring, parameters::Parameters &p) override;
 
         void adapt(const parameters::Weights &w, std::shared_ptr<matrix_adaptation::Adaptation> adaptation, Population &pop,
                    const Population &old_pop, const parameters::Stats &stats, const size_t lambda) override;
@@ -145,7 +146,7 @@ namespace mutation
     struct PSR : CSA
     {
         double succes_ratio = .25;
-        
+
         Vector combined;
 
         using CSA::CSA;
@@ -179,6 +180,6 @@ namespace mutation
     };
 
     std::shared_ptr<Strategy> get(const parameters::Modules &m, const size_t mu,
-                                  const double mueff, const double d, const double sigma, const std::optional<double> cs);
+                                  const double mueff, const double d, const double sigma, const std::optional<double> cs, const double expected_z);
 
 }
\ No newline at end of file
diff --git a/include/parameters.hpp b/include/parameters.hpp
index 2413735..866003c 100644
--- a/include/parameters.hpp
+++ b/include/parameters.hpp
@@ -26,8 +26,8 @@ namespace parameters
         Population pop;
         Population old_pop;
 
-        std::shared_ptr<matrix_adaptation::Adaptation> adaptation;
         std::shared_ptr<sampling::Sampler> sampler;
+        std::shared_ptr<matrix_adaptation::Adaptation> adaptation;
         std::shared_ptr<mutation::Strategy> mutation;
         std::shared_ptr<selection::Strategy> selection;
         std::shared_ptr<restart::Strategy> restart;
diff --git a/include/sampling.hpp b/include/sampling.hpp
index 1c9ea2a..a25e036 100644
--- a/include/sampling.hpp
+++ b/include/sampling.hpp
@@ -23,6 +23,11 @@ namespace sampling
         virtual void reset(const parameters::Modules &, const size_t)
         {
         }
+
+        virtual double expected_length()
+        {
+            return std::sqrt(static_cast<double>(d));
+        }
     };
 
     /**
@@ -61,7 +66,7 @@ namespace sampling
         Distribution dist;
     };
 
-    //! Gaussian distribution sampler
+    // //! Gaussian distribution sampler
     using Gaussian = Random<rng::normal<double>>;
 
     //! Uniform distribution sampler
@@ -78,7 +83,7 @@ namespace sampling
 
         [[nodiscard]] Vector operator()() override;
 
-        void reset(const parameters::Modules& m, const size_t l) override
+        void reset(const parameters::Modules &m, const size_t l) override
         {
             sampler->reset(m, l);
             mirror = false;
@@ -109,7 +114,7 @@ namespace sampling
 
         [[nodiscard]] Vector operator()() override;
 
-        void reset(const parameters::Modules& mod, const size_t lambda) override;
+        void reset(const parameters::Modules &mod, const size_t lambda) override;
 
         static size_t get_n_samples(const parameters::Modules &modules, const size_t lambda);
 
@@ -121,9 +126,8 @@ namespace sampling
         Matrix I;
         size_t current = 0;
     };
-   
 
-	/**
+    /**
      * @brief Generator yielding samples from a Halton sequence.
      *
      */
@@ -136,22 +140,20 @@ namespace sampling
     private:
         int index_;
         bool scramble_;
-    	std::vector<int> primes_;
+        std::vector<int> primes_;
         std::vector<std::vector<std::vector<int>>> permutations_;
 
         static double next(int index, const int base);
 
-        static double next(int index, const int base, const std::vector<std::vector<int>>& permutations);
+        static double next(int index, const int base, const std::vector<std::vector<int>> &permutations);
 
         static std::vector<int> sieve(const int n);
 
-        static std::vector<std::vector<std::vector<int>>> get_permutations(const std::vector<int>& primes);
+        static std::vector<std::vector<std::vector<int>>> get_permutations(const std::vector<int> &primes);
 
         static std::vector<int> n_primes(const size_t d);
-      
     };
 
-   
     /**
      * @brief Generator yielding samples from a Sobol sequence.
      *
@@ -159,34 +161,32 @@ namespace sampling
     struct Sobol : Sampler
     {
         rng::CachedShuffleSequence cache;
-     
+
         Sobol(const size_t dim);
 
         [[nodiscard]] Vector operator()() override { return cache.next(); }
     };
 
-
     /**
      * \brief A sampler that cycles through a number of points in a cache
      */
-    struct CachedSampler: Sampler
+    struct CachedSampler : Sampler
     {
         std::shared_ptr<Sampler> sampler;
         std::vector<Vector> cache;
         size_t index;
         size_t n_samples;
-        
-        CachedSampler(const std::shared_ptr<Sampler> sampler): 
-            Sampler(sampler->d), 
-            sampler(sampler),
-            cache(),
-            index(0),
-            n_samples(std::max(constants::cache_min_samples, utils::nearest_power_of_2(constants::cache_max_doubles / sampler->d)))
-        { 
+
+        CachedSampler(const std::shared_ptr<Sampler> sampler) : Sampler(sampler->d),
+                                                                sampler(sampler),
+                                                                cache(),
+                                                                index(0),
+                                                                n_samples(std::max(constants::cache_min_samples, utils::nearest_power_of_2(constants::cache_max_doubles / sampler->d)))
+        {
             cache.reserve(n_samples);
         }
 
-        CachedSampler(const std::vector<Vector>& cache, const bool transform_ppf = false)
+        CachedSampler(const std::vector<Vector> &cache, const bool transform_ppf = false)
             : Sampler(cache[0].size()),
               sampler(std::make_shared<Tester>(cache[0].size())),
               cache(cache),
@@ -194,21 +194,171 @@ namespace sampling
               n_samples(cache.size())
         {
             if (transform_ppf)
-                for (auto& sample: this->cache)
-                    for (auto& si: sample)
+                for (auto &sample : this->cache)
+                    for (auto &si : sample)
                         si = ppf(si);
         }
 
-
-        [[nodiscard]] Vector operator()() override { 
+        [[nodiscard]] Vector operator()() override
+        {
             Vector sample;
             if (index < n_samples)
                 cache.emplace_back(sampler->operator()());
-            
+
             return cache[index++ % n_samples];
         }
     };
 
+    /***
+     * \brief Abstract class for sample transformation methods
+     */
+    struct SampleTransformer : Sampler
+    {
+
+        SampleTransformer(const std::shared_ptr<Sampler> sampler) : Sampler(sampler->d), sampler(sampler) {}
+        /**
+         * Should be overwritten, transforms U(0,1) indep samples into something else
+         */
+        [[nodiscard]] virtual Vector transform(Vector x) = 0;
+
+        [[nodiscard]] virtual Vector operator()() override
+        {
+            return transform((*sampler)());
+        }
+
+        void reset(const parameters::Modules &m, const size_t l) override
+        {
+            sampler->reset(m, l);
+        }
+
+        [[nodiscard]] Vector raw()
+        {
+            return (*sampler)();
+        }
+
+    protected:
+        std::shared_ptr<Sampler> sampler;
+    };
+
+    struct IdentityTransformer: SampleTransformer
+    {
+        IdentityTransformer(const std::shared_ptr<Sampler> sampler) : SampleTransformer(sampler) {}
+        
+        [[nodiscard]] virtual Vector transform(Vector x)
+        {
+            return x;
+        }
+    };
+
+
+    //! Adds ppf to transform into gaussian
+    struct GaussianTransformer : SampleTransformer
+    {
+        GaussianTransformer(const std::shared_ptr<Sampler> sampler) : SampleTransformer(sampler) {}
+
+        double expected_length() override
+        {
+            const double dd = static_cast<double>(this->sampler->d);
+            return sqrt(dd) * (1.0 - 1.0 / (4.0 * dd) + 1.0 / (21.0 * pow(dd, 2.0)));
+        }
+
+        [[nodiscard]] virtual Vector transform(Vector x) override
+        {
+            for (auto &xi : x)
+                xi = ppf(xi);
+            return x;
+        }
+    };
+
+    struct UniformScaler : SampleTransformer
+    {
+        static inline double scale = std::sqrt(3.0);
+
+        UniformScaler(const std::shared_ptr<Sampler> sampler) : SampleTransformer(sampler) {}
+
+        [[nodiscard]] virtual Vector transform(Vector x) override
+        {
+            for (auto &xi : x)
+                xi = -scale + (2.0 * scale) * xi;
+            return x;
+        }
+    };
+
+    struct LaplaceTransformer : SampleTransformer
+    {
+        static inline double b = std::sqrt(0.5);
+        
+        LaplaceTransformer(const std::shared_ptr<Sampler> sampler) : SampleTransformer(sampler) {}
+
+        [[nodiscard]] virtual Vector transform(Vector x) override
+        {
+            for (auto &xi : x)
+            {
+                if (xi < 0.5)
+                    xi = b * std::log(2.0 * xi);
+                else
+                    xi = -b * std::log(2.0 * (1.0 - xi));
+                
+            }
+            return x;
+        }
+    };
+
+    struct LogisticTransformer : SampleTransformer
+    {
+        static inline double s = std::sqrt(3.0) / M_PI;
+        
+        LogisticTransformer(const std::shared_ptr<Sampler> sampler) : SampleTransformer(sampler) {}
+
+        [[nodiscard]] virtual Vector transform(Vector x) override
+        {
+            for (auto &xi : x)
+                xi = s * std::log(xi  / (1 - xi));
+            return x;
+        }
+    };
+
+    struct CauchyTransformer : SampleTransformer
+    {
+        static inline double gamma = 1.0;
+
+        CauchyTransformer(const std::shared_ptr<Sampler> sampler) : SampleTransformer(sampler) {}
+
+
+        double expected_length() override
+        {
+            // TODO: this should be something like 1.18 * n
+            // Expectation is undef, we can use median? 
+            const double dd = static_cast<double>(this->sampler->d);
+            // Empirically approximated median
+            const double median_z = dd * (1.0 + 0.18 * std::tanh(dd / 4.07));
+            return median_z;
+        }
+
+        [[nodiscard]] virtual Vector transform(Vector x) override
+        {
+            for (auto &xi : x)
+                xi = gamma * std::tan(M_PI * (xi - 0.5));
+            return x;
+        }
+    };
+
+    struct DoubleWeibullTransformer : SampleTransformer
+    {
+        DoubleWeibullTransformer(const std::shared_ptr<Sampler> sampler) : SampleTransformer(sampler) {}
+
+        [[nodiscard]] virtual Vector transform(Vector x) override
+        {
+            for (auto &xi : x)
+                if (xi < 0.5)
+                    xi = -std::sqrt(-std::log(2.0 * xi));
+                else
+                    xi = std::sqrt(-std::log(2.0 * (1.0 - xi)));
+            return x;
+        }
+    };
+
+
 
     std::shared_ptr<Sampler> get(const size_t dim, const parameters::Modules &mod, const size_t lambda);
 
diff --git a/include/to_string.hpp b/include/to_string.hpp
index 5756f57..5315a95 100644
--- a/include/to_string.hpp
+++ b/include/to_string.hpp
@@ -23,8 +23,8 @@ namespace parameters
     {
         switch (s)
         {
-        case BaseSampler::GAUSSIAN:
-            return "GAUSSIAN";
+        case BaseSampler::UNIFORM:
+            return "UNIFORM";
         case BaseSampler::SOBOL:
             return "SOBOL";
         case BaseSampler::HALTON:
diff --git a/modcma/c_maes/__init__.py b/modcma/c_maes/__init__.py
index b41bc00..1163f02 100644
--- a/modcma/c_maes/__init__.py
+++ b/modcma/c_maes/__init__.py
@@ -11,7 +11,8 @@
     repelling,
     Population,
     Parameters,
-    ModularCMAES
+    ModularCMAES,
+    es
 )
 
 from .cmaescpp.parameters import Settings
\ No newline at end of file
diff --git a/modcma/c_maes/cmaescpp/options.pyi b/modcma/c_maes/cmaescpp/options.pyi
index 77b631b..1420703 100644
--- a/modcma/c_maes/cmaescpp/options.pyi
+++ b/modcma/c_maes/cmaescpp/options.pyi
@@ -1,40 +1,40 @@
 from typing import ClassVar
 
-BIPOP: RestartStrategy
-COTN: CorrectionMethod
-COVARIANCE: MatrixAdaptationType
-CSA: StepSizeAdaptation
-DEFAULT: RecombinationWeights
-EQUAL: RecombinationWeights
-GAUSSIAN: BaseSampler
-HALF_POWER_LAMBDA: RecombinationWeights
-HALTON: BaseSampler
-IPOP: RestartStrategy
-LPXNES: StepSizeAdaptation
-MATRIX: MatrixAdaptationType
-MIRROR: CorrectionMethod
-MIRRORED: Mirror
-MSR: StepSizeAdaptation
-MXNES: StepSizeAdaptation
-NONE: MatrixAdaptationType
-PAIRWISE: Mirror
-PSR: StepSizeAdaptation
-RESTART: RestartStrategy
-SATURATE: CorrectionMethod
-SEPERABLE: MatrixAdaptationType
-SOBOL: BaseSampler
-STOP: RestartStrategy
-TOROIDAL: CorrectionMethod
-TPA: StepSizeAdaptation
-UNIFORM: CenterPlacement
-UNIFORM_RESAMPLE: CorrectionMethod
-X0: CenterPlacement
-XNES: StepSizeAdaptation
-ZERO: CenterPlacement
+# BIPOP: RestartStrategy
+# COTN: CorrectionMethod
+# COVARIANCE: MatrixAdaptationType
+# CSA: StepSizeAdaptation
+# DEFAULT: RecombinationWeights
+# EQUAL: RecombinationWeights
+# UNIFORM: BaseSampler
+# HALF_POWER_LAMBDA: RecombinationWeights
+# HALTON: BaseSampler
+# IPOP: RestartStrategy
+# LPXNES: StepSizeAdaptation
+# MATRIX: MatrixAdaptationType
+# MIRROR: CorrectionMethod
+# MIRRORED: Mirror
+# MSR: StepSizeAdaptation
+# MXNES: StepSizeAdaptation
+# NONE: MatrixAdaptationType
+# PAIRWISE: Mirror
+# PSR: StepSizeAdaptation
+# RESTART: RestartStrategy
+# SATURATE: CorrectionMethod
+# SEPERABLE: MatrixAdaptationType
+# SOBOL: BaseSampler
+# STOP: RestartStrategy
+# TOROIDAL: CorrectionMethod
+# TPA: StepSizeAdaptation
+# UNIFORM: CenterPlacement
+# UNIFORM_RESAMPLE: CorrectionMethod
+# X0: CenterPlacement
+# XNES: StepSizeAdaptation
+# ZERO: CenterPlacement
 
 class BaseSampler:
     __members__: ClassVar[dict] = ...  # read-only
-    GAUSSIAN: ClassVar[BaseSampler] = ...
+    UNIFORM: ClassVar[BaseSampler] = ...
     HALTON: ClassVar[BaseSampler] = ...
     SOBOL: ClassVar[BaseSampler] = ...
     __entries: ClassVar[dict] = ...
@@ -48,6 +48,29 @@ class BaseSampler:
     def name(self) -> str: ...
     @property
     def value(self) -> int: ...
+    
+
+class SampleTranformerType:
+    __members__: ClassVar[dict] = ...  # read-only
+    NONE: ClassVar[SampleTranformerType] = ...
+    GAUSSIAN: ClassVar[SampleTranformerType] = ...
+    SCALED_UNIFORM: ClassVar[SampleTranformerType] = ...
+    LAPLACE: ClassVar[SampleTranformerType] = ...
+    LOGISTIC: ClassVar[SampleTranformerType] = ...
+    CAUCHY: ClassVar[SampleTranformerType] = ...
+    DOUBLE_WEIBULL:  ClassVar[SampleTranformerType] = ...
+    
+    __entries: ClassVar[dict] = ...
+    def __init__(self, value: int) -> None: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
+    def __index__(self) -> int: ...
+    def __int__(self) -> int: ...
+    def __ne__(self, other: object) -> bool: ...
+    @property
+    def name(self) -> str: ...
+    @property
+    def value(self) -> int: ...
 
 class CenterPlacement:
     __members__: ClassVar[dict] = ...  # read-only
@@ -74,6 +97,7 @@ class CorrectionMethod:
     SATURATE: ClassVar[CorrectionMethod] = ...
     TOROIDAL: ClassVar[CorrectionMethod] = ...
     UNIFORM_RESAMPLE: ClassVar[CorrectionMethod] = ...
+    RESAMPLE: ClassVar[CorrectionMethod] = ...
     __entries: ClassVar[dict] = ...
     def __init__(self, value: int) -> None: ...
     def __eq__(self, other: object) -> bool: ...
diff --git a/modcma/c_maes/cmaescpp/parameters.pyi b/modcma/c_maes/cmaescpp/parameters.pyi
index 2a511a3..004a3fd 100644
--- a/modcma/c_maes/cmaescpp/parameters.pyi
+++ b/modcma/c_maes/cmaescpp/parameters.pyi
@@ -17,6 +17,7 @@ class Modules:
     ssa: modcma.c_maes.cmaescpp.options.StepSizeAdaptation
     threshold_convergence: bool
     weights: modcma.c_maes.cmaescpp.options.RecombinationWeights
+    sample_transformation: modcma.c_maes.cmaescpp.options.SampleTranformerType
     def __init__(self) -> None: ...
 
 class Settings:
diff --git a/scripts/distributions/ecdf_plots.ipynb b/scripts/distributions/ecdf_plots.ipynb
new file mode 100644
index 0000000..bb09ef6
--- /dev/null
+++ b/scripts/distributions/ecdf_plots.ipynb
@@ -0,0 +1,449 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import json\n",
+    "import warnings\n",
+    "\n",
+    "import numpy as np\n",
+    "import iohinspector as ins \n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib.colors as mcolors\n",
+    "import seaborn as sns\n",
+    "import polars as pl\n",
+    "\n",
+    "from time import perf_counter\n",
+    "from scipy import stats\n",
+    "\n",
+    "import matplotlib\n",
+    "matplotlib.rcParams['pdf.fonttype'] = 42\n",
+    "matplotlib.rcParams['ps.fonttype'] = 42\n",
+    "matplotlib.rcParams.update({'font.size': 15})\n",
+    "\n",
+    "data = \"../../data/\"\n",
+    "files = [f for f in os.listdir(data)]\n",
+    "one_plus_one = [os.path.join(data, f) for f in files if f.startswith(\"One\") and not f.endswith(\"zip\")]\n",
+    "mu_comma = [os.path.join(data, f) for f in files if f.startswith(\"Mu\") and not f.endswith(\"zip\")]\n",
+    "cma_es = [os.path.join(data, f) for f in files if f.startswith(\"CMA-ES-UN\") and not f.endswith(\"zip\")]\n",
+    "cma_es_sob = [os.path.join(data, f) for f in files if f.startswith(\"CMA-ES-SOB\") and not f.endswith(\"zip\")]\n",
+    "ecma_es = [os.path.join(data, f) for f in files if f.startswith(\"eCMA-ES\") and not f.endswith(\"zip\")]\n",
+    "recma_es = [os.path.join(data, f) for f in files if f.startswith(\"re-eCMA-ES\") and not f.endswith(\"zip\")]\n",
+    "reecma_es = [os.path.join(data, f) for f in files if f.startswith(\"re-eCMA-ES\") and not f.endswith(\"zip\")]\n",
+    "len(one_plus_one), len(mu_comma), len(cma_es), \n",
+    "\n",
+    "# cma_es_sob = ['../../data/CMA-ES-UNIFORM-SCALED_UNIFORM',\n",
+    "#   '../../data/CMA-ES-UNIFORM-GAUSSIAN',] + cma_es_sob\n",
+    "\n",
+    "def fix_legend_labels(ax, n_split, algs, groupby_word = None, reorder=False):\n",
+    "    colors = dict(zip(algs, mcolors.TABLEAU_COLORS))\n",
+    "    lines = ax.get_lines()[::]\n",
+    "    if reorder:\n",
+    "        lines = lines[::2] + lines[1::2]\n",
+    "        \n",
+    "    for line, line_label in zip(lines[:len(lines)//2], lines[len(lines)//2:]):\n",
+    "        if (lab:=line_label.get_label()) in colors:\n",
+    "            for l in (line, line_label):\n",
+    "                l.set_color(colors[lab])\n",
+    "                l.set_linewidth(3)  \n",
+    "                if groupby_word is not None and groupby_word in lab:\n",
+    "                    l.set_linestyle('dashed')  \n",
+    "                else:\n",
+    "                    l.set_linestyle('solid')  \n",
+    "            \n",
+    "    handles, labels = ax.get_legend_handles_labels()\n",
+    "    labels = [l[n_split:] for l in labels[:]]\n",
+    "    idx = np.argsort(labels)\n",
+    "    ax.legend(np.array(handles)[idx], np.array(labels)[idx], fancybox=True, shadow=True, fontsize=13)\n",
+    "    return handles, labels\n",
+    "    \n",
+    "def place_legend_below(ax, handles, labels, show = True, legend_nrow = 1, start_legend = 3, loc_y = -.11):\n",
+    "    box = ax.get_position()\n",
+    "    ax.set_position([box.x0, box.y0 + box.height * 0.1,\n",
+    "            box.width, box.height * 0.9])\n",
+    "    \n",
+    "    ax.legend().remove()\n",
+    "    if show:\n",
+    "        ax.legend(np.array(handles), np.array(labels), loc='upper center',\n",
+    "            fontsize=13, bbox_to_anchor=(start_legend, loc_y), fancybox=True, shadow=True, ncol=np.ceil(len(labels) / legend_nrow), \n",
+    "        )\n",
+    "        \n",
+    "def get_manager(folders):\n",
+    "    manager = ins.DataManager()\n",
+    "    algs = []\n",
+    "    for alg in folders:\n",
+    "        algs.append(os.path.basename(alg))\n",
+    "        manager.add_folder(alg)\n",
+    "    algs.sort()\n",
+    "    \n",
+    "    return manager, algs\n",
+    "\n",
+    "def make_ecdfs(folders, alg_name, file_name_prefix, n_split = 15, groupby_word=None, legend_nrow=1, dims=(2, 3, 5, 10, 20, 40), fids = None):\n",
+    "    manager, algs = get_manager(folders)\n",
+    "    \n",
+    "    if fids is None:\n",
+    "        fids = range(1, 25)\n",
+    "        \n",
+    "    for fid in fids:\n",
+    "        print(fid, end=',')\n",
+    "        f, axes = plt.subplots(1, len(dims), figsize=(20, 7), sharey=True)\n",
+    "\n",
+    "        f.suptitle(f\"{alg_name} on $f_{{{fid}}}$\")\n",
+    "        for dim, ax in zip(dims, axes.ravel()):\n",
+    "            with warnings.catch_warnings():\n",
+    "                warnings.simplefilter(\"ignore\")\n",
+    "                m = manager.select(function_ids=[fid], dimensions=[dim])\n",
+    "                \n",
+    "            x_values = ins.get_sequence(1, dim * 10_000, 50, scale_log=True, cast_to_int=True)\n",
+    "            df = m.load(True, False, include_columns=[\"algorithm_name\", \"function_id\", \"dimension\"], x_values=x_values)\n",
+    "            ins.plot.plot_ecdf(df, ax=ax)\n",
+    "\n",
+    "            ax.set_title(f\"${dim}D$\")\n",
+    "            ax.set_ylabel(\"Fraction Attained\")\n",
+    "            h,l = fix_legend_labels(ax, n_split, algs, groupby_word)\n",
+    "            place_legend_below(ax, h, l, dim == 2, legend_nrow)\n",
+    "                \n",
+    "        plt.savefig(f\"figures/{file_name_prefix}_f{fid}.pdf\")\n",
+    "\n",
+    "def plot_ecdf_agg_dims(folders,alg_name, file_name_prefix, n_split = 15, groupby_word=\"\", legend_nrow=1, dims = (2, 3, 5, 10, 20, 40), fids = None):\n",
+    "    manager, algs = get_manager(folders)\n",
+    "    if fids is None:\n",
+    "        fids = range(1, 25)\n",
+    "        \n",
+    "    f, axes = plt.subplots(1, len(dims), figsize=(5*len(dims), 7), sharey=True)\n",
+    "    for ax, dim in zip(axes, dims):\n",
+    "        for alg in algs:\n",
+    "            m = manager.select(algorithms=[alg], dimensions=[dim], function_ids = fids)\n",
+    "            dt = ins.plot.plot_ecdf(m.load(True, True), ax=ax)\n",
+    "        \n",
+    "        h,l = fix_legend_labels(ax, n_split, algs, groupby_word, reorder=True)\n",
+    "        place_legend_below(ax,h,l, dim == 2, start_legend=.5 + (.5 * len(dims)), legend_nrow=legend_nrow)\n",
+    "        ax.set_title(f\"${dim}D$\")\n",
+    "        ax.set_ylabel(\"Fraction Attained\")\n",
+    "        ax.grid()    \n",
+    "    f.suptitle(alg_name)        \n",
+    "    plt.savefig(f\"figures/{file_name_prefix}_ecdf_agg_dim.pdf\")   \n",
+    "    \n",
+    "def plot_ecdf_agg(folders, alg_name, file_name_prefix, n_split = 15, groupby_word=\"\", legend_nrow=1, dims = (2, 3, 5, 10, 20, 40), fids = None):\n",
+    "    manager, algs = get_manager(folders)\n",
+    "\n",
+    "    if fids is None:\n",
+    "        fids = range(1, 25)\n",
+    "        \n",
+    "    f, ax = plt.subplots(figsize=(8, 5))\n",
+    "    for alg in algs:\n",
+    "        m = manager.select(algorithms=[alg],  function_ids = fids, dimensions=dims)\n",
+    "        dt = ins.plot.plot_ecdf(m.load(True, True), ax=ax)\n",
+    "\n",
+    "    h,l = fix_legend_labels(ax, n_split, algs, groupby_word, reorder=True)\n",
+    "    # place_legend_below(ax,h,l, dim == 2, start_legend=.5 + (.5 * len(dims)), legend_nrow=legend_nrow)\n",
+    "    ax.set_title(alg_name)\n",
+    "    ax.set_ylabel(\"Fraction Attained\")\n",
+    "    ax.grid()    \n",
+    "    plt.savefig(f\"figures/{file_name_prefix}_ecdf_agg.pdf\") \n",
+    "      \n",
+    "def calc_aocc(group, fval_col = \"eaf\", max_budget = 10_000 * 40):\n",
+    "    group = group.cast({\"evaluations\": pl.Int64}).filter(\n",
+    "        pl.col(\"evaluations\") <= max_budget\n",
+    "    )\n",
+    "    new_row = pl.DataFrame(\n",
+    "        {\n",
+    "            \"evaluations\": [0, max_budget],\n",
+    "            fval_col: [group[fval_col].min(), group[fval_col].max()],\n",
+    "        }\n",
+    "    )\n",
+    "    group = (\n",
+    "        pl.concat([group, new_row], how=\"diagonal\")\n",
+    "        .sort(\"evaluations\")\n",
+    "        .fill_null(strategy=\"forward\")\n",
+    "        .fill_null(strategy=\"backward\")\n",
+    "    )\n",
+    "    return group.with_columns(\n",
+    "        (\n",
+    "            (\n",
+    "                pl.col(\"evaluations\").diff(n=1, null_behavior=\"ignore\")\n",
+    "                * (pl.col(fval_col).shift(1))\n",
+    "            )\n",
+    "            / max_budget\n",
+    "        ).alias(\"aocc_contribution\")\n",
+    "    )['aocc_contribution'].sum()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_439760/3172604517.py:86: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`). Consider using `matplotlib.pyplot.close()`.\n",
+      "  f, axes = plt.subplots(1, len(dims), figsize=(20, 7), sharey=True)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "22,23,24,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,1,2,"
+     ]
+    }
+   ],
+   "source": [
+    "make_ecdfs(one_plus_one, \"(1+1)-ES\", \"1p1\", 19)\n",
+    "make_ecdfs(mu_comma, \"($\\mu/\\mu$, $\\lambda$)-$\\sigma$SA-ES\", \"mu_comma\", 22)\n",
+    "make_ecdfs(cma_es, \"CMA-ES\", \"cma_es\", 15)\n",
+    "make_ecdfs(ecma_es, \"eCMA-ES\", \"ecma_es\", 16)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_values = ins.get_sequence(1, 40 * 10_000, 50, scale_log=True, cast_to_int=True)\n",
+    "\n",
+    "manager = ins.DataManager()\n",
+    "for ds in (one_plus_one, mu_comma, cma_es, ecma_es):\n",
+    "    m, algs = get_manager(ds)\n",
+    "    manager += m\n",
+    "\n",
+    "df = manager.load(True, False, include_columns=[\"algorithm_name\", \"function_id\", \"dimension\"], x_values=x_values)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(['CAUCHY',\n",
+       "  'DOUBLE_WEIBULL',\n",
+       "  'GAUSSIAN',\n",
+       "  'LAPLACE',\n",
+       "  'LOGISTIC',\n",
+       "  'SCALED_UNIFORM'],\n",
+       " ['CMA-ES', 'MuCommaLambda', 'OnePlusOne', 'eCMA-ES'])"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "algs = []\n",
+    "for ds in (one_plus_one, mu_comma, cma_es, ecma_es):\n",
+    "    m, ags = get_manager(ds)\n",
+    "    algs.extend(ags)\n",
+    "algs, samplers = list(map(sorted, map(list, map(set, zip(*[x.split(\"-UNIFORM-\") for x in algs])))))\n",
+    "samplers, algs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nice_alg_names = {\n",
+    "    'OnePlusOne': '(1+1)-ES', \n",
+    "    'MuCommaLambda': '($\\mu/\\mu$, $\\lambda$)-$\\sigma$SA-ES', \n",
+    "    'CMA-ES': '($\\mu/\\mu_W$, $\\lambda$)-CMA-ES', \n",
+    "    'eCMA-ES': '($\\mu/\\mu_W$ + $\\lambda$)-CMA-ES',\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1600x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "colors = dict(zip(samplers, mcolors.TABLEAU_COLORS))\n",
+    "markers = dict(zip(algs, \"1234\"))\n",
+    "\n",
+    "linestyle = 'solid'\n",
+    "linewidth = 2\n",
+    "markersize= 15\n",
+    "markeredgewidth = 2\n",
+    "\n",
+    "from matplotlib.lines import Line2D\n",
+    "\n",
+    "\n",
+    "\n",
+    "aoccs = []\n",
+    "f, (ax, ax2) = plt.subplots(1, 2, figsize=(16, 6),  gridspec_kw={'width_ratios': [3, 1]})\n",
+    "aocc = []\n",
+    "\n",
+    "for name, data in df.group_by(\"algorithm_name\"):\n",
+    "    line = ins.transform_fval(data).group_by(\"evaluations\").agg(pl.col(\"eaf\").mean()).sort(\"evaluations\")\n",
+    "    \n",
+    "    alg, sampler = name[0].split(\"-UNIFORM-\")\n",
+    "    gi = 1\n",
+    "    d = 1\n",
+    "    aocc.append((gi, d, calc_aocc(line), alg, sampler))\n",
+    "    ax.semilogx(line['evaluations'], line['eaf'], c=colors[sampler], linestyle=linestyle, alpha=.5, linewidth=linewidth)\n",
+    "    ax.semilogx(line['evaluations'], line['eaf'], c=colors[sampler], marker=markers[alg], linestyle='', alpha=1, markersize=markersize, markeredgewidth=markeredgewidth)\n",
+    "\n",
+    "aocc = pl.DataFrame(aocc, schema=[\"gi\", \"d\", \"aocc\", \"alg\", \"sampler\"], orient='row')\n",
+    "aoccs.append(aocc)\n",
+    "    \n",
+    "handles = [Line2D([0], [0], linestyle='')]\n",
+    "labels = [\"$\\\\bf{Sampler}$\"]\n",
+    "for sampler, col in colors.items():\n",
+    "    handles.append(Line2D([0], [0], label=sampler, color=col, linestyle=linestyle, linewidth=linewidth)) \n",
+    "    labels.append(sampler.title().replace(\"Scaled_\", \"\").replace(\"Double_\", \"d\"))\n",
+    "\n",
+    "\n",
+    "handles.append(Line2D([0], [0], linestyle=''))\n",
+    "labels.append(\"$\\\\bf{Algorithm}$\")    \n",
+    "\n",
+    "\n",
+    "for alg, name in nice_alg_names.items():\n",
+    "    handles.append(Line2D([0], [0], label=alg, color='black', marker=markers[alg], linestyle=linestyle, linewidth=linewidth, markersize=markersize, markeredgewidth=markeredgewidth))\n",
+    "    labels.append(name)\n",
+    "    \n",
+    "handles.append(Line2D([0], [0], linestyle=''))\n",
+    "labels.append(\"\")      \n",
+    "    \n",
+    "ax.legend(handles, labels, loc='upper left', fancybox=True, shadow=True, fontsize=14, ncol=2)\n",
+    "ax.set_ylabel(\"Fraction Attained\")\n",
+    "ax.set_xlabel(\"Evaluations\")\n",
+    "ax.grid(which=\"both\", axis=\"both\")\n",
+    "\n",
+    "\n",
+    "for alg, name in nice_alg_names.items():\n",
+    "    group = aocc.filter(aocc['alg'] == alg)\n",
+    "    idx = np.argsort(group['sampler'])\n",
+    "    x_values = np.array([samplers.index(g) for g in group['sampler'][idx]])\n",
+    "    p = ax2.plot(x_values, group['aocc'][idx], label=name, linestyle='dashed', marker='o')\n",
+    "    ax2.plot(x_values, group['aocc'][idx], marker=markers[alg], linestyle='dashed',  color=p[0].get_color(), alpha=.5)\n",
+    "    \n",
+    "ax2.legend(fontsize=14)\n",
+    "ax2.set_ylabel(\"AUC Attainment Curve\")\n",
+    "ax2.set_xticks(range(len(samplers)), labels=[x.title().replace(\"Double_\", \"d\").replace(\"Scaled_\", \"\") for x in samplers], rotation=25)\n",
+    "ax2.grid()\n",
+    "# ax2.set_ylim(.41, .8)\n",
+    "\n",
+    "# f.suptitle(f\"Group: {gi}\")\n",
+    "plt.tight_layout()\n",
+    "plt.savefig(f\"figures/overview_ecdf.pdf\")\n",
+    "# ax.set_ylim(0, 1.01);\n",
+    "\n",
+    "aoccs = pl.concat(aoccs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x300 with 5 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "function_groups = (\n",
+    "    (1,2,3, 4, 5),\n",
+    "    (6, 7, 8, 9),\n",
+    "    (10, 11, 12, 13, 14),\n",
+    "    (15, 16, 17, 18, 19),\n",
+    "    (20, 21, 22, 23, 24)\n",
+    ")\n",
+    "\n",
+    "aocc = []\n",
+    "for gi, funcs in enumerate(function_groups, 1):\n",
+    "    for name, data in df.group_by(\"algorithm_name\"):\n",
+    "        data = data.filter(pl.col(\"function_id\").is_in(funcs))\n",
+    "        line = ins.transform_fval(data).group_by(\"evaluations\").agg(pl.col(\"eaf\").mean()).sort(\"evaluations\")\n",
+    "        \n",
+    "        alg, sampler = name[0].split(\"-UNIFORM-\")\n",
+    "        aocc.append((gi, calc_aocc(line), alg, sampler))\n",
+    "        ax.semilogx(line['evaluations'], line['eaf'], c=colors[sampler], linestyle=linestyle, alpha=.5, linewidth=linewidth)\n",
+    "        ax.semilogx(line['evaluations'], line['eaf'], c=colors[sampler], marker=markers[alg], linestyle='', alpha=1, markersize=markersize, markeredgewidth=markeredgewidth)\n",
+    "\n",
+    "aoccs = pl.DataFrame(aocc, schema=[\"gi\", \"aocc\", \"alg\", \"sampler\"], orient='row')\n",
+    "\n",
+    "f, axes = plt.subplots(1, 5, figsize=(14, 3), sharey=True)\n",
+    "for gi, ax in enumerate(axes.ravel(), 1):\n",
+    "    \n",
+    "    for alg in nice_alg_names:\n",
+    "        group =  aoccs.filter(gi=gi, alg=alg)\n",
+    "        idx = np.argsort(group['sampler'])\n",
+    "        ax.plot(group['sampler'][idx], group['aocc'][idx], label=nice_alg_names[alg], marker='o', linestyle='dashed')\n",
+    "    \n",
+    "    if gi == 5: \n",
+    "        h, l = ax.get_legend_handles_labels()   \n",
+    "        ax.legend(np.array(h), np.array(l), loc='upper center',\n",
+    "                fontsize=11, bbox_to_anchor=(-.1, 1), fancybox=True, shadow=True, ncol=2,\n",
+    "        )\n",
+    "    if gi == 1:\n",
+    "        ax.set_ylabel(\"AUC Attainment Curve\", fontsize=12)\n",
+    "        \n",
+    "    ax.set_xticks(range(len(samplers)), labels=[x.title().replace(\"Double_\", \"d\").replace(\"Scaled_\", \"\") for x in samplers], rotation=25, fontsize=13)\n",
+    "    ax.grid()\n",
+    "    ax.set_title(f\"Group {gi}\", fontsize=12)\n",
+    "    \n",
+    "plt.subplots_adjust(wspace=0.1, bottom=.2, left=0.05, right=.98)\n",
+    "plt.savefig(\"figures/auc_per_group.pdf\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/scripts/distributions/plots.ipynb b/scripts/distributions/plots.ipynb
new file mode 100644
index 0000000..3e2502e
--- /dev/null
+++ b/scripts/distributions/plots.ipynb
@@ -0,0 +1,516 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns \n",
+    "from modcma.c_maes import (\n",
+    "    sampling\n",
+    "    ModularCMAES, parameters, options, constants, utils, es\n",
+    ")\n",
+    "\n",
+    "\n",
+    "import matplotlib\n",
+    "matplotlib.rcParams['pdf.fonttype'] = 42\n",
+    "matplotlib.rcParams['ps.fonttype'] = 42\n",
+    "matplotlib.rcParams.update({'font.size': 15})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "samplers = (\n",
+    "    sampling.CauchyTransformer,\n",
+    "    sampling.DoubleWeibullTransformer,\n",
+    "    sampling.GaussianTransformer,\n",
+    "    sampling.LaplaceTransformer,\n",
+    "    sampling.LogisticTransformer,\n",
+    "    sampling.UniformScaler,    \n",
+    ")\n",
+    "\n",
+    "\n",
+    "def get_sampler(d, transformer):\n",
+    "    base_sampler = sampling.Uniform(d)\n",
+    "    sampler = sampler_cls(base_sampler)\n",
+    "    return sampler\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 700x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "n_samples = 10000\n",
+    "\n",
+    "def get_name(sampler_cls):\n",
+    "    return sampler_cls.__name__.replace(\"Transformer\", \"\").replace(\"Scaler\", \"\").replace(\"Double\", \"d\")\n",
+    "\n",
+    "records = []\n",
+    "dims = np.array((2, 5, 10, 20, 50, 100, 200, 500, 1000))\n",
+    "for i, (sampler_cls) in enumerate(samplers):\n",
+    "    for d in dims:\n",
+    "        sampler = get_sampler(d, sampler_cls)\n",
+    "        samples = [(get_name(sampler_cls), d, np.linalg.norm(sampler())) for _ in range(n_samples)]\n",
+    "        records.extend(samples)\n",
+    "\n",
+    "colums = [\"Sampler\", r\"$n$\", r\"$||z||_2$\"]\n",
+    "data = pd.DataFrame(records, columns = colums)\n",
+    "\n",
+    "palette = dict(zip(sorted(data['Sampler'].unique()), sns.color_palette(\"tab10\")))\n",
+    "\n",
+    "f, (ax1, ax2) = plt.subplots(2, 1, figsize=(7, 6), sharex=True)\n",
+    "sns.boxenplot(data[data['Sampler'] != 'Cauchy'], x=colums[1], hue=colums[0], y=colums[2], fill=False, gap=.1, showfliers=False, ax=ax1, palette=palette)\n",
+    "ax1.plot(range(len(dims)), np.sqrt(dims), marker='D', markersize=5, label=r'$\\sqrt{n}$', color='black')\n",
+    "\n",
+    "\n",
+    "ax1.legend()\n",
+    "ax1.grid()\n",
+    "\n",
+    "sns.boxenplot(data[data['Sampler'] == 'Cauchy'], x=colums[1], hue=colums[0], y=colums[2], fill=False, gap=.1, showfliers=False, ax=ax2, palette=palette)\n",
+    "ax2.plot(range(len(dims)), 1.18 * dims, marker='D', markersize=5, label=r'1.18${n}$', color='black')\n",
+    "ax2.set_yscale(\"log\")\n",
+    "ax2.legend(loc='upper left')\n",
+    "ax2.grid()\n",
+    "plt.tight_layout()\n",
+    "plt.savefig(\"figures/distributions_z.pdf\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2400x500 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "n_samples = 1000000\n",
+    "n = 2\n",
+    "\n",
+    "matplotlib.rcParams.update({'font.size': 20})\n",
+    "\n",
+    "def angle_with_all_ones(vector):\n",
+    "    # Convert input to a numpy array\n",
+    "    vector = np.array(vector)\n",
+    "    all_ones = np.ones_like(vector)\n",
+    "    dot_product = np.dot(vector, all_ones)\n",
+    "\n",
+    "    # Compute the magnitudes\n",
+    "    magnitude_v = np.linalg.norm(vector)\n",
+    "    magnitude_ones = np.linalg.norm(all_ones)\n",
+    "\n",
+    "    # Compute the cosine of the angle\n",
+    "    cos_theta = dot_product / (magnitude_v * magnitude_ones)\n",
+    "\n",
+    "    # Ensure the value is within the valid domain for arccos [-1, 1] (handle numerical precision issues)\n",
+    "    cos_theta = np.clip(cos_theta, -1.0, 1.0)\n",
+    "\n",
+    "    # Compute the angle in radians and convert to degrees\n",
+    "    angle_radians = np.arccos(cos_theta)\n",
+    "    angle_degrees = np.degrees(angle_radians)\n",
+    "    \n",
+    "    clockwise = -np.sign(dot_product * np.cross(vector, all_ones))\n",
+    "    \n",
+    "    return angle_degrees * clockwise\n",
+    "\n",
+    "\n",
+    "f, axes = plt.subplots(1, len(samplers), figsize=(4*len(samplers), 5 * (2 - 1)), sharex=True, sharey='row')\n",
+    "\n",
+    "axes[0].set_ylabel(r\"Density\")\n",
+    "for ax, sampler_cls in zip(axes.ravel(), samplers):\n",
+    "    sampler = get_sampler(n, sampler_cls)\n",
+    "    samples = np.array([sampler() for s in range(n_samples)]).T\n",
+    "    # samples = np.abs(samples)\n",
+    "    directions = samples / np.linalg.norm(samples, axis=0)\n",
+    "    angles2 = np.array([angle_with_all_ones(s) for s in directions.T]).ravel()\n",
+    "    \n",
+    "    ax.hist(angles2, bins=100, density=True)\n",
+    "    # ax.set_title(f\"{get_name(sampler_cls)}: ({np.mean(angles2):.2f}+-{np.std(angles2):.2f})\")\n",
+    "    ax.set_title(f\"{get_name(sampler_cls)}\")\n",
+    "\n",
+    "    ax.grid()\n",
+    "    \n",
+    "    ax.xaxis.set_tick_params(which='both', labelbottom=True)\n",
+    "    ax.set_xlabel(r\"$\\theta\\ vs. \\mathbf{1}$\")\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.savefig(f\"figures/angles_vs_unitvec_n{n}.pdf\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2400x500 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "n_samples = int(10e5)\n",
+    "n = 2\n",
+    "\n",
+    "matplotlib.rcParams.update({'font.size': 20})\n",
+    "\n",
+    "f, axes = plt.subplots(1, len(samplers), figsize=(4*len(samplers), 5 * (2 - 1)), sharex=True, sharey='row')\n",
+    "\n",
+    "axes[0].set_ylabel(r\"Density\")\n",
+    "for ax, sampler_cls in zip(axes.ravel(), samplers):\n",
+    "    sampler = get_sampler(n, sampler_cls)\n",
+    "    samples = np.array([sampler() for s in range(n_samples)]).T\n",
+    "    # samples = np.abs(samples)\n",
+    "    # directions = samples / np.linalg.norm(samples, axis=0)\n",
+    "    try:\n",
+    "        sns.kdeplot(x=samples[0].clip(-100, 100), y=samples[1].clip(-100, 100), ax=ax)\n",
+    "    except:\n",
+    "        continue\n",
+    "    ax.set_title(f\"{get_name(sampler_cls)}\")\n",
+    "\n",
+    "    # ax.xaxis.set_tick_params(which='both', labelbottom=True)\n",
+    "    # ax.set_xlabel(r\"$\\theta\\ vs. \\mathbf{1}$\")\n",
+    "    ax.set_xlim(-4, 4)\n",
+    "    ax.set_ylim(-4, 4)\n",
+    "    ax.grid()\n",
+    "\n",
+    "plt.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "d = 2 \n",
+    "\n",
+    "def sphere(x):\n",
+    "    x = np.asarray(x)\n",
+    "    return x.dot(x)\n",
+    "\n",
+    "def get_meshgrid(objective_function, lb, ub, delta: float = 0.025):\n",
+    "    x = np.arange(lb, ub + delta, delta)\n",
+    "    y = np.arange(lb, ub + delta, delta)\n",
+    "\n",
+    "    if hasattr(objective_function, \"optimum\"):\n",
+    "        xo, yo = objective_function.optimum.x\n",
+    "        x = np.sort(np.r_[x, xo])\n",
+    "        y = np.sort(np.r_[y, yo])\n",
+    "\n",
+    "    X, Y = np.meshgrid(x, y)\n",
+    "\n",
+    "    Z = np.zeros(X.shape)\n",
+    "    for idx1 in range(X.shape[0]):\n",
+    "        for idx2 in range(X.shape[1]):\n",
+    "            Z[idx1, idx2] = objective_function([X[idx1, idx2], Y[idx1, idx2]])\n",
+    "    return X, Y, Z\n",
+    "\n",
+    "\n",
+    "X, Y, Z = get_meshgrid(sphere, -5, 3)\n",
+    "\n",
+    "x0 = np.array([-4, -4])\n",
+    "\n",
+    "\n",
+    "modules = parameters.Modules()\n",
+    "modules.sample_transformation = options.SampleTranformerType(1)\n",
+    "settings = parameters.Settings(dim=2, modules=modules, x0=x0, sigma0=2)\n",
+    "\n",
+    "utils.set_seed(10)\n",
+    "cma = ModularCMAES(settings)\n",
+    "\n",
+    "\n",
+    "f, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 5), sharex=True, sharey=True)\n",
+    "\n",
+    "ax1.contourf(\n",
+    "    X, Y, np.log10(Z), levels=200, cmap=\"Spectral\", zorder=-1, vmin=-1, vmax=2.5\n",
+    ")\n",
+    "ax2.contourf(\n",
+    "    X, Y, np.log10(Z), levels=200, cmap=\"Spectral\", zorder=-1, vmin=-1, vmax=2.5\n",
+    ")\n",
+    "\n",
+    "for i in range(3):\n",
+    "    m = cma.p.adaptation.m.copy()\n",
+    "    C = cma.p.adaptation.C.copy()\n",
+    "    sigma = cma.p.mutation.sigma\n",
+    "    theta = np.degrees(np.arctan2(C[1, 0], C[0, 0]))\n",
+    "    \n",
+    "    color = 'black'\n",
+    "    p = ax1.scatter(*m, label=i, color=color)\n",
+    "    \n",
+    "    current = Ellipse(\n",
+    "        m,\n",
+    "        *(sigma * np.diag(C)),\n",
+    "        angle=theta,\n",
+    "        facecolor=\"none\",\n",
+    "        edgecolor=p.get_edgecolor(),\n",
+    "        linewidth=2,\n",
+    "        linestyle=\"dashed\",\n",
+    "        zorder=0,\n",
+    "    )\n",
+    "    ax1.add_patch(current)\n",
+    "    cma.step(sphere)\n",
+    "    \n",
+    "    \n",
+    "    \n",
+    "modules = parameters.Modules()\n",
+    "modules.sample_transformation = options.SampleTranformerType(2)\n",
+    "settings = parameters.Settings(dim=2, modules=modules, x0=x0, sigma0=2)\n",
+    "\n",
+    "utils.set_seed(10)\n",
+    "cma = ModularCMAES(settings)\n",
+    "\n",
+    "for i in range(3):\n",
+    "    m = cma.p.adaptation.m.copy()\n",
+    "    C = cma.p.adaptation.C.copy()\n",
+    "    sigma = cma.p.mutation.sigma\n",
+    "    theta = np.degrees(np.arctan2(C[1, 0], C[0, 0]))\n",
+    "    \n",
+    "    color = 'black'\n",
+    "    p = ax2.scatter(*m, label=i, color=color)\n",
+    "    \n",
+    "    \n",
+    "    width = sigma * C[0, 0]\n",
+    "    height = sigma * C[1, 1]\n",
+    "    \n",
+    "    current = Rectangle(\n",
+    "       (-width / 2, -height / 2), width, height,\n",
+    "        facecolor=\"none\",\n",
+    "        edgecolor=p.get_edgecolor(), \n",
+    "        linewidth=2,\n",
+    "        linestyle=\"dashed\",\n",
+    "        zorder=0,   \n",
+    "    )\n",
+    "    transformation = (\n",
+    "        Affine2D()\n",
+    "        .rotate_deg(theta)  \n",
+    "        .translate(*m)\n",
+    "        + ax2.transData  \n",
+    "    )\n",
+    "    \n",
+    "    current.set_transform(transformation)\n",
+    "    \n",
+    "    ax2.add_patch(current)\n",
+    "    cma.step(sphere)\n",
+    "    \n",
+    "\n",
+    "for ax in ax1, ax2:\n",
+    "    ax.set_aspect(\"equal\")\n",
+    "    ax.set_ylim(-5, 0)\n",
+    "    ax.set_xticks([])\n",
+    "    ax.set_yticks([])\n",
+    "plt.tight_layout()\n",
+    "plt.savefig(\"figures/adaptation.pdf\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_one_plus_one(problem, dim, sampler):\n",
+    "    modules = parameters.Modules()\n",
+    "    modules.sample_transformation = options.SampleTranformerType(sampler)\n",
+    "    \n",
+    "    x0 = np.random.uniform(-5, 5, size=dim)\n",
+    "    return es.OnePlusOneES(\n",
+    "        dim,\n",
+    "        x0=x0,\n",
+    "        f0=problem(x0),\n",
+    "        sigma0=1,\n",
+    "        modules=modules,\n",
+    "    )\n",
+    "    \n",
+    "names = sorted([options.SampleTranformerType(sampler).name.title().replace(\"Scaled_\", \"\").replace(\"Double_\", \"d\") \n",
+    "                for sampler in range(1, 7)], key=lambda x:x.lower())\n",
+    "colors = dict(zip(names, sns.color_palette(\"tab10\")))\n",
+    "\n",
+    "n_evals = 10000\n",
+    "n_runs = 1000\n",
+    "\n",
+    "linestyle = {\n",
+    "    2: \"solid\",\n",
+    "    10: \"dashed\",\n",
+    "    50: \"dotted\"\n",
+    "}\n",
+    "\n",
+    "np.random.seed(1)\n",
+    "utils.set_seed(1)\n",
+    "linewidth = 2\n",
+    "\n",
+    "f, ax = plt.subplots(figsize=(7, 4))\n",
+    "for sampler in range(1, 7):\n",
+    "    for d in (2, 10, 50):\n",
+    "        f = np.zeros(n_evals)\n",
+    "        s = np.zeros(n_evals)\n",
+    "        for r in range(n_runs):\n",
+    "            alg = get_one_plus_one(sphere, d, sampler)\n",
+    "            for e in range(n_evals):\n",
+    "                f[e] += alg.f\n",
+    "                s[e] += alg.sigma\n",
+    "                alg.step(sphere)\n",
+    "        \n",
+    "        f /= n_runs\n",
+    "        s /= n_runs\n",
+    "        sampler_name = get_name(alg.sampler.__class__)\n",
+    "        ax.plot(s, color=colors[sampler_name], linestyle=linestyle[d], label=sampler_name, linewidth=linewidth)\n",
+    "\n",
+    "ax.legend()\n",
+    "ax.set_yscale(\"log\")\n",
+    "ax.set_xscale(\"log\")\n",
+    "\n",
+    "from matplotlib.lines import Line2D\n",
+    "\n",
+    "handles = [Line2D([0], [0], linestyle='')]\n",
+    "labels = [\"$\\\\bf{Sampler}$\"]\n",
+    "\n",
+    "for alg, color in colors.items():\n",
+    "    handles.append(Line2D([0], [0], label=alg, color=color, linewidth=linewidth))\n",
+    "    labels.append(alg)\n",
+    "\n",
+    "\n",
+    "handles.append(Line2D([0], [0], linestyle=''))\n",
+    "labels.append(\"$\\\\mathbf{n}$\")\n",
+    "\n",
+    "for alg, color in linestyle.items():\n",
+    "    handles.append(Line2D([0], [0], label=alg, color='black', linestyle=color, linewidth=linewidth))\n",
+    "    labels.append(alg)\n",
+    "\n",
+    "handles.append(Line2D([0], [0], linestyle=''))\n",
+    "labels.append(\"\")      \n",
+    "handles.append(Line2D([0], [0], linestyle=''))\n",
+    "labels.append(\"\")      \n",
+    "\n",
+    "ax.legend(handles, labels, loc='lower left', fancybox=True, shadow=True, fontsize=13, ncol=2)\n",
+    "ax.set_ylim(1e-10, 10)\n",
+    "ax.grid(which=\"both\", axis=\"both\")\n",
+    "ax.set_ylabel(r\"$\\sigma$\")\n",
+    "ax.set_xlabel(r\"Evaluations\")\n",
+    "plt.tight_layout()\n",
+    "plt.savefig(\"figures/1p1_sigma.pdf\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "samplers = [\n",
+    "    lambda a: stats.cauchy(2.0, scale=1).rvs(size=a),\n",
+    "    lambda a: stats.dweibull(2.0, scale=1).rvs(size=a),\n",
+    "    lambda a: stats.norm().rvs(size=a),\n",
+    "    lambda a: stats.laplace().rvs(size=a),\n",
+    "    lambda a: stats.logistic().rvs(size=a),\n",
+    "    lambda a: stats.uniform().rvs(size=a),\n",
+    "]\n",
+    "\n",
+    "labels=[\"Cauchy\", \"dWeibull\", \"Gaussian\",  \"Laplace\", \"Logistic\", \"Uniform\"]\n",
+    "\n",
+    "def time_sampler(sampler, n = 1_000_000):\n",
+    "    start = perf_counter()\n",
+    "    sampler(n)\n",
+    "    return perf_counter() - start\n",
+    "\n",
+    "t = []\n",
+    "for label, sampler in zip(labels, samplers):\n",
+    "    times = [time_sampler(sampler) for _ in range(1000)]\n",
+    "    t.append((label, np.mean(times), np.std(times)))\n",
+    "    \n",
+    "time_data = pl.DataFrame(t, schema=['sampler', 'mean', 'std'], orient='row')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure(figsize=(6, 3))\n",
+    "p = plt.errorbar(\n",
+    "    time_data['sampler'], time_data['mean'], time_data['std'], \n",
+    "    marker='_', markersize=20, \n",
+    "    capsize=5,\n",
+    "    markeredgewidth=2, \n",
+    "    elinewidth=2, \n",
+    "    linestyle=''\n",
+    ")\n",
+    "\n",
+    "\n",
+    "plt.grid()\n",
+    "plt.xticks(rotation=25);\n",
+    "plt.ylabel(\"Time [s]\", color=p[0].get_color())\n",
+    "plt.yticks(color=p[0].get_color())\n",
+    "ax1 = plt.gca()\n",
+    "ax2 = plt.twinx()\n",
+    "g_time = time_data.filter(sampler='Gaussian')['mean'] \n",
+    "\n",
+    "\n",
+    "ax2.plot(time_data['sampler'], (time_data['mean'] - g_time) / g_time, color='red', marker='x', linestyle='', markersize=7, markeredgewidth=2)\n",
+    "\n",
+    "ax2.set_ylabel(\"vs. Gaussian\", color='red')\n",
+    "ax2.plot(time_data['sampler'], np.zeros(6), linestyle='dashed', zorder=-100, color='grey')\n",
+    "plt.yticks(color='red')\n",
+    "ax2.set_ylim(*((np.array(ax1.get_ylim()) - g_time[0]) / g_time[0]))\n",
+    "plt.tight_layout()\n",
+    "plt.savefig(\"figures/time.pdf\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/scripts/distributions/run.sh b/scripts/distributions/run.sh
new file mode 100644
index 0000000..0820408
--- /dev/null
+++ b/scripts/distributions/run.sh
@@ -0,0 +1,23 @@
+python run.py --sampler 1 --cache_size=16 --base_sampler=1 --logged&
+python run.py --sampler 2 --cache_size=16 --base_sampler=1 --logged&
+
+python run.py --sampler 1 --cache_size=32 --base_sampler=1 --logged&
+python run.py --sampler 2 --cache_size=32 --base_sampler=1 --logged&
+
+python run.py --sampler 1 --cache_size=64 --base_sampler=1 --logged&
+python run.py --sampler 2 --cache_size=64 --base_sampler=1 --logged&
+
+python run.py --sampler 1 --cache_size=128 --base_sampler=1 --logged&
+python run.py --sampler 2 --cache_size=128 --base_sampler=1 --logged&
+
+python run.py --sampler 1 --base_sampler=1 --logged&
+python run.py --sampler 2 --base_sampler=1 --logged&
+
+
+for i in {1..6}; 
+do 
+    for j in {1..6}; 
+    do 
+        python run.py --sampler $i --logged --alg &j &
+    done
+done 
diff --git a/src/bounds.cpp b/src/bounds.cpp
index a363aeb..26f09cc 100644
--- a/src/bounds.cpp
+++ b/src/bounds.cpp
@@ -9,15 +9,26 @@ static double modulo2(const int x)
 
 namespace bounds
 {
-	Mask BoundCorrection::is_out_of_bounds(const Vector& xi) const
+	
+	Mask is_out_of_bounds(const Vector &xi, const Vector &lb, const Vector &ub) 
 	{
 		return xi.array() < lb.array() || xi.array() > ub.array();
 	}
 
+	bool any_out_of_bounds(const Vector &xi, const Vector &lb, const Vector &ub)
+	{
+		return bounds::is_out_of_bounds(xi, lb, ub).any();
+	}
+
+	
+	Mask BoundCorrection::is_out_of_bounds(const Vector& xi) const
+	{
+		return bounds::is_out_of_bounds(xi, lb, ub);
+	}
 
 	Vector BoundCorrection::delta_out_of_bounds(const Vector& xi, const Mask& oob) const
 	{
-		return 	(oob).select((xi - lb).cwiseQuotient(db), xi);;
+		return (oob).select((xi - lb).cwiseQuotient(db), xi);;
 	}
 
 	void BoundCorrection::correct(const Eigen::Index i, parameters::Parameters& p)
@@ -32,7 +43,6 @@ namespace bounds
 		}
 	}
 
-
 	Vector COTN::correct_x(const Vector& xi, const Mask& oob)
 	{
 		const Vector y = delta_out_of_bounds(xi, oob);
diff --git a/src/es.cpp b/src/es.cpp
new file mode 100644
index 0000000..7185cf7
--- /dev/null
+++ b/src/es.cpp
@@ -0,0 +1,100 @@
+#include "es.hpp"
+#include "bounds.hpp"
+
+namespace es
+{
+
+    Vector OnePlusOneES::sample()
+    {
+        size_t n_rej = 0;
+        Vector x1;
+        do
+        {
+            const Vector z = (*sampler)();
+            x1 = x + sigma * z;
+
+            const auto mask = corrector->is_out_of_bounds(x1);
+            if (mask.any())
+                x1 = corrector->correct_x(x1, mask);
+
+        } while (rejection_sampling && n_rej++ < 5*d && bounds::any_out_of_bounds(x1, corrector->lb, corrector->ub) );
+        return x1;
+    }
+
+    void OnePlusOneES::step(FunctionType &objective)
+    {
+        const auto x1 = sample();
+        const auto f1 = objective(x1);
+        const bool has_improved = f1 < f;
+        sigma *= pow(std::exp(static_cast<double>(has_improved) - 0.2), decay);
+        if (has_improved)
+        {
+            x = x1;
+            f = f1;
+        }
+        t++;
+    }
+    void OnePlusOneES::operator()(FunctionType &objective)
+    {
+        while (t < budget && f > target)
+            step(objective);
+    }
+
+    Vector MuCommaLambdaES::sample(const Vector si)
+    {
+        size_t n_rej = 0;
+        Vector x;
+        do
+        {
+            const Vector z = (*sampler)();
+            x = m.array() + (si.array() * z.array());
+
+            const auto mask = corrector->is_out_of_bounds(x);
+            if (mask.any())
+                x = corrector->correct_x(x, mask);
+
+        } while (rejection_sampling && n_rej++ < 5*d && bounds::any_out_of_bounds(x, corrector->lb, corrector->ub));
+        return x;
+    }
+
+    void MuCommaLambdaES::step(FunctionType &objective)
+    {
+        static sampling::Gaussian g_sigma_sampler(1);
+
+        for (size_t i = 0; i < lambda; i++)
+        {
+            const double psi_k = std::exp(tau * g_sigma_sampler()[0]);
+            const Vector psi_kv = (tau_i * (*sigma_sampler)()).array().exp().matrix();
+            S.col(i) = sigma.array() * psi_kv.array() * psi_k;
+            X.col(i) = sample(S.col(i));
+            f(i) = objective(X.col(i));
+            e++;
+        }
+        const auto idx = utils::sort_indexes(f);
+        X = X(Eigen::all, idx).eval();
+        S = S(Eigen::all, idx).eval();
+        f = f(idx).eval();
+
+        if (f[0] < f_min)
+        {
+            f_min = f[0];
+            x_min = X.col(0);
+        }
+
+        sigma.setZero();
+        m.setZero();
+
+        for (size_t i = 0; i < mu; i++)
+        {
+            m += mu_inv * X.col(i);
+            sigma += mu_inv * S.col(i);
+        }
+        t++;
+    }
+
+    void MuCommaLambdaES::operator()(FunctionType &objective)
+    {
+        while (e < budget && f_min > target)
+            step(objective);
+    }
+}
diff --git a/src/interface.cpp b/src/interface.cpp
index 987a5ad..696a1cb 100644
--- a/src/interface.cpp
+++ b/src/interface.cpp
@@ -8,6 +8,7 @@
 
 #include "c_maes.hpp"
 #include "to_string.hpp"
+#include "es.hpp"
 
 namespace py = pybind11;
 
@@ -29,11 +30,21 @@ void define_options(py::module &main)
         .export_values();
 
     py::enum_<BaseSampler>(m, "BaseSampler")
-        .value("GAUSSIAN", BaseSampler::GAUSSIAN)
+        .value("UNIFORM", BaseSampler::UNIFORM)
         .value("SOBOL", BaseSampler::SOBOL)
         .value("HALTON", BaseSampler::HALTON)
         .export_values();
 
+    py::enum_<SampleTranformerType>(m, "SampleTranformerType")
+        .value("NONE", SampleTranformerType::NONE)
+        .value("GAUSSIAN", SampleTranformerType::GAUSSIAN)
+        .value("SCALED_UNIFORM", SampleTranformerType::SCALED_UNIFORM)
+        .value("LAPLACE", SampleTranformerType::LAPLACE)
+        .value("LOGISTIC", SampleTranformerType::LOGISTIC)
+        .value("CAUCHY", SampleTranformerType::CAUCHY)
+        .value("DOUBLE_WEIBULL", SampleTranformerType::DOUBLE_WEIBULL)
+        .export_values();
+
     py::enum_<Mirror>(m, "Mirror")
         .value("NONE", Mirror::NONE)
         .value("MIRRORED", Mirror::MIRRORED)
@@ -57,6 +68,7 @@ void define_options(py::module &main)
         .value("UNIFORM_RESAMPLE", CorrectionMethod::UNIFORM_RESAMPLE)
         .value("SATURATE", CorrectionMethod::SATURATE)
         .value("TOROIDAL", CorrectionMethod::TOROIDAL)
+        .value("RESAMPLE", CorrectionMethod::RESAMPLE)
         .export_values();
 
     py::enum_<RestartStrategyType>(m, "RestartStrategy")
@@ -104,7 +116,8 @@ void define_samplers(py::module &main)
 
     py::class_<Sampler, std::shared_ptr<Sampler>>(m, "Sampler")
         .def_readonly("d", &Sampler::d)
-        .def("reset", &Sampler::reset);
+        .def("reset", &Sampler::reset)
+        .def("expected_length", &Sampler::expected_length);
 
     py::class_<PySampler, Sampler, std::shared_ptr<PySampler>>(m, "PySampler")
         .def(py::init<size_t, std::function<double()>>(), py::arg("d"), py::arg("function"))
@@ -143,6 +156,51 @@ void define_samplers(py::module &main)
         .def(py::init<const std::shared_ptr<Sampler>, size_t>(),
              py::arg("sampler"), py::arg("n_samples"))
         .def("__call__", &Orthogonal::operator());
+
+    py::class_<SampleTransformer, Sampler, std::shared_ptr<SampleTransformer>>(m, "SampleTransformer")
+        .def("raw", &SampleTransformer::raw);
+
+    py::class_<IdentityTransformer, SampleTransformer, std::shared_ptr<IdentityTransformer>>(m, "IdentityTransformer")
+        .def(py::init<const std::shared_ptr<Sampler>>(), py::arg("sampler"))
+        .def("transform", &IdentityTransformer::transform)
+        .def("__call__", &IdentityTransformer::operator())
+        .def("expected_length", &IdentityTransformer::expected_length);
+
+    py::class_<GaussianTransformer, SampleTransformer, std::shared_ptr<GaussianTransformer>>(m, "GaussianTransformer")
+        .def(py::init<const std::shared_ptr<Sampler>>(), py::arg("sampler"))
+        .def("transform", &GaussianTransformer::transform)
+        .def("__call__", &GaussianTransformer::operator())
+        .def("expected_length", &GaussianTransformer::expected_length);
+
+    py::class_<UniformScaler, SampleTransformer, std::shared_ptr<UniformScaler>>(m, "UniformScaler")
+        .def(py::init<const std::shared_ptr<Sampler>>(), py::arg("sampler"))
+        .def("transform", &UniformScaler::transform)
+        .def("__call__", &UniformScaler::operator())
+        .def("expected_length", &UniformScaler::expected_length);
+
+    py::class_<LaplaceTransformer, SampleTransformer, std::shared_ptr<LaplaceTransformer>>(m, "LaplaceTransformer")
+        .def(py::init<const std::shared_ptr<Sampler>>(), py::arg("sampler"))
+        .def("transform", &LaplaceTransformer::transform)
+        .def("__call__", &LaplaceTransformer::operator())
+        .def("expected_length", &LaplaceTransformer::expected_length);
+
+    py::class_<LogisticTransformer, SampleTransformer, std::shared_ptr<LogisticTransformer>>(m, "LogisticTransformer")
+        .def(py::init<const std::shared_ptr<Sampler>>(), py::arg("sampler"))
+        .def("transform", &LogisticTransformer::transform)
+        .def("__call__", &LogisticTransformer::operator())
+        .def("expected_length", &LogisticTransformer::expected_length);
+
+    py::class_<CauchyTransformer, SampleTransformer, std::shared_ptr<CauchyTransformer>>(m, "CauchyTransformer")
+        .def(py::init<const std::shared_ptr<Sampler>>(), py::arg("sampler"))
+        .def("transform", &CauchyTransformer::transform)
+        .def("__call__", &CauchyTransformer::operator())
+        .def("expected_length", &CauchyTransformer::expected_length);
+
+    py::class_<DoubleWeibullTransformer, SampleTransformer, std::shared_ptr<DoubleWeibullTransformer>>(m, "DoubleWeibullTransformer")
+        .def(py::init<const std::shared_ptr<Sampler>>(), py::arg("sampler"))
+        .def("transform", &DoubleWeibullTransformer::transform)
+        .def("__call__", &DoubleWeibullTransformer::operator())
+        .def("expected_length", &DoubleWeibullTransformer::expected_length);
 }
 
 void define_utils(py::module &main)
@@ -153,7 +211,7 @@ void define_utils(py::module &main)
     m.def("i8_sobol", &i8_sobol, py::arg("dim_num"), py::arg("seed"), py::arg("quasi"));
     m.def("compute_ert", &utils::compute_ert, py::arg("running_times"), py::arg("budget"));
     m.def("set_seed", &rng::set_seed, py::arg("seed"), "Set the random seed");
-    m.def("random_uniform", &random_double<rng::uniform<double>>, "Generate a uniform random number in [-1, 1]");
+    m.def("random_uniform", &random_double<rng::uniform<double>>, "Generate a uniform random number in [0, 1]");
     m.def("random_normal", &random_double<rng::normal<double>>, "Generate a standard normal random number");
 
     py::class_<rng::Shuffler>(m, "Shuffler")
@@ -161,14 +219,13 @@ void define_utils(py::module &main)
         .def(py::init<size_t>(), py::arg("stop"))
         .def("next", &rng::Shuffler::next)
         .def_readwrite("start", &rng::Shuffler::start)
-		.def_readwrite("stop", &rng::Shuffler::stop)
-		.def_readwrite("n", &rng::Shuffler::n)
-		.def_readwrite("seed", &rng::Shuffler::seed)
-		.def_readwrite("offset", &rng::Shuffler::offset)
-		.def_readwrite("multiplier", &rng::Shuffler::multiplier)
-		.def_readwrite("modulus", &rng::Shuffler::modulus)
-		.def_readwrite("found", &rng::Shuffler::found)
-        ;
+        .def_readwrite("stop", &rng::Shuffler::stop)
+        .def_readwrite("n", &rng::Shuffler::n)
+        .def_readwrite("seed", &rng::Shuffler::seed)
+        .def_readwrite("offset", &rng::Shuffler::offset)
+        .def_readwrite("multiplier", &rng::Shuffler::multiplier)
+        .def_readwrite("modulus", &rng::Shuffler::modulus)
+        .def_readwrite("found", &rng::Shuffler::found);
 
     py::class_<rng::CachedShuffleSequence>(m, "CachedShuffleSequence")
         .def(py::init<size_t>(), py::arg("dim"))
@@ -252,8 +309,8 @@ void define_repelling(py::module &main)
     m.def("euclidian", &distance::euclidian, py::arg("u"), py::arg("v"));
     m.def("manhattan", &distance::manhattan, py::arg("u"), py::arg("v"));
     m.def("mahanolobis", &distance::mahanolobis, py::arg("u"), py::arg("v"), py::arg("C_inv"));
-    m.def("hill_valley_test", &distance::hill_valley_test, 
-        py::arg("u"), py::arg("v"), py::arg("f"), py::arg("n_evals"));
+    m.def("hill_valley_test", &distance::hill_valley_test,
+          py::arg("u"), py::arg("v"), py::arg("f"), py::arg("n_evals"));
 }
 
 void define_matrix_adaptation(py::module &main)
@@ -266,7 +323,7 @@ void define_matrix_adaptation(py::module &main)
         .def_readwrite("dm", &Adaptation::dm)
         .def_readwrite("ps", &Adaptation::ps)
         .def_readwrite("dd", &Adaptation::dd)
-        .def_readwrite("chiN", &Adaptation::chiN)
+        .def_readwrite("expected_length_z", &Adaptation::expected_length_z)
         .def_readwrite("inv_C", &CovarianceAdaptation::inv_C)
         .def("adapt_evolution_paths", &Adaptation::adapt_evolution_paths,
              py::arg("pop"),
@@ -295,12 +352,12 @@ void define_matrix_adaptation(py::module &main)
             ss << " dm: " << dyn.dm.transpose();
             ss << " ps: " << dyn.ps.transpose();
             ss << " dd: " << dyn.dd;
-            ss << " chiN: " << dyn.chiN;
+            ss << " expected_length_z: " << dyn.expected_length_z;
             ss << ">";
             return ss.str(); });
 
     py::class_<CovarianceAdaptation, Adaptation, std::shared_ptr<CovarianceAdaptation>>(m, "CovarianceAdaptation")
-        .def(py::init<size_t, Vector>(), py::arg("dimension"), py::arg("x0"))
+        .def(py::init<size_t, Vector, double>(), py::arg("dimension"), py::arg("x0"), py::arg("expected_length_z"))
         .def_readwrite("pc", &CovarianceAdaptation::pc)
         .def_readwrite("d", &CovarianceAdaptation::d)
         .def_readwrite("B", &CovarianceAdaptation::B)
@@ -328,13 +385,13 @@ void define_matrix_adaptation(py::module &main)
             ss << " C: " << dyn.C;
             ss << " inv_root_C: " << dyn.inv_root_C;
             ss << " dd: " << dyn.dd;
-            ss << " chiN: " << dyn.chiN;
+            ss << " expected_length_z: " << dyn.expected_length_z;
             ss << " hs: " << dyn.hs;
             ss << ">";
             return ss.str(); });
 
     py::class_<SeperableAdaptation, CovarianceAdaptation, std::shared_ptr<SeperableAdaptation>>(m, "SeperableAdaptation")
-        .def(py::init<size_t, Vector>(), py::arg("dimension"), py::arg("x0"))
+        .def(py::init<size_t, Vector, double>(), py::arg("dimension"), py::arg("x0"), py::arg("expected_length_z"))
         .def("__repr__", [](SeperableAdaptation &dyn)
              {
                 std::stringstream ss;
@@ -350,13 +407,13 @@ void define_matrix_adaptation(py::module &main)
                 ss << " C: " << dyn.C;
                 ss << " inv_root_C: " << dyn.inv_root_C;
                 ss << " dd: " << dyn.dd;
-                ss << " chiN: " << dyn.chiN;
+                ss << " expected_length_z: " << dyn.expected_length_z;
                 ss << " hs: " << dyn.hs;
                 ss << ">";
                 return ss.str(); });
 
     py::class_<MatrixAdaptation, Adaptation, std::shared_ptr<MatrixAdaptation>>(m, "MatrixAdaptation")
-        .def(py::init<size_t, Vector>(), py::arg("dimension"), py::arg("x0"))
+        .def(py::init<size_t, Vector, double>(), py::arg("dimension"), py::arg("x0"), py::arg("expected_length_z"))
         .def_readwrite("M", &MatrixAdaptation::M)
         .def_readwrite("M_inv", &MatrixAdaptation::M_inv)
         .def("__repr__", [](MatrixAdaptation &dyn)
@@ -370,12 +427,12 @@ void define_matrix_adaptation(py::module &main)
             ss << " ps: " << dyn.ps.transpose();
             ss << " M: " << dyn.M;
             ss << " dd: " << dyn.dd;
-            ss << " chiN: " << dyn.chiN;
+            ss << " expected_length_z: " << dyn.expected_length_z;
             ss << ">";
             return ss.str(); });
 
     py::class_<None, Adaptation, std::shared_ptr<None>>(m, "NoAdaptation")
-        .def(py::init<size_t, Vector>(), py::arg("dimension"), py::arg("x0"))
+        .def(py::init<size_t, Vector, double>(), py::arg("dimension"), py::arg("x0"), py::arg("expected_length_z"))
         .def("__repr__", [](None &dyn)
              {
             std::stringstream ss;
@@ -386,7 +443,7 @@ void define_matrix_adaptation(py::module &main)
             ss << " dm: " << dyn.dm.transpose();
             ss << " ps: " << dyn.ps.transpose();
             ss << " dd: " << dyn.dd;
-            ss << " chiN: " << dyn.chiN;
+            ss << " expected_length_z: " << dyn.expected_length_z;
             ss << ">";
             return ss.str(); });
 }
@@ -413,6 +470,7 @@ void define_parameters(py::module &main)
         .def_readwrite("repelling_restart", &Modules::repelling_restart)
         .def_readwrite("matrix_adaptation", &Modules::matrix_adaptation)
         .def_readwrite("center_placement", &Modules::center_placement)
+        .def_readwrite("sample_transformation", &Modules::sample_transformation)
         .def("__repr__", [](Modules &mod)
              { return to_string(mod); });
 
@@ -551,7 +609,7 @@ void define_parameters(py::module &main)
         .def(py::init<Settings>(), py::arg("settings"))
         .def("adapt", &Parameters::adapt, py::arg("objective"))
         .def("perform_restart", &Parameters::perform_restart, py::arg("objective"),
-        py::arg("sigma") = std::nullopt)
+             py::arg("sigma") = std::nullopt)
         .def_readwrite("settings", &Parameters::settings)
         .def_readwrite("mu", &Parameters::mu)
         .def_readwrite("lamb", &Parameters::lambda)
@@ -603,6 +661,9 @@ void define_bounds(py::module &main)
         .def("correct", &BoundCorrection::correct,
              py::arg("population"), py::arg("m"));
 
+    py::class_<Resample, BoundCorrection, std::shared_ptr<Resample>>(m, "Resample")
+        .def(py::init<Vector, Vector>(), py::arg("lb"), py::arg("ub"));
+    
     py::class_<NoCorrection, BoundCorrection, std::shared_ptr<NoCorrection>>(m, "NoCorrection")
         .def(py::init<Vector, Vector>(), py::arg("lb"), py::arg("ub"));
 
@@ -678,76 +739,84 @@ void define_mutation(py::module &main)
 
     py::class_<CSA, Strategy, std::shared_ptr<CSA>>(m, "CSA")
         .def(
-            py::init<std::shared_ptr<ThresholdConvergence>, std::shared_ptr<SequentialSelection>, std::shared_ptr<SigmaSampler>, double, double, double>(),
+            py::init<std::shared_ptr<ThresholdConvergence>, std::shared_ptr<SequentialSelection>, std::shared_ptr<SigmaSampler>, double, double, double, double>(),
             py::arg("threshold_convergence"),
             py::arg("sequential_selection"),
             py::arg("sigma_sampler"),
             py::arg("cs"),
             py::arg("damps"),
-            py::arg("sigma0"))
+            py::arg("sigma0"),
+            py::arg("expected_length_z"))
         .def_readwrite("damps", &CSA::damps)
+        .def_readwrite("expected_length_z", &CSA::expected_length_z)
         .def(
             "mutate", &CSA::mutate, py::arg("objective"),
             py::arg("n_offspring"),
             py::arg("parameters"));
 
     py::class_<TPA, CSA, std::shared_ptr<TPA>>(m, "TPA")
-        .def(py::init<std::shared_ptr<ThresholdConvergence>, std::shared_ptr<SequentialSelection>, std::shared_ptr<SigmaSampler>, double, double, double>(),
+        .def(py::init<std::shared_ptr<ThresholdConvergence>, std::shared_ptr<SequentialSelection>, std::shared_ptr<SigmaSampler>, double, double, double, double>(),
              py::arg("threshold_convergence"),
              py::arg("sequential_selection"),
              py::arg("sigma_sampler"),
              py::arg("cs"),
              py::arg("damps"),
-             py::arg("sigma0"))
+             py::arg("sigma0"),
+             py::arg("expected_length_z"))
         .def_readwrite("a_tpa", &TPA::a_tpa)
         .def_readwrite("b_tpa", &TPA::b_tpa)
         .def_readwrite("rank_tpa", &TPA::rank_tpa);
 
     py::class_<MSR, CSA, std::shared_ptr<MSR>>(m, "MSR")
-        .def(py::init<std::shared_ptr<ThresholdConvergence>, std::shared_ptr<SequentialSelection>, std::shared_ptr<SigmaSampler>, double, double, double>(),
+        .def(py::init<std::shared_ptr<ThresholdConvergence>, std::shared_ptr<SequentialSelection>, std::shared_ptr<SigmaSampler>, double, double, double, double>(),
              py::arg("threshold_convergence"),
              py::arg("sequential_selection"),
              py::arg("sigma_sampler"),
              py::arg("cs"),
              py::arg("damps"),
-             py::arg("sigma0"));
+             py::arg("sigma0"),
+             py::arg("expected_length_z"));
 
     py::class_<PSR, CSA, std::shared_ptr<PSR>>(m, "PSR")
-        .def(py::init<std::shared_ptr<ThresholdConvergence>, std::shared_ptr<SequentialSelection>, std::shared_ptr<SigmaSampler>, double, double, double>(),
+        .def(py::init<std::shared_ptr<ThresholdConvergence>, std::shared_ptr<SequentialSelection>, std::shared_ptr<SigmaSampler>, double, double, double, double>(),
              py::arg("threshold_convergence"),
              py::arg("sequential_selection"),
              py::arg("sigma_sampler"),
              py::arg("cs"),
              py::arg("damps"),
-             py::arg("sigma0"))
+             py::arg("sigma0"),
+             py::arg("expected_length_z"))
         .def_readwrite("success_ratio", &PSR::succes_ratio);
 
     py::class_<XNES, CSA, std::shared_ptr<XNES>>(m, "XNES")
-        .def(py::init<std::shared_ptr<ThresholdConvergence>, std::shared_ptr<SequentialSelection>, std::shared_ptr<SigmaSampler>, double, double, double>(),
+        .def(py::init<std::shared_ptr<ThresholdConvergence>, std::shared_ptr<SequentialSelection>, std::shared_ptr<SigmaSampler>, double, double, double, double>(),
              py::arg("threshold_convergence"),
              py::arg("sequential_selection"),
              py::arg("sigma_sampler"),
              py::arg("cs"),
              py::arg("damps"),
-             py::arg("sigma0"));
+             py::arg("sigma0"),
+             py::arg("expected_length_z"));
 
     py::class_<MXNES, CSA, std::shared_ptr<MXNES>>(m, "MXNES")
-        .def(py::init<std::shared_ptr<ThresholdConvergence>, std::shared_ptr<SequentialSelection>, std::shared_ptr<SigmaSampler>, double, double, double>(),
+        .def(py::init<std::shared_ptr<ThresholdConvergence>, std::shared_ptr<SequentialSelection>, std::shared_ptr<SigmaSampler>, double, double, double, double>(),
              py::arg("threshold_convergence"),
              py::arg("sequential_selection"),
              py::arg("sigma_sampler"),
              py::arg("cs"),
              py::arg("damps"),
-             py::arg("sigma0"));
+             py::arg("sigma0"),
+             py::arg("expected_length_z"));
 
     py::class_<LPXNES, CSA, std::shared_ptr<LPXNES>>(m, "LPXNES")
-        .def(py::init<std::shared_ptr<ThresholdConvergence>, std::shared_ptr<SequentialSelection>, std::shared_ptr<SigmaSampler>, double, double, double>(),
+        .def(py::init<std::shared_ptr<ThresholdConvergence>, std::shared_ptr<SequentialSelection>, std::shared_ptr<SigmaSampler>, double, double, double, double>(),
              py::arg("threshold_convergence"),
              py::arg("sequential_selection"),
              py::arg("sigma_sampler"),
              py::arg("cs"),
              py::arg("damps"),
-             py::arg("sigma0"));
+             py::arg("sigma0"),
+             py::arg("expected_length_z"));
 }
 
 void define_population(py::module &main)
@@ -823,8 +892,7 @@ void define_constants(py::module &m)
             [](py::object)
             { return constants::cache_samples; },
             [](py::object, bool a)
-            { constants::cache_samples = a; })
-        ;
+            { constants::cache_samples = a; });
 }
 
 void define_restart(py::module &main)
@@ -890,11 +958,11 @@ void define_restart(py::module &main)
 
     py::class_<Stop, Strategy, std::shared_ptr<Stop>>(m, "Stop")
         .def(py::init<double, double, double>(), py::arg("sigma"), py::arg("dimension"), py::arg("lamb"))
-        .def("restart", &Stop::restart, py::arg("objective"),py::arg("parameters"));
+        .def("restart", &Stop::restart, py::arg("objective"), py::arg("parameters"));
 
     py::class_<Restart, Strategy, std::shared_ptr<Restart>>(m, "Restart")
         .def(py::init<double, double, double>(), py::arg("sigma"), py::arg("dimension"), py::arg("lamb"))
-        .def("restart", &Restart::restart, py::arg("objective"),py::arg("parameters"));
+        .def("restart", &Restart::restart, py::arg("objective"), py::arg("parameters"));
 
     py::class_<IPOP, Strategy, std::shared_ptr<IPOP>>(m, "IPOP")
         .def(py::init<double, double, double>(), py::arg("sigma"), py::arg("dimension"), py::arg("lamb"))
@@ -903,7 +971,7 @@ void define_restart(py::module &main)
 
     py::class_<BIPOP, Strategy, std::shared_ptr<BIPOP>>(m, "BIPOP")
         .def(py::init<double, double, double, double, size_t>(), py::arg("sigma"), py::arg("dimension"), py::arg("lamb"), py::arg("mu"), py::arg("budget"))
-        .def("restart", &BIPOP::restart, py::arg("objective"),py::arg("parameters"))
+        .def("restart", &BIPOP::restart, py::arg("objective"), py::arg("parameters"))
         .def("large", &BIPOP::large)
         .def_readwrite("mu_factor", &BIPOP::mu_factor)
         .def_readwrite("lambda_init", &BIPOP::lambda_init)
@@ -939,6 +1007,90 @@ void define_cmaes(py::module &m)
         .def_readonly("p", &ModularCMAES::p);
 }
 
+void define_es(py::module &main)
+{
+    auto m = main.def_submodule("es");
+    parameters::Modules default_modules;
+    using namespace es;
+    py::class_<OnePlusOneES, std::shared_ptr<OnePlusOneES>>(m, "OnePlusOneES")
+        .def(
+            py::init<
+                size_t,
+                Vector,
+                double,
+                double,
+                size_t,
+                double,
+                parameters::Modules>(),
+            py::arg("d"),
+            py::arg("x0"),
+            py::arg("f0"),
+            py::arg("sigma0") = 1.0,
+            py::arg("budget") = 10'000,
+            py::arg("target") = 1e-8,
+            py::arg("modules") = default_modules)
+        .def("__call__", &OnePlusOneES::operator())
+        .def("step", &OnePlusOneES::step)
+        .def("sample", &OnePlusOneES::sample)
+        .def_readwrite("d", &OnePlusOneES::d)
+        .def_readwrite("sigma", &OnePlusOneES::sigma)
+        .def_readwrite("decay", &OnePlusOneES::decay)
+        .def_readwrite("x", &OnePlusOneES::x)
+        .def_readwrite("f", &OnePlusOneES::f)
+        .def_readwrite("t", &OnePlusOneES::t)
+        .def_readwrite("budget", &OnePlusOneES::budget)
+        .def_readwrite("target", &OnePlusOneES::target)
+        .def_readwrite("sampler", &OnePlusOneES::sampler)
+        .def_readwrite("rejection_sampling", &OnePlusOneES::rejection_sampling)
+        .def_readwrite("corrector", &OnePlusOneES::corrector)
+        ;
+
+    py::class_<MuCommaLambdaES, std::shared_ptr<MuCommaLambdaES>>(m, "MuCommaLambdaES")
+        .def(
+            py::init<
+                size_t,
+                Vector,
+                double,
+                size_t,
+                double,
+                parameters::Modules>(),
+            py::arg("d"),
+            py::arg("x0"),
+            py::arg("sigma0") = 1.0,
+            py::arg("budget") = 10'000,
+            py::arg("target") = 1e-8,
+            py::arg("modules") = default_modules)
+        .def("__call__", &MuCommaLambdaES::operator())
+        .def("step", &MuCommaLambdaES::step)
+        .def("sample", &MuCommaLambdaES::sample)
+        .def_readwrite("d", &MuCommaLambdaES::d)
+        .def_readwrite("lamb", &MuCommaLambdaES::lambda)
+        .def_readwrite("mu", &MuCommaLambdaES::mu)
+
+        .def_readwrite("sigma", &MuCommaLambdaES::sigma)
+        .def_readwrite("m", &MuCommaLambdaES::m)
+
+        .def_readwrite("X", &MuCommaLambdaES::X)
+        .def_readwrite("S", &MuCommaLambdaES::S)
+        .def_readwrite("f", &MuCommaLambdaES::f)
+
+        .def_readwrite("tau", &MuCommaLambdaES::tau)
+        .def_readwrite("tau_i", &MuCommaLambdaES::tau_i)
+        .def_readwrite("mu_inv", &MuCommaLambdaES::mu_inv)
+
+        .def_readwrite("f_min", &MuCommaLambdaES::f_min)
+        .def_readwrite("x_min", &MuCommaLambdaES::x_min)
+        .def_readwrite("t", &MuCommaLambdaES::t)
+        .def_readwrite("e", &MuCommaLambdaES::e)
+        .def_readwrite("budget", &MuCommaLambdaES::budget)
+        .def_readwrite("target", &MuCommaLambdaES::target)
+        .def_readwrite("sampler", &MuCommaLambdaES::sampler)
+        .def_readwrite("sigma_sampler", &MuCommaLambdaES::sigma_sampler)
+        .def_readwrite("rejection_sampling", &MuCommaLambdaES::rejection_sampling)
+        .def_readwrite("corrector", &MuCommaLambdaES::corrector)
+     ;
+}
+
 PYBIND11_MODULE(cmaescpp, m)
 {
     define_constants(m);
@@ -955,4 +1107,5 @@ PYBIND11_MODULE(cmaescpp, m)
     define_bounds(m);
     define_selection(m);
     define_cmaes(m);
+    define_es(m);
 }
diff --git a/src/main.cpp b/src/main.cpp
index 7a09f49..ff2aac0 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -53,7 +53,7 @@ int main()
 	constants::cache_samples = true;
 
 	parameters::Settings settings(dim);
-	settings.modules.sampler = parameters::BaseSampler::GAUSSIAN;
+	settings.modules.sampler = parameters::BaseSampler::UNIFORM;
 	settings.modules.mirrored = parameters::Mirror::NONE;
 	settings.modules.orthogonal = true;
 	parameters::Parameters p(settings);
diff --git a/src/matrix_adaptation.cpp b/src/matrix_adaptation.cpp
index 423663f..734f505 100644
--- a/src/matrix_adaptation.cpp
+++ b/src/matrix_adaptation.cpp
@@ -18,7 +18,7 @@ namespace matrix_adaptation
 
 		const double actual_ps_length = ps.norm() / sqrt(
 			1.0 - pow(1.0 - mutation->cs, 2.0 * (stats.evaluations / lambda)));
-		const double expected_ps_length = (1.4 + (2.0 / (dd + 1.0))) * chiN;
+		const double expected_ps_length = (1.4 + (2.0 / (dd + 1.0))) * expected_length_z;
 
 		hs = actual_ps_length < expected_ps_length;
 		pc = (1.0 - w.cc) * pc + (hs * sqrt(w.cc * (2.0 - w.cc) * w.mueff)) * dm;
diff --git a/src/mutation.cpp b/src/mutation.cpp
index 0c13db6..7c59a22 100644
--- a/src/mutation.cpp
+++ b/src/mutation.cpp
@@ -8,8 +8,7 @@ namespace mutation
 	Vector ThresholdConvergence::scale(const Vector &zi, const double diameter, const size_t budget,
 									   const size_t evaluations)
 	{
-		const double t = init_threshold * diameter * pow(
-			static_cast<double>(budget - evaluations) / static_cast<double>(budget), decay_factor);
+		const double t = init_threshold * diameter * pow(static_cast<double>(budget - evaluations) / static_cast<double>(budget), decay_factor);
 
 		if (const auto norm = zi.norm(); norm < t)
 			return zi.array() * ((t + (t - norm)) / norm);
@@ -24,8 +23,9 @@ namespace mutation
 	void CSA::adapt(const parameters::Weights &w, std::shared_ptr<matrix_adaptation::Adaptation> adaptation,
 					Population &pop,
 					const Population &old_pop, const parameters::Stats &stats, const size_t lambda)
+
 	{
-		sigma *= std::exp((cs / damps) * ((adaptation->ps.norm() / adaptation->chiN) - 1));
+		sigma *= std::exp((cs / damps) * ((adaptation->ps.norm() / expected_length_z) - 1));
 	}
 
 	void CSA::mutate(FunctionType &objective, const size_t n_offspring, parameters::Parameters &p)
@@ -36,6 +36,7 @@ namespace mutation
 
 		for (Eigen::Index i = 0; i < static_cast<Eigen::Index>(n_offspring); ++i)
 		{
+			size_t n_rej = 0;
 			do
 			{
 				p.pop.Z.col(i) = p.mutation->tc->scale((*p.sampler)(), p.bounds->diameter, p.settings.budget, p.stats.evaluations);
@@ -45,7 +46,8 @@ namespace mutation
 				p.pop.X.col(i) = p.pop.Y.col(i) * p.pop.s(i) + p.adaptation->m;
 
 				p.bounds->correct(i, p);
-			} while (p.repelling->is_rejected(p.pop.X.col(i), p));
+			} while (
+				(p.settings.modules.bound_correction == parameters::CorrectionMethod::RESAMPLE && n_rej++ < 5*p.settings.dim && p.bounds->is_out_of_bounds(p.pop.X.col(i)).any()) || p.repelling->is_rejected(p.pop.X.col(i), p));
 
 			p.pop.f(i) = objective(p.pop.X.col(i));
 			p.stats.evaluations++;
@@ -169,7 +171,8 @@ namespace mutation
 	}
 
 	std::shared_ptr<Strategy> get(const parameters::Modules &m, const size_t mu, const double mueff,
-								  const double d, const double sigma, const std::optional<double> cs0)
+								  const double d, const double sigma, const std::optional<double> cs0,
+								  const double expected_z)
 	{
 		using namespace parameters;
 		auto tc = m.threshold_convergence
@@ -190,26 +193,26 @@ namespace mutation
 		switch (m.ssa)
 		{
 		case StepSizeAdaptation::TPA:
-			return std::make_shared<TPA>(tc, sq, ss, cs, damps, sigma);
+			return std::make_shared<TPA>(tc, sq, ss, cs, damps, sigma, expected_z);
 		case StepSizeAdaptation::MSR:
-			return std::make_shared<MSR>(tc, sq, ss, cs, damps, sigma);
+			return std::make_shared<MSR>(tc, sq, ss, cs, damps, sigma, expected_z);
 		case StepSizeAdaptation::XNES:
 			cs = cs0.value_or(mueff / (2.0 * std::log(std::max(2., d)) * sqrt(d)));
-			return std::make_shared<XNES>(tc, sq, ss, cs, damps, sigma);
+			return std::make_shared<XNES>(tc, sq, ss, cs, damps, sigma, expected_z);
 		case StepSizeAdaptation::MXNES:
 			cs = cs0.value_or(1.);
-			return std::make_shared<MXNES>(tc, sq, ss, cs, damps, sigma);
+			return std::make_shared<MXNES>(tc, sq, ss, cs, damps, sigma, expected_z);
 		case StepSizeAdaptation::LPXNES:
 			cs = cs0.value_or(9.0 * mueff / (10.0 * sqrt(d)));
-			return std::make_shared<LPXNES>(tc, sq, ss, cs, damps, sigma);
+			return std::make_shared<LPXNES>(tc, sq, ss, cs, damps, sigma, expected_z);
 		case StepSizeAdaptation::PSR:
 			cs = cs0.value_or(.9);
-			return std::make_shared<PSR>(tc, sq, ss, cs, 0., sigma);
+			return std::make_shared<PSR>(tc, sq, ss, cs, 0., sigma, expected_z);
 		default:
 		case StepSizeAdaptation::CSA:
 			cs = cs0.value_or((mueff + 2.0) / (d + mueff + 5.0));
 			damps = 1.0 + (2.0 * std::max(0.0, sqrt((mueff - 1.0) / (d + 1)) - 1) + cs);
-			return std::make_shared<CSA>(tc, sq, ss, cs, damps, sigma);
+			return std::make_shared<CSA>(tc, sq, ss, cs, damps, sigma, expected_z);
 		}
 	}
 }
diff --git a/src/parameters.cpp b/src/parameters.cpp
index 164684a..ca67afa 100644
--- a/src/parameters.cpp
+++ b/src/parameters.cpp
@@ -8,14 +8,16 @@ namespace parameters
 													   weights(settings.dim, settings.mu0, settings.lambda0, settings),
 													   pop(settings.dim, settings.lambda0),
 													   old_pop(settings.dim, settings.lambda0),
-													   adaptation(matrix_adaptation::get(settings.modules, settings.dim,
-																						 settings.x0.value_or(Vector::Zero(settings.dim)))),
 													   sampler(sampling::get(settings.dim, settings.modules, settings.lambda0)),
+													   adaptation(matrix_adaptation::get(settings.modules, settings.dim,
+																						 settings.x0.value_or(Vector::Zero(settings.dim)),
+																						 sampler->expected_length())),
 													   mutation(mutation::get(settings.modules,
 																			  settings.mu0, weights.mueff,
 																			  static_cast<double>(settings.dim),
 																			  settings.sigma0,
-																			  settings.cs)),
+																			  settings.cs,
+																			  sampler->expected_length())),
 													   selection(std::make_shared<selection::Strategy>(settings.modules)),
 													   restart(restart::get(
 														   settings.modules.restart_strategy,
@@ -52,7 +54,7 @@ namespace parameters
 		mutation = mutation::get(settings.modules, mu, weights.mueff,
 								 static_cast<double>(settings.dim),
 								 sigma.value_or(settings.sigma0),
-								 settings.cs);
+								 settings.cs, sampler->expected_length());
 		adaptation->restart(settings);
 		(*center_placement)(*this);
 		restart->criteria = restart::RestartCriteria(sigma.value_or(settings.sigma0), settings.dim, lambda, stats.t);
diff --git a/src/sampling.cpp b/src/sampling.cpp
index 4b6aba9..876566c 100644
--- a/src/sampling.cpp
+++ b/src/sampling.cpp
@@ -41,7 +41,7 @@ namespace sampling
 		return samples.col(current++);
 	}
 
-	size_t Orthogonal::get_n_samples(const parameters::Modules& modules, const size_t lambda)
+	size_t Orthogonal::get_n_samples(const parameters::Modules &modules, const size_t lambda)
 	{
 		using namespace parameters;
 		const auto not_mirrored = modules.mirrored == Mirror::NONE;
@@ -49,7 +49,7 @@ namespace sampling
 		return std::max(1, (static_cast<int>(lambda) / (2 - not_mirrored)) - (2 * has_tpa));
 	}
 
-	void Orthogonal::reset(const parameters::Modules& mod, const size_t lambda)
+	void Orthogonal::reset(const parameters::Modules &mod, const size_t lambda)
 	{
 		sampler->reset(mod, lambda);
 		n = std::max(d, Orthogonal::get_n_samples(mod, lambda));
@@ -59,12 +59,11 @@ namespace sampling
 		current = 0;
 	}
 
-	Halton::Halton(const size_t d, const bool scramble) :
-		Sampler(d),
-		index_(6),
-		scramble_(scramble),
-		primes_(n_primes(d)),
-		permutations_(d)
+	Halton::Halton(const size_t d, const bool scramble) : Sampler(d),
+														  index_(6),
+														  scramble_(scramble),
+														  primes_(n_primes(d)),
+														  permutations_(d)
 	{
 		if (scramble_)
 			permutations_ = get_permutations(primes_);
@@ -76,11 +75,11 @@ namespace sampling
 
 		if (scramble_)
 			for (size_t j = 0; j < d; ++j)
-				res(j) = ppf(next(index_, primes_[j], permutations_[j]));
+				res(j) = next(index_, primes_[j], permutations_[j]);
 		else
 			for (size_t j = 0; j < d; ++j)
-				res(j) = ppf(next(index_, primes_[j]));
-		
+				res(j) = next(index_, primes_[j]);
+
 		index_++;
 		return res;
 	}
@@ -95,13 +94,12 @@ namespace sampling
 			f = f / static_cast<double>(base);
 		}
 		return result;
-
 	}
 
-	double Halton::next(int index, const int base, const std::vector<std::vector<int>>& permutations)
+	double Halton::next(int index, const int base, const std::vector<std::vector<int>> &permutations)
 	{
 		double result = 0.0, f = 1.0 / base;
-		for (const auto& permutation : permutations)
+		for (const auto &permutation : permutations)
 		{
 			const double remainder = permutation[index % base];
 			result += remainder * f;
@@ -130,7 +128,7 @@ namespace sampling
 		return primes;
 	}
 
-	std::vector<std::vector<std::vector<int>>> Halton::get_permutations(const std::vector<int>& primes)
+	std::vector<std::vector<std::vector<int>>> Halton::get_permutations(const std::vector<int> &primes)
 	{
 		std::vector<std::vector<std::vector<int>>> permutations(primes.size());
 		for (size_t i = 0; i < primes.size(); i++)
@@ -159,25 +157,22 @@ namespace sampling
 		return primes;
 	}
 
-	
 	Sobol::Sobol(const size_t dim) : Sampler(dim), cache(dim)
 	{
 		long long seed = 2;
 		for (size_t i = 0; i < cache.n_samples; i++)
 			i8_sobol(static_cast<int>(d), &seed, cache.cache.data() + i * d);
-		cache.transform(ppf);
+		// cache.transform(ppf);
 	}
 
-	
-
-	std::shared_ptr<Sampler> get(const size_t dim, const parameters::Modules& modules, const size_t lambda)
+	std::shared_ptr<Sampler> get(const size_t dim, const parameters::Modules &modules, const size_t lambda)
 	{
 		using namespace parameters;
 		std::shared_ptr<Sampler> sampler;
 		switch (modules.sampler)
 		{
-		case BaseSampler::GAUSSIAN:
-			sampler = std::make_shared<Gaussian>(dim);
+		case BaseSampler::UNIFORM:
+			sampler = std::make_shared<Uniform>(dim);
 			break;
 		case BaseSampler::SOBOL:
 			sampler = std::make_shared<Sobol>(dim);
@@ -190,6 +185,31 @@ namespace sampling
 			break;
 		}
 
+		switch (modules.sample_transformation)
+		{
+		case SampleTranformerType::GAUSSIAN:
+			sampler = std::make_shared<GaussianTransformer>(sampler);
+			break;
+		case SampleTranformerType::SCALED_UNIFORM:
+			sampler = std::make_shared<UniformScaler>(sampler);
+			break;
+		case SampleTranformerType::LAPLACE:
+			sampler = std::make_shared<LaplaceTransformer>(sampler);
+			break;
+		case SampleTranformerType::LOGISTIC:
+			sampler = std::make_shared<LogisticTransformer>(sampler);
+			break;
+		case SampleTranformerType::CAUCHY:
+			sampler = std::make_shared<CauchyTransformer>(sampler);
+			break;
+		case SampleTranformerType::DOUBLE_WEIBULL:
+			sampler = std::make_shared<DoubleWeibullTransformer>(sampler);
+			break;
+		case SampleTranformerType::NONE:
+			sampler = std::make_shared<IdentityTransformer>(sampler);
+			break;
+		}
+
 		if (modules.orthogonal)
 			sampler = std::make_shared<Orthogonal>(sampler, Orthogonal::get_n_samples(modules, lambda));
 
diff --git a/tests/test_c_es.py b/tests/test_c_es.py
new file mode 100644
index 0000000..d50512f
--- /dev/null
+++ b/tests/test_c_es.py
@@ -0,0 +1,38 @@
+import unittest
+import numpy as np
+from modcma.c_maes import es, parameters, utils
+
+def sphere(x: np.ndarray) -> float:
+    return np.linalg.norm(x)
+
+
+class TestES(unittest.TestCase):
+    def test_1p1(self):
+        d = 2
+        utils.set_seed(1)
+        x0 = np.ones(d)
+        
+        alg = es.OnePlusOneES(
+            d, 
+            x0, 
+            sphere(x0)
+        )
+        alg(sphere)
+        self.assertLessEqual(alg.f, 1e-8)
+        self.assertLessEqual(alg.t, 500)
+
+    def test_mu_comma_lamb(self):
+        d = 2
+        x0 = np.ones(d)
+        utils.set_seed(1)
+        alg = es.MuCommaLambdaES(
+            d, 
+            x0,
+            
+        )
+        alg(sphere)
+        self.assertLessEqual(alg.f_min, 1e-8)
+        self.assertLessEqual(alg.e, 1000)
+
+if __name__ == "__main__":
+    unittest.main()
\ No newline at end of file
diff --git a/tests/test_c_mutation.py b/tests/test_c_mutation.py
index 2319f27..5cfba25 100644
--- a/tests/test_c_mutation.py
+++ b/tests/test_c_mutation.py
@@ -73,7 +73,7 @@ def test_adapt_csa(self):
             cma.p.settings.sigma0
             * np.exp(
                 (cma.p.mutation.cs / cma.p.mutation.damps)
-                * ((np.linalg.norm(cma.p.adaptation.ps) / cma.p.adaptation.chiN) - 1)
+                * ((np.linalg.norm(cma.p.adaptation.ps) / cma.p.sampler.expected_length()) - 1)
             ),
         )
 
diff --git a/tests/test_c_sampling.py b/tests/test_c_sampling.py
index e77f133..7653a60 100644
--- a/tests/test_c_sampling.py
+++ b/tests/test_c_sampling.py
@@ -19,15 +19,15 @@ def sampler_test(self, sampler, expected):
 
     def test_base_sampler_gauss(self):
         sampler = sampling.Gaussian(5)
-        self.sampler_test(sampler, 1.107994899)
+        self.sampler_test(sampler, -1.88320896)
 
     def test_base_sampler_halton(self):
         sampler = sampling.Halton(5)
-        self.sampler_test(sampler, -0.3516482)
+        self.sampler_test(sampler, 2.373425998)
 
     def test_base_sampler_sobol(self):
         sampler = sampling.Sobol(5)
-        self.sampler_test(sampler, -0.5787853)
+        self.sampler_test(sampler, 2.2788658)
 
     def test_samplers_are_random(self):
         for sampler in (sampling.Halton, sampling.Sobol):