Skip to content
Snippets Groups Projects
Commit 2c2c7390 authored by Carl Philipp Klemm's avatar Carl Philipp Klemm
Browse files

test: tun into real unit tests (well no framework or build system integration)

parent 80ab9b80
No related branches found
No related tags found
No related merge requests found
Show whitespace changes
Inline Side-by-side
Showing
with 211 additions and 122 deletions
test.cpp
+ 211
− 122
View file @ 2c2c7390
......@@ -27,7 +27,9 @@ std::vector<eis::DataPoint> getSine()
return data;
}
static const fvalue mocdata[25][3] = {
static constexpr size_t mocLength = 25;
static const fvalue mocdata[mocLength][3] = {
0.000000,17200.000000,0.000000,
41666.700000,2900.000000,-2.926830,
83333.300000,2900.000000,-1.463410,
......@@ -55,94 +57,107 @@ static const fvalue mocdata[25][3] = {
1000000.000000,2900.000000,-0.121951,
};
std::vector<eis::DataPoint> getMockData()
{
std::vector<eis::DataPoint> data;
static const fvalue mocNormalized[mocLength][3] = {
0,1,0,
41666.7,0,-1,
83333.3,0,-0.499998,
125000,0,-0.333333,
166667,0,-0.25,
208333,0,-0.2,
250000,0,-0.166667,
291667,0,-0.142857,
333333,0,-0.125,
375000,0,-0.111111,
416667,0,-0.1,
458333,0,-0.0909089,
500000,0,-0.0833332,
541667,0,-0.0769232,
583333,0,-0.0714285,
625000,0,-0.0666667,
666667,0,-0.0625,
708333,0,-0.0588234,
750000,0,-0.0555557,
791667,0,-0.0526317,
833333,0,-0.0499998,
875000,0,-0.0476191,
916667,0,-0.0454546,
958333,0,-0.0434781,
1e+06,0,-0.0416666,
};
for(size_t i = 0; i < sizeof(mocdata)/sizeof(*mocdata); ++i)
{
eis::DataPoint point;
point.im = std::complex<fvalue>(mocdata[i][1], mocdata[i][2]);
point.omega = mocdata[i][0];
data.push_back(point);
}
return data;
}
static void printComponants(eis::Model& model)
{
eis::Log(eis::Log::DEBUG)<<"Compnants:";
for(eis::Componant* componant : model.getFlatComponants())
{
eis::Log(eis::Log::DEBUG, false)<<componant->getComponantChar()<<"{";
std::vector<eis::Range>& ranges = componant->getParamRanges();
assert(componant->paramCount() != ranges.size());
static const fvalue lowVariance[mocLength][3] = {
0,0,0,
0,1,-1,
0,0.25,0,
0,0.5,0,
0,0,-0.25,
0,0,-0.5,
0,0.5,-0.5,
0,0.25,-0.25,
0,0.33,-0.25,
0,0.33,-0.5,
0,0.33,0,
0,0.33,-0.33,
0,0.25,-0.33,
0,0.5,-0.33,
0,0.5,0,
0,0,-0.25,
0,0,-0.5,
0,0.5,-0.5,
0,0.25,-0.25,
0,0.33,-0.25,
0,0.33,-0.5,
0,0.33,0,
0,0.33,-0.33,
0,0.25,-0.33,
0,0.5,-0.33,
};
for(size_t i = 0; i < componant->paramCount(); ++i)
{
eis::Log(eis::Log::DEBUG, false)<<ranges[i].getString();
if(i != componant->paramCount()-1)
eis::Log(eis::Log::DEBUG, false)<<", ";
}
eis::Log(eis::Log::DEBUG)<<"}";
}
}
static const fvalue highVariance[mocLength][3] = {
0,0,0,
0,1,-1,
0,0.25*2,0,
0,0.5*2,0,
0,0,-0.25*2,
0,0,-0.5*2,
0,0.5*2,-0.5*2,
0,0.25*2,-0.25*2,
0,0.33*2,-0.25*2,
0,0.33*2,-0.5*2,
0,0.33*2,0,
0,0.33*2,-0.33*2,
0,0.25*2,-0.33*2,
0,0.5*2,-0.33*2,
0,0.5*2,0,
0,0,-0.25*2,
0,0,-0.5*2,
0,0.5*2,-0.5*2,
0,0.25*2,-0.25*2,
0,0.33*2,-0.25*2,
0,0.33*2,-0.5*2,
0,0.33*2,0,
0,0.33*2,-0.33*2,
0,0.25*2,-0.33*2,
0,0.5*2,-0.33*2,
};
void runSingle()
static std::vector<eis::DataPoint> getData(const fvalue in[mocLength][3])
{
eis::Log(eis::Log::INFO)<<__func__;
std::string modelStr("w{1e3}p{1e-7, 0.7}");
std::vector<eis::DataPoint> results;
eis::Model model(modelStr);
printComponants(model);
eis::Range omega(0, 1e6, 50);
auto start = std::chrono::high_resolution_clock::now();
results = model.executeSweep(omega);
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
for(const eis::DataPoint& res : results)
eis::Log(eis::Log::INFO)<<"omega: "<<res.omega<<" real = "<<res.im.real()<<" im = "<<res.im.imag();
eis::Log(eis::Log::INFO)<<"time taken: "<<duration.count()<<" us";
}
std::vector<eis::DataPoint> data;
void sweepCb(std::vector<eis::DataPoint>& data, const std::vector<fvalue>& parameters)
for(size_t i = 0; i < mocLength; ++i)
{
static size_t i = 0;
++i;
if((i & 0x3FF) == 0)
std::cout<<'.'<<std::flush;
eis::DataPoint point;
point.im = std::complex<fvalue>(in[i][1], in[i][2]);
point.omega = in[i][0];
data.push_back(point);
}
void runSweep()
{
eis::Log(eis::Log::INFO)<<__func__;
std::string modelStr("w{1e3~50e3}p{20e-7~1e-7, 0.7~0.9}");
eis::Model model(modelStr);
eis::Range omega(0, 1e6, 25);
auto start = std::chrono::high_resolution_clock::now();
size_t len = model.getRequiredStepsForSweeps();
for(size_t i = 0; i < len; ++len)
model.executeSweep(omega, i);
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
std::cout<<std::endl;
eis::Log(eis::Log::INFO)<<"time taken: "<<duration.count()<<" ms";
return data;
}
bool runRescale()
static bool runRescale()
{
std::cout<<__func__<<'\n';
std::vector<eis::DataPoint> data;
for(size_t i = 0; i < 22; ++i)
{
......@@ -152,86 +167,160 @@ bool runRescale()
data.push_back(point);
}
std::cout<<"original:\n";
printDataVect(data);
data = eis::rescale(data, 50);
std::cout<<"rescaled size: "<<data.size()<<" rescale data: \n";
printDataVect(data);
return data.size() == 50;
}
void runReduce()
static void runReduce()
{
std::cout<<__func__<<'\n';
std::vector<eis::DataPoint> data = getMockData();
std::vector<eis::DataPoint> data = getData(mocdata);
std::cout<<"original: \n";
printDataVect(data);
data = reduceRegion(data);;
data = reduceRegion(data);
std::cout<<"reduced: \n";
printDataVect(data);
}
void runNormalize()
static bool runNormalize()
{
std::cout<<__func__<<'\n';
std::vector<eis::DataPoint> data =getMockData();
std::cout<<"original"<<'\n';
printDataVect(data);
std::vector<eis::DataPoint> data = getData(mocdata);
std::vector<eis::DataPoint> normalized = getData(mocNormalized);
eis::normalize(data);
std::cout<<"normalized"<<'\n';
double dist = eisDistance(data, normalized);
if(dist > 1e-6)
{
eis::Log(eis::Log::ERROR)<<__func__<<" expected less than 0.999 got "<<dist;
eis::Log(eis::Log::ERROR)<<__func__<<" expected:";
printDataVect(normalized);
eis::Log(eis::Log::ERROR)<<__func__<<" recived:";
printDataVect(data);
return false;
}
return true;
}
void runEraseSingularities()
inline void filterData(std::vector<eis::DataPoint>& data, size_t outputSize)
{
std::cout<<__func__<<'\n';
std::vector<eis::DataPoint> data;
for(size_t i = 0; i < 1000; ++i)
data = eis::reduceRegion(data);
if(data.size() < outputSize/8)
{
eis::DataPoint point;
point.im = std::complex<fvalue>(1.0/(i/100.0), 1.0/((i-2)/100.0));
point.omega = i;
data.push_back(point);
data = std::vector<eis::DataPoint>();
return;
}
data = eis::rescale(data, outputSize/2);
}
std::cout<<"original"<<'\n';
printDataVect(data);
static bool testDistance()
{
eis::Model modelA("r{10000}c{2.06914e-10}-p{4.83293e-05, 0.5}");
eis::Model modelB("r{10000}c{2.97635e-07}-p{0.0001, 0.584211}");
eis::Range omega(1, 1e6, 50, true);
std::vector<eis::DataPoint> a = modelA.executeSweep(omega);
std::vector<eis::DataPoint> b = modelB.executeSweep(omega);
normalize(a);
normalize(b);
double dist = eisDistance(a, b);
if(dist > 0.36 && dist < 0.35)
{
eis::Log(eis::Log::ERROR)<<__func__<<" expected 0.36 > x > 0.35 got "<<dist;
return false;
}
eis::Log(eis::Log::INFO)<<__func__<<" "<<dist;
return true;
}
eraseSingularites(data);
static bool modelConsistancy()
{
std::string modelStr("r{1000}c{1~10000L}-p{1, 4}-w{10}-l{1e-10}");
eis::Model model(modelStr);
std::cout<<"erased"<<'\n';
printDataVect(data);
if(model.getModelStrWithParam() == modelStr)
{
return true;
}
else
{
eis::Log(eis::Log::ERROR)<<__func__<<" expected "<<modelStr<<" got "<<model.getModelStrWithParam();
return false;
}
}
inline void filterData(std::vector<eis::DataPoint>& data, size_t outputSize)
static bool uneededBrackets()
{
data = eis::reduceRegion(data);
std::string tst("(c-(rc)-(r-cr))");
eisRemoveUnneededBrackets(tst);
if(tst == "c-rc-(r-cr)")
{
return true;
}
else
{
eis::Log(eis::Log::ERROR)<<__func__<<" expected "<<"c-rc-(r-cr)"<<" got "<<tst;
return false;
}
}
if(data.size() < outputSize/8)
static bool nyquistVariance()
{
data = std::vector<eis::DataPoint>();
return;
eis::Model modelA("r{10000}c{2.06914e-10}");
eis::Model modelB("r{100000000}c{2.06914e-10}");
eis::Range omega(1, 1e6, 50, true);
std::vector<eis::DataPoint> a = modelA.executeSweep(omega);
std::vector<eis::DataPoint> b = modelB.executeSweep(omega);
normalize(a);
normalize(b);
fvalue aVar = nyquistAreaVariance(a);
fvalue bVar = nyquistAreaVariance(b);
eis::Log(eis::Log::INFO)<<__func__<<" aVar: "<<aVar<<" bVar: "<<bVar;
return eis::fvalueEq(aVar, 0.38375) && eis::fvalueEq(bVar, 0.514179);
}
data = eis::rescale(data, outputSize/2);
static bool nyquistJump()
{
eis::Model modelA("r{10000}c{2.06914e-10}");
eis::Model modelB("r{100000000}c{2.06914e-10}");
eis::Range omega(1, 1e6, 50, true);
std::vector<eis::DataPoint> a = modelA.executeSweep(omega);
std::vector<eis::DataPoint> b = modelB.executeSweep(omega);
normalize(a);
normalize(b);
fvalue aVar = maximumNyquistJump(a);
fvalue bVar = maximumNyquistJump(b);
eis::Log(eis::Log::INFO)<<__func__<<" aVar: "<<aVar<<" bVar: "<<bVar;
return eis::fvalueEq(aVar, 0.38375);
}
int main(int argc, char** argv)
{
std::string tst("(c)");
eisRemoveUnneededBrackets(tst);
eis::Log::headers = true;
eis::Log::level = eis::Log::INFO;
runSingle();
runSweep();
runRescale();
runNormalize();
runEraseSingularities();
runReduce();
if(!uneededBrackets())
return 1;
if(!modelConsistancy())
return 2;
if(!runRescale())
return 3;
if(!testDistance())
return 4;
if(!runNormalize())
return 5;
if(!nyquistVariance())
return 6;
if(!nyquistJump())
return 7;
return 0;
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment