mirror
/
DiFipp
kopia lustrzana https://github.com/vsamy/DiFipp
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

Uniformization of names.

topic/cross-compile v1.4.3
Vincent Samy 2019-11-12 10:12:23 +09:00
rodzic 050dd14760
commit 2cd67a45b4
4 zmienionych plików z 94 dodań i 56 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

50
include/differentiators.h
Wyświetl plik

@ -38,7 +38,7 @@ namespace details {
// T: type // T: type
// N: Number of points // 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 { template <typename T, size_t N> struct GetCDCoeffs {
vectN_t<T, N> operator()() const; vectN_t<T, N> operator()() const;
}; };
@ -304,12 +304,12 @@ public:
}; };
template <typename T, size_t N, int Order, typename CoeffGetter> template <typename T, size_t N, int Order, typename CoeffGetter>
class CentralDifferentiator : public GenericFilter<T> { class CenteredDifferentiator : public GenericFilter<T> {
public: public:
CentralDifferentiator() CenteredDifferentiator()
: GenericFilter<T>(vectX_t<T>::Constant(1, T(1)), CoeffGetter{}(), FilterType::Centered) : 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)) : 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)); } 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> 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"); static_assert(Order >= 1, "Order must be greater or equal to 1");
public: public:
TVCentralDifferentiator() TVCenteredDifferentiator()
: TVGenericFilter<T>(Order, vectX_t<T>::Constant(1, T(1)), CoeffGetter{}(), FilterType::Centered) : TVGenericFilter<T>(Order, vectX_t<T>::Constant(1, T(1)), CoeffGetter{}(), FilterType::Centered)
{} {}
}; };
@ -339,30 +339,30 @@ public:
} // namespace details } // namespace details
// Backward differentiators // 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 BackwardDiffNoiseRobust = 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 BackwardDiffHybridNoiseRobust = details::BackwardDifferentiator<T, N, 1, details::GetFHNRCoeffs<T, N>>;
// Time-Varying backward differentiators // 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 TVBackwardDiffNoiseRobust = 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 TVBackwardDiffHybridNoiseRobust = details::TVBackwardDifferentiator<T, N, 1, details::GetFHNRISDCoeffs<T, N>>;
// Central differentiators // Centered 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 CenteredDiffBasic = details::CenteredDifferentiator<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 CenteredDiffLowNoiseLanczos = details::CenteredDifferentiator<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 CenteredDiffSuperLowNoiseLanczos = details::CenteredDifferentiator<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 CenteredDiffNoiseRobust2 = details::CenteredDifferentiator<T, N, 1, details::GetCNR2Coeffs<T, N>>;
template <typename T, size_t N> using CenteredNoiseRobust4Diff = details::CentralDifferentiator<T, N, 1, details::GetCNR4Coeffs<T, N>>; template <typename T, size_t N> using CenteredDiffNoiseRobust4 = details::CenteredDifferentiator<T, N, 1, details::GetCNR4Coeffs<T, N>>;
// Time-Varying central differentiators // Time-Varying centered 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 TVCenteredDiffNoiseRobust2 = details::TVCenteredDifferentiator<T, N, 1, details::GetCNR2ISDCoeffs<T, N>>;
template <typename T, size_t N> using TVCenteredNoiseRobust4Diff = details::TVCentralDifferentiator<T, N, 1, details::GetCNR4ISDCoeffs<T, N>>; template <typename T, size_t N> using TVCenteredDiffNoiseRobust4 = details::TVCenteredDifferentiator<T, N, 1, details::GetCNR4ISDCoeffs<T, N>>;
// Second-order backward differentiators // 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 // 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 // Second-order centered differentiators
template <typename T, size_t N> using CenteredSecondOrderDiff = details::CentralDifferentiator<T, N, 2, details::GetSOCNRCoeffs<T, N>>; template <typename T, size_t N> using CenteredDiffSecondOrder = details::CenteredDifferentiator<T, N, 2, details::GetSOCNRCoeffs<T, N>>;
// Second-order Time-Varying central differentiators // Second-order Time-Varying centered differentiators
template <typename T, size_t N> using TVCenteredSecondOrderDiff = details::TVCentralDifferentiator<T, N, 2, details::GetSOCNRISDCoeffs<T, N>>; template <typename T, size_t N> using TVCenteredDiffSecondOrder = details::TVCenteredDifferentiator<T, N, 2, details::GetSOCNRISDCoeffs<T, N>>;
} // namespace difi } // namespace difi

38
include/difi
Wyświetl plik

@ -60,4 +60,42 @@ using BilinearTransformd = BilinearTransform<double>;
using BilinearTransformcf = BilinearTransform<std::complex<float>>; using BilinearTransformcf = BilinearTransform<std::complex<float>>;
using BilinearTransformcd = BilinearTransform<std::complex<double>>; 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 } // namespace difi

32
tests/diffTesters.h
Wyświetl plik

@ -136,32 +136,32 @@ private:
vectX_t<T> m_time; vectX_t<T> m_time;
}; };
template <typename T, size_t N> template <size_t N>
using central_list = std::tuple<CentralDiff<T, N>, LowNoiseLanczosDiff<T, N>, SuperLowNoiseLanczosDiff<T, N>, CenteredNoiseRobust2Diff<T, N>, CenteredNoiseRobust4Diff<T, N>>; using central_list = std::tuple<CenteredDiffBasicd<N>, CenteredDiffLowNoiseLanczosd<N>, CenteredDiffSuperLowNoiseLanczosd<N>, CenteredDiffNoiseRobust2d<N>, CenteredDiffNoiseRobust4d<N>>;
template <typename T, size_t N> template <size_t N>
TFDiffTester<T, central_list<T, N>> generateCTester(const vectX_t<T>& f, const vectX_t<T>& df) 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> template <size_t N>
TFDiffTester<T, std::tuple<CenteredSecondOrderDiff<T, N>>> generateC2OTester(const vectX_t<T>& f, const vectX_t<T>& df) 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> template <size_t N>
using tv_central_list = std::tuple<TVCenteredNoiseRobust2Diff<T, N>, TVCenteredNoiseRobust4Diff<T, N>>; using tv_central_list = std::tuple<TVCenteredDiffNoiseRobust2d<N>, TVCenteredDiffNoiseRobust4d<N>>;
template <typename T, size_t N> template <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) 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> template <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) 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 };
} }

30
tests/differentiator_tests.cpp
Wyświetl plik

@ -83,8 +83,8 @@ TEST_CASE("Sinus time-fixed central derivative", "[sin][central][1st]")
{ {
double dt = 0.001; double dt = 0.001;
auto sg = sinGenerator<double>(STEPS, SIN_AMPLITUDE, SIN_FREQUENCY, dt); auto sg = sinGenerator<double>(STEPS, SIN_AMPLITUDE, SIN_FREQUENCY, dt);
auto ct7 = generateCTester<double, 7>(std::get<0>(sg), std::get<1>(sg)); auto ct7 = generateCTester<7>(std::get<0>(sg), std::get<1>(sg));
auto ct9 = generateCTester<double, 9>(std::get<0>(sg), std::get<1>(sg)); auto ct9 = generateCTester<9>(std::get<0>(sg), std::get<1>(sg));
ct7.setFilterTimestep(dt); ct7.setFilterTimestep(dt);
ct9.setFilterTimestep(dt); ct9.setFilterTimestep(dt);
@ -99,8 +99,8 @@ TEST_CASE("Polynome time-fixed central derivative", "[poly][central][1st]")
double dt = 0.001; double dt = 0.001;
{ {
auto pg = polyGenerator<double>(STEPS, POLY_4<double>, dt); auto pg = polyGenerator<double>(STEPS, POLY_4<double>, dt);
auto ct7 = generateCTester<double, 7>(std::get<0>(pg), std::get<1>(pg)); auto ct7 = generateCTester<7>(std::get<0>(pg), std::get<1>(pg));
auto ct9 = generateCTester<double, 9>(std::get<0>(pg), std::get<1>(pg)); auto ct9 = generateCTester<9>(std::get<0>(pg), std::get<1>(pg));
ct7.setFilterTimestep(dt); ct7.setFilterTimestep(dt);
ct9.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 pg = polyGenerator<double>(STEPS, POLY_7<double>, dt);
auto ct7 = generateCTester<double, 7>(std::get<0>(pg), std::get<1>(pg)); auto ct7 = generateCTester<7>(std::get<0>(pg), std::get<1>(pg));
auto ct9 = generateCTester<double, 9>(std::get<0>(pg), std::get<1>(pg)); auto ct9 = generateCTester<9>(std::get<0>(pg), std::get<1>(pg));
ct7.setFilterTimestep(dt); ct7.setFilterTimestep(dt);
ct9.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; double dt = 0.001;
auto sg = sinGenerator<double>(STEPS, SIN_AMPLITUDE, SIN_FREQUENCY, dt); auto sg = sinGenerator<double>(STEPS, SIN_AMPLITUDE, SIN_FREQUENCY, dt);
auto ct7 = generateC2OTester<double, 7>(std::get<0>(sg), std::get<2>(sg)); auto ct7 = generateC2OTester<7>(std::get<0>(sg), std::get<2>(sg));
auto ct9 = generateC2OTester<double, 9>(std::get<0>(sg), std::get<2>(sg)); auto ct9 = generateC2OTester<9>(std::get<0>(sg), std::get<2>(sg));
auto ct11 = generateC2OTester<double, 11>(std::get<0>(sg), std::get<2>(sg)); auto ct11 = generateC2OTester<11>(std::get<0>(sg), std::get<2>(sg));
ct7.setFilterTimestep(dt); ct7.setFilterTimestep(dt);
ct9.setFilterTimestep(dt); ct9.setFilterTimestep(dt);
@ -145,8 +145,8 @@ TEST_CASE("Sinus time-varying central derivative", "[tv][sin][central][1st]")
{ {
double dt = 0.001; double dt = 0.001;
auto sg = tvSinGenerator<double>(STEPS, SIN_AMPLITUDE, SIN_FREQUENCY, dt); 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 ct7 = generateTVCTester<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 ct9 = generateTVCTester<9>(std::get<0>(sg), std::get<1>(sg), std::get<2>(sg));
std::array<double, 2> eps = { 1., 1. }; std::array<double, 2> eps = { 1., 1. };
ct7.run(eps); ct7.run(eps);
@ -158,8 +158,8 @@ TEST_CASE("Polynome time-varying central derivative", "[tv][poly][central][1st]"
double dt = 0.001; double dt = 0.001;
{ {
auto pg = tvPolyGenerator<double>(STEPS, POLY_4<double>, dt); 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 ct7 = generateTVCTester<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 ct9 = generateTVCTester<9>(std::get<0>(pg), std::get<1>(pg), std::get<2>(pg));
std::array<double, 2> eps = { 1e-3, 1e-3 }; std::array<double, 2> eps = { 1e-3, 1e-3 };
ct7.run(eps); 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 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 ct7 = generateTVCTester<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 ct9 = generateTVCTester<9>(std::get<0>(pg), std::get<1>(pg), std::get<2>(pg));
std::array<double, 2> eps = { 1e-3, 1e-3 }; std::array<double, 2> eps = { 1e-3, 1e-3 };
ct7.run(eps); ct7.run(eps);