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
// 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

38
include/difi
Wyświetl plik

@ -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

32
tests/diffTesters.h
Wyświetl plik

@ -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 };
}

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;
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);