diff --git a/include/differentiators.h b/include/differentiators.h
index 7649549..a0ae300 100644
--- a/include/differentiators.h
+++ b/include/differentiators.h
@@ -38,7 +38,7 @@ namespace details {
 // T: type
 // N: Number of points
 
-// Central differentiators: http://www.holoborodko.com/pavel/numerical-methods/numerical-derivative/central-differences/
+// Centered differentiators: http://www.holoborodko.com/pavel/numerical-methods/numerical-derivative/central-differences/
 template <typename T, size_t N> struct GetCDCoeffs {
     vectN_t<T, N> operator()() const;
 };
@@ -304,12 +304,12 @@ public:
 };
 
 template <typename T, size_t N, int Order, typename CoeffGetter>
-class CentralDifferentiator : public GenericFilter<T> {
+class CenteredDifferentiator : public GenericFilter<T> {
 public:
-    CentralDifferentiator()
+    CenteredDifferentiator()
         : GenericFilter<T>(vectX_t<T>::Constant(1, T(1)), CoeffGetter{}(), FilterType::Centered)
     {}
-    CentralDifferentiator(T timestep)
+    CenteredDifferentiator(T timestep)
         : GenericFilter<T>(vectX_t<T>::Constant(1, T(1)), CoeffGetter{}() / std::pow(timestep, Order))
     {}
     void setTimestep(T timestep) { setCoeffs(vectX_t<T>::Constant(1, T(1)), CoeffGetter{}() / std::pow(timestep, Order)); }
@@ -327,11 +327,11 @@ public:
 };
 
 template <typename T, size_t N, int Order, typename CoeffGetter>
-class TVCentralDifferentiator : public TVGenericFilter<T> {
+class TVCenteredDifferentiator : public TVGenericFilter<T> {
     static_assert(Order >= 1, "Order must be greater or equal to 1");
 
 public:
-    TVCentralDifferentiator()
+    TVCenteredDifferentiator()
         : TVGenericFilter<T>(Order, vectX_t<T>::Constant(1, T(1)), CoeffGetter{}(), FilterType::Centered)
     {}
 };
@@ -339,30 +339,30 @@ public:
 } // namespace details
 
 // Backward differentiators
-template <typename T, size_t N> using BackwardNoiseRobustDiff = details::BackwardDifferentiator<T, N, 1, details::GetFNRCoeffs<T, N>>;
-template <typename T, size_t N> using BackwardHybridNoiseRobustDiff = details::BackwardDifferentiator<T, N, 1, details::GetFHNRCoeffs<T, N>>;
+template <typename T, size_t N> using BackwardDiffNoiseRobust = details::BackwardDifferentiator<T, N, 1, details::GetFNRCoeffs<T, N>>;
+template <typename T, size_t N> using BackwardDiffHybridNoiseRobust = details::BackwardDifferentiator<T, N, 1, details::GetFHNRCoeffs<T, N>>;
 // Time-Varying backward differentiators
-template <typename T, size_t N> using TVBackwardNoiseRobustDiff = details::TVBackwardDifferentiator<T, N, 1, details::GetFNRISDCoeffs<T, N>>;
-template <typename T, size_t N> using TVBackwardHybridNoiseRobustDiff = details::TVBackwardDifferentiator<T, N, 1, details::GetFHNRISDCoeffs<T, N>>;
+template <typename T, size_t N> using TVBackwardDiffNoiseRobust = details::TVBackwardDifferentiator<T, N, 1, details::GetFNRISDCoeffs<T, N>>;
+template <typename T, size_t N> using TVBackwardDiffHybridNoiseRobust = details::TVBackwardDifferentiator<T, N, 1, details::GetFHNRISDCoeffs<T, N>>;
 
-// Central differentiators
-template <typename T, size_t N> using CentralDiff = details::CentralDifferentiator<T, N, 1, details::GetCDCoeffs<T, N>>;
-template <typename T, size_t N> using LowNoiseLanczosDiff = details::CentralDifferentiator<T, N, 1, details::GetLNLCoeffs<T, N>>;
-template <typename T, size_t N> using SuperLowNoiseLanczosDiff = details::CentralDifferentiator<T, N, 1, details::GetSLNLCoeffs<T, N>>;
-template <typename T, size_t N> using CenteredNoiseRobust2Diff = details::CentralDifferentiator<T, N, 1, details::GetCNR2Coeffs<T, N>>;
-template <typename T, size_t N> using CenteredNoiseRobust4Diff = details::CentralDifferentiator<T, N, 1, details::GetCNR4Coeffs<T, N>>;
-// Time-Varying central differentiators
-template <typename T, size_t N> using TVCenteredNoiseRobust2Diff = details::TVCentralDifferentiator<T, N, 1, details::GetCNR2ISDCoeffs<T, N>>;
-template <typename T, size_t N> using TVCenteredNoiseRobust4Diff = details::TVCentralDifferentiator<T, N, 1, details::GetCNR4ISDCoeffs<T, N>>;
+// Centered differentiators
+template <typename T, size_t N> using CenteredDiffBasic = details::CenteredDifferentiator<T, N, 1, details::GetCDCoeffs<T, N>>;
+template <typename T, size_t N> using CenteredDiffLowNoiseLanczos = details::CenteredDifferentiator<T, N, 1, details::GetLNLCoeffs<T, N>>;
+template <typename T, size_t N> using CenteredDiffSuperLowNoiseLanczos = details::CenteredDifferentiator<T, N, 1, details::GetSLNLCoeffs<T, N>>;
+template <typename T, size_t N> using CenteredDiffNoiseRobust2 = details::CenteredDifferentiator<T, N, 1, details::GetCNR2Coeffs<T, N>>;
+template <typename T, size_t N> using CenteredDiffNoiseRobust4 = details::CenteredDifferentiator<T, N, 1, details::GetCNR4Coeffs<T, N>>;
+// Time-Varying centered differentiators
+template <typename T, size_t N> using TVCenteredDiffNoiseRobust2 = details::TVCenteredDifferentiator<T, N, 1, details::GetCNR2ISDCoeffs<T, N>>;
+template <typename T, size_t N> using TVCenteredDiffNoiseRobust4 = details::TVCenteredDifferentiator<T, N, 1, details::GetCNR4ISDCoeffs<T, N>>;
 
 // Second-order backward differentiators
-template <typename T, size_t N> using BackwardSecondOrderDiff = details::BackwardDifferentiator<T, N, 2, details::GetSOFNRCoeffs<T, N>>;
+template <typename T, size_t N> using BackwardDiffSecondOrder = details::BackwardDifferentiator<T, N, 2, details::GetSOFNRCoeffs<T, N>>;
 // Second-order Time-Varying backward differentiators
-template <typename T, size_t N> using TVBackwardSecondOrderDiff = details::TVBackwardDifferentiator<T, N, 2, details::GetSOFNRISDCoeffs<T, N>>;
+template <typename T, size_t N> using TVBackwardDiffSecondOrder = details::TVBackwardDifferentiator<T, N, 2, details::GetSOFNRISDCoeffs<T, N>>;
 
-// Second-order central differentiators
-template <typename T, size_t N> using CenteredSecondOrderDiff = details::CentralDifferentiator<T, N, 2, details::GetSOCNRCoeffs<T, N>>;
-// Second-order Time-Varying central differentiators
-template <typename T, size_t N> using TVCenteredSecondOrderDiff = details::TVCentralDifferentiator<T, N, 2, details::GetSOCNRISDCoeffs<T, N>>;
+// Second-order centered differentiators
+template <typename T, size_t N> using CenteredDiffSecondOrder = details::CenteredDifferentiator<T, N, 2, details::GetSOCNRCoeffs<T, N>>;
+// Second-order Time-Varying centered differentiators
+template <typename T, size_t N> using TVCenteredDiffSecondOrder = details::TVCenteredDifferentiator<T, N, 2, details::GetSOCNRISDCoeffs<T, N>>;
 
 } // namespace difi
\ No newline at end of file
diff --git a/include/difi b/include/difi
index 909ebaa..2e7679a 100644
--- a/include/difi
+++ b/include/difi
@@ -60,4 +60,42 @@ using BilinearTransformd = BilinearTransform<double>;
 using BilinearTransformcf = BilinearTransform<std::complex<float>>;
 using BilinearTransformcd = BilinearTransform<std::complex<double>>;
 
+// 1st order centered differentiators
+template <size_t N> using CenteredDiffBasicf = CenteredDiffBasic<float, N>;
+template <size_t N> using CenteredDiffBasicd = CenteredDiffBasic<double, N>;
+template <size_t N> using CenteredDiffLowNoiseLanczosf = CenteredDiffLowNoiseLanczos<float, N>;
+template <size_t N> using CenteredDiffLowNoiseLanczosd = CenteredDiffLowNoiseLanczos<double, N>;
+template <size_t N> using CenteredDiffSuperLowNoiseLanczosf = CenteredDiffSuperLowNoiseLanczos<float, N>;
+template <size_t N> using CenteredDiffSuperLowNoiseLanczosd = CenteredDiffSuperLowNoiseLanczos<double, N>;
+template <size_t N> using CenteredDiffNoiseRobust2f = CenteredDiffNoiseRobust2<float, N>;
+template <size_t N> using CenteredDiffNoiseRobust2d = CenteredDiffNoiseRobust2<double, N>;
+template <size_t N> using CenteredDiffNoiseRobust4f = CenteredDiffNoiseRobust4<float, N>;
+template <size_t N> using CenteredDiffNoiseRobust4d = CenteredDiffNoiseRobust4<double, N>;
+template <size_t N> using TVCenteredDiffNoiseRobust2f = TVCenteredDiffNoiseRobust2<float, N>;
+template <size_t N> using TVCenteredDiffNoiseRobust2d = TVCenteredDiffNoiseRobust2<double, N>;
+template <size_t N> using TVCenteredDiffNoiseRobust4f = TVCenteredDiffNoiseRobust4<float, N>;
+template <size_t N> using TVCenteredDiffNoiseRobust4d = TVCenteredDiffNoiseRobust4<double, N>;
+
+// 2nd order centered differentiators
+template <size_t N> using CenteredDiffSecondOrderf = CenteredDiffSecondOrder<float, N>;
+template <size_t N> using CenteredDiffSecondOrderd = CenteredDiffSecondOrder<double, N>;
+template <size_t N> using TVCenteredDiffSecondOrderf = TVCenteredDiffSecondOrder<float, N>;
+template <size_t N> using TVCenteredDiffSecondOrderd = TVCenteredDiffSecondOrder<double, N>;
+
+// 1st order backward differentiators
+template <size_t N> using BackwardDiffNoiseRobustf = BackwardDiffNoiseRobust<float, N>;
+template <size_t N> using BackwardDiffNoiseRobustd = BackwardDiffNoiseRobust<double, N>;
+template <size_t N> using BackwardDiffHybridNoiseRobustf = BackwardDiffHybridNoiseRobust<float, N>;
+template <size_t N> using BackwardDiffHybridNoiseRobustd = BackwardDiffHybridNoiseRobust<double, N>;
+template <size_t N> using TVBackwardDiffNoiseRobustf = TVBackwardDiffNoiseRobust<float, N>;
+template <size_t N> using TVBackwardDiffNoiseRobustd = TVBackwardDiffNoiseRobust<double, N>;
+template <size_t N> using TVBackwardDiffHybridNoiseRobustf = TVBackwardDiffHybridNoiseRobust<float, N>;
+template <size_t N> using TVBackwardDiffHybridNoiseRobustd = TVBackwardDiffHybridNoiseRobust<double, N>;
+
+// 2nd order backward differentiators
+template <size_t N> using BackwardDiffSecondOrderf = BackwardDiffSecondOrder<float, N>;
+template <size_t N> using BackwardDiffSecondOrderd = BackwardDiffSecondOrder<double, N>;
+template <size_t N> using TVBackwardDiffSecondOrderf = TVBackwardDiffSecondOrder<float, N>;
+template <size_t N> using TVBackwardDiffSecondOrderd = TVBackwardDiffSecondOrder<double, N>;
+
 } // namespace difi
\ No newline at end of file
diff --git a/tests/diffTesters.h b/tests/diffTesters.h
index 0a65fb0..125df6b 100644
--- a/tests/diffTesters.h
+++ b/tests/diffTesters.h
@@ -136,32 +136,32 @@ private:
     vectX_t<T> m_time;
 };
 
-template <typename T, size_t N>
-using central_list = std::tuple<CentralDiff<T, N>, LowNoiseLanczosDiff<T, N>, SuperLowNoiseLanczosDiff<T, N>, CenteredNoiseRobust2Diff<T, N>, CenteredNoiseRobust4Diff<T, N>>;
+template <size_t N>
+using central_list = std::tuple<CenteredDiffBasicd<N>, CenteredDiffLowNoiseLanczosd<N>, CenteredDiffSuperLowNoiseLanczosd<N>, CenteredDiffNoiseRobust2d<N>, CenteredDiffNoiseRobust4d<N>>;
 
-template <typename T, size_t N>
-TFDiffTester<T, central_list<T, N>> generateCTester(const vectX_t<T>& f, const vectX_t<T>& df)
+template <size_t N>
+TFDiffTester<double, central_list<N>> generateCTester(const vectX_t<double>& f, const vectX_t<double>& df)
 {
-    return { central_list<T, N>{}, f, df };
+    return { central_list<N>{}, f, df };
 }
 
-template <typename T, size_t N>
-TFDiffTester<T, std::tuple<CenteredSecondOrderDiff<T, N>>> generateC2OTester(const vectX_t<T>& f, const vectX_t<T>& df)
+template <size_t N>
+TFDiffTester<double, std::tuple<CenteredDiffSecondOrderd<N>>> generateC2OTester(const vectX_t<double>& f, const vectX_t<double>& df)
 {
-    return { std::tuple<CenteredSecondOrderDiff<T, N>>{}, f, df };
+    return { std::tuple<CenteredDiffSecondOrderd<N>>{}, f, df };
 }
 
-template <typename T, size_t N>
-using tv_central_list = std::tuple<TVCenteredNoiseRobust2Diff<T, N>, TVCenteredNoiseRobust4Diff<T, N>>;
+template <size_t N>
+using tv_central_list = std::tuple<TVCenteredDiffNoiseRobust2d<N>, TVCenteredDiffNoiseRobust4d<N>>;
 
-template <typename T, size_t N>
-TVDiffTester<T, tv_central_list<T, N>> generateTVCTester(const vectX_t<T>& t, const vectX_t<T>& f, const vectX_t<T>& df)
+template <size_t N>
+TVDiffTester<double, tv_central_list<N>> generateTVCTester(const vectX_t<double>& t, const vectX_t<double>& f, const vectX_t<double>& df)
 {
-    return { tv_central_list<T, N>{}, t, f, df };
+    return { tv_central_list<N>{}, t, f, df };
 }
 
-template <typename T, size_t N>
-TVDiffTester<T, std::tuple<TVCenteredSecondOrderDiff<T, N>>> generateTVC2OTester(const vectX_t<T>& t, const vectX_t<T>& f, const vectX_t<T>& df)
+template <size_t N>
+TVDiffTester<double, std::tuple<TVCenteredDiffSecondOrderd<N>>> generateTVC2OTester(const vectX_t<double>& t, const vectX_t<double>& f, const vectX_t<double>& df)
 {
-    return { std::tuple<TVCenteredSecondOrderDiff<T, N>>{}, t, f, df };
+    return { std::tuple<TVCenteredSecondOrderDiff<N>>{}, t, f, df };
 }
\ No newline at end of file
diff --git a/tests/differentiator_tests.cpp b/tests/differentiator_tests.cpp
index 478c91f..b718715 100644
--- a/tests/differentiator_tests.cpp
+++ b/tests/differentiator_tests.cpp
@@ -83,8 +83,8 @@ TEST_CASE("Sinus time-fixed central derivative", "[sin][central][1st]")
 {
     double dt = 0.001;
     auto sg = sinGenerator<double>(STEPS, SIN_AMPLITUDE, SIN_FREQUENCY, dt);
-    auto ct7 = generateCTester<double, 7>(std::get<0>(sg), std::get<1>(sg));
-    auto ct9 = generateCTester<double, 9>(std::get<0>(sg), std::get<1>(sg));
+    auto ct7 = generateCTester<7>(std::get<0>(sg), std::get<1>(sg));
+    auto ct9 = generateCTester<9>(std::get<0>(sg), std::get<1>(sg));
 
     ct7.setFilterTimestep(dt);
     ct9.setFilterTimestep(dt);
@@ -99,8 +99,8 @@ TEST_CASE("Polynome time-fixed central derivative", "[poly][central][1st]")
     double dt = 0.001;
     {
         auto pg = polyGenerator<double>(STEPS, POLY_4<double>, dt);
-        auto ct7 = generateCTester<double, 7>(std::get<0>(pg), std::get<1>(pg));
-        auto ct9 = generateCTester<double, 9>(std::get<0>(pg), std::get<1>(pg));
+        auto ct7 = generateCTester<7>(std::get<0>(pg), std::get<1>(pg));
+        auto ct9 = generateCTester<9>(std::get<0>(pg), std::get<1>(pg));
 
         ct7.setFilterTimestep(dt);
         ct9.setFilterTimestep(dt);
@@ -111,8 +111,8 @@ TEST_CASE("Polynome time-fixed central derivative", "[poly][central][1st]")
     }
     {
         auto pg = polyGenerator<double>(STEPS, POLY_7<double>, dt);
-        auto ct7 = generateCTester<double, 7>(std::get<0>(pg), std::get<1>(pg));
-        auto ct9 = generateCTester<double, 9>(std::get<0>(pg), std::get<1>(pg));
+        auto ct7 = generateCTester<7>(std::get<0>(pg), std::get<1>(pg));
+        auto ct9 = generateCTester<9>(std::get<0>(pg), std::get<1>(pg));
 
         ct7.setFilterTimestep(dt);
         ct9.setFilterTimestep(dt);
@@ -127,9 +127,9 @@ TEST_CASE("2nd order sinus time-fixed center derivative", "[sin][center][2nd]")
 {
     double dt = 0.001;
     auto sg = sinGenerator<double>(STEPS, SIN_AMPLITUDE, SIN_FREQUENCY, dt);
-    auto ct7 = generateC2OTester<double, 7>(std::get<0>(sg), std::get<2>(sg));
-    auto ct9 = generateC2OTester<double, 9>(std::get<0>(sg), std::get<2>(sg));
-    auto ct11 = generateC2OTester<double, 11>(std::get<0>(sg), std::get<2>(sg));
+    auto ct7 = generateC2OTester<7>(std::get<0>(sg), std::get<2>(sg));
+    auto ct9 = generateC2OTester<9>(std::get<0>(sg), std::get<2>(sg));
+    auto ct11 = generateC2OTester<11>(std::get<0>(sg), std::get<2>(sg));
 
     ct7.setFilterTimestep(dt);
     ct9.setFilterTimestep(dt);
@@ -145,8 +145,8 @@ TEST_CASE("Sinus time-varying central derivative", "[tv][sin][central][1st]")
 {
     double dt = 0.001;
     auto sg = tvSinGenerator<double>(STEPS, SIN_AMPLITUDE, SIN_FREQUENCY, dt);
-    auto ct7 = generateTVCTester<double, 7>(std::get<0>(sg), std::get<1>(sg), std::get<2>(sg));
-    auto ct9 = generateTVCTester<double, 9>(std::get<0>(sg), std::get<1>(sg), std::get<2>(sg));
+    auto ct7 = generateTVCTester<7>(std::get<0>(sg), std::get<1>(sg), std::get<2>(sg));
+    auto ct9 = generateTVCTester<9>(std::get<0>(sg), std::get<1>(sg), std::get<2>(sg));
 
     std::array<double, 2> eps = { 1., 1. };
     ct7.run(eps);
@@ -158,8 +158,8 @@ TEST_CASE("Polynome time-varying central derivative", "[tv][poly][central][1st]"
     double dt = 0.001;
     {
         auto pg = tvPolyGenerator<double>(STEPS, POLY_4<double>, dt);
-        auto ct7 = generateTVCTester<double, 7>(std::get<0>(pg), std::get<1>(pg), std::get<2>(pg));
-        auto ct9 = generateTVCTester<double, 9>(std::get<0>(pg), std::get<1>(pg), std::get<2>(pg));
+        auto ct7 = generateTVCTester<7>(std::get<0>(pg), std::get<1>(pg), std::get<2>(pg));
+        auto ct9 = generateTVCTester<9>(std::get<0>(pg), std::get<1>(pg), std::get<2>(pg));
 
         std::array<double, 2> eps = { 1e-3, 1e-3 };
         ct7.run(eps);
@@ -167,8 +167,8 @@ TEST_CASE("Polynome time-varying central derivative", "[tv][poly][central][1st]"
     }
     {
         auto pg = tvPolyGenerator<double>(STEPS, POLY_4<double>, dt);
-        auto ct7 = generateTVCTester<double, 7>(std::get<0>(pg), std::get<1>(pg), std::get<2>(pg));
-        auto ct9 = generateTVCTester<double, 9>(std::get<0>(pg), std::get<1>(pg), std::get<2>(pg));
+        auto ct7 = generateTVCTester<7>(std::get<0>(pg), std::get<1>(pg), std::get<2>(pg));
+        auto ct9 = generateTVCTester<9>(std::get<0>(pg), std::get<1>(pg), std::get<2>(pg));
 
         std::array<double, 2> eps = { 1e-3, 1e-3 };
         ct7.run(eps);