rename seperable>separable

Author: jacobdenobel

include/matrix_adaptation.hpp

@@ -132,12 +132,12 @@ namespace matrix_adaptation
 		Vector invert_y(const Vector&) override;
 	};
 
-	struct SeperableAdaptation : Adaptation
+	struct SeparableAdaptation : Adaptation
 	{
 		Vector pc, d, c;
 		bool hs;
 
-		SeperableAdaptation(const size_t dim, const Vector& x0, const Float expected_length_z) : Adaptation(dim, x0, Vector::Zero(dim), expected_length_z),
+		SeparableAdaptation(const size_t dim, const Vector& x0, const Float expected_length_z) : Adaptation(dim, x0, Vector::Zero(dim), expected_length_z),
 			pc(Vector::Zero(dim)),
 			d(Vector::Ones(dim)),
 			c(Vector::Ones(dim)),
@@ -306,7 +306,7 @@ namespace matrix_adaptation
 		case MatrixAdaptationType::NONE:
 			return std::make_shared<None>(dim, x0, expected_z);
 		case MatrixAdaptationType::SEPARABLE:
-			return std::make_shared<SeperableAdaptation>(dim, x0, expected_z);
+			return std::make_shared<SeparableAdaptation>(dim, x0, expected_z);
 		case MatrixAdaptationType::CHOLESKY:
 			return std::make_shared<CholeskyAdaptation>(dim, x0, expected_z);
 		case MatrixAdaptationType::CMSA:

modcma/c_maes/cmaescpp/__init__.pyi

@@ -57,7 +57,7 @@ class Parameters:
     adaptation: (
         matrix_adaptation.MatrixAdaptation
         | matrix_adaptation.CovarianceAdaptation
-        | matrix_adaptation.SeperableAdaptation
+        | matrix_adaptation.SeparableAdaptation
         | matrix_adaptation.OnePlusOneAdaptation
         | matrix_adaptation.NoAdaptation
     )

modcma/c_maes/cmaescpp/matrix_adaptation.pyi

@@ -46,7 +46,7 @@ class NoAdaptation(Adaptation):
 class OnePlusOneAdaptation(CovarianceAdaptation):
     def __init__(self, dimension: int, x0: numpy.ndarray, expected_length_z: float) -> None: ...
 
-class SeperableAdaptation(CovarianceAdaptation):
+class SeparableAdaptation(CovarianceAdaptation):
     c: numpy.ndarray
     pc: numpy.ndarray
     d: numpy.ndarray

scripts/matrix/plots.ipynb

@@ -431,16 +431,16 @@ void define_matrix_adaptation(py::module& main)
 				ss << ">";
 				return ss.str(); });
 
-	py::class_<SeperableAdaptation, Adaptation, std::shared_ptr<SeperableAdaptation>>(m, "SeperableAdaptation")
+	py::class_<SeparableAdaptation, Adaptation, std::shared_ptr<SeparableAdaptation>>(m, "SeparableAdaptation")
 		.def(py::init<size_t, Vector, Float>(), py::arg("dimension"), py::arg("x0"), py::arg("expected_length_z"))
-		.def_readwrite("c", &SeperableAdaptation::c)
-		.def_readwrite("pc", &SeperableAdaptation::pc)
-		.def_readwrite("d", &SeperableAdaptation::d)
-		.def("__repr__", [] (SeperableAdaptation& dyn)
+		.def_readwrite("c", &SeparableAdaptation::c)
+		.def_readwrite("pc", &SeparableAdaptation::pc)
+		.def_readwrite("d", &SeparableAdaptation::d)
+		.def("__repr__", [] (SeparableAdaptation& dyn)
 			{
 				std::stringstream ss;
 				ss << std::boolalpha;
-				ss << "<SeperableAdaptation";
+				ss << "<SeparableAdaptation";
 				ss << " m: " << dyn.m.transpose();
 				ss << " m_old: " << dyn.m_old.transpose();
 				ss << " dm: " << dyn.dm.transpose();
@@ -678,7 +678,7 @@ void define_parameters(py::module& main)
 	using AdaptationType = std::variant<
 		std::shared_ptr<matrix_adaptation::MatrixAdaptation>,
 		std::shared_ptr<matrix_adaptation::None>,
-		std::shared_ptr<matrix_adaptation::SeperableAdaptation>,
+		std::shared_ptr<matrix_adaptation::SeparableAdaptation>,
 		std::shared_ptr<matrix_adaptation::CholeskyAdaptation>,
 		std::shared_ptr<matrix_adaptation::SelfAdaptation>,
 		std::shared_ptr<matrix_adaptation::CovarainceNoEigvAdaptation>,
@@ -707,7 +707,7 @@ void define_parameters(py::module& main)
 					case MatrixAdaptationType::NONE:
 						return std::dynamic_pointer_cast<matrix_adaptation::None>(self.adaptation);
 					case MatrixAdaptationType::SEPARABLE:
-						return std::dynamic_pointer_cast<matrix_adaptation::SeperableAdaptation>(self.adaptation);
+						return std::dynamic_pointer_cast<matrix_adaptation::SeparableAdaptation>(self.adaptation);
 					case MatrixAdaptationType::CHOLESKY:
 						return std::dynamic_pointer_cast<matrix_adaptation::CholeskyAdaptation>(self.adaptation);
 					case MatrixAdaptationType::CMSA:

src/interface.cpp

@@ -161,7 +161,7 @@ namespace matrix_adaptation
 	}
 
 
-	void SeperableAdaptation::adapt_evolution_paths_inner(const Population& pop,
+	void SeparableAdaptation::adapt_evolution_paths_inner(const Population& pop,
 		const parameters::Weights& w,
 		const parameters::Stats& stats, const parameters::Settings& settings, size_t mu, size_t lambda)
 	{
@@ -180,7 +180,7 @@ namespace matrix_adaptation
 		pc = (1.0 - w.cc) * pc + (hs * w.sqrt_cc_mueff) * dm;
 	}
 
-	bool SeperableAdaptation::adapt_matrix_inner(const parameters::Weights& w, const parameters::Modules& m, const Population& pop, size_t mu,
+	bool SeparableAdaptation::adapt_matrix_inner(const parameters::Weights& w, const parameters::Modules& m, const Population& pop, size_t mu,
 		const parameters::Settings& settings, parameters::Stats& stats)
 	{
 
@@ -204,20 +204,20 @@ namespace matrix_adaptation
 		return true;
 	}
 
-	void SeperableAdaptation::restart(const parameters::Settings& settings, const Float sigma)
+	void SeparableAdaptation::restart(const parameters::Settings& settings, const Float sigma)
 	{
 		Adaptation::restart(settings, sigma);
 		c.setOnes();
 		d.setOnes();
 		pc.setZero();
 	}
 
-	Vector SeperableAdaptation::compute_y(const Vector& zi)
+	Vector SeparableAdaptation::compute_y(const Vector& zi)
 	{
 		return d.array() * zi.array();
 	}
 
-	Vector SeperableAdaptation::invert_y(const Vector& yi)
+	Vector SeparableAdaptation::invert_y(const Vector& yi)
 	{
 		return yi.array() / d.array();
 	}