From ad82c2dc64e71437de7ef681cff4462ef97fbe61 Mon Sep 17 00:00:00 2001
From: Carl Klemm <carl@uvos.xyz>
Date: Tue, 3 May 2022 13:47:21 +0200
Subject: [PATCH] Switch from double to fvalue everywhere to allow selectable
 percission

---
 cap.cpp                       | 12 ++++++------
 constantphase.cpp             | 12 ++++++------
 eisgenerator/cap.h            | 10 +++++-----
 eisgenerator/componant.h      | 12 +++++++-----
 eisgenerator/constantphase.h  | 12 ++++++------
 eisgenerator/model.h          | 10 +++++-----
 eisgenerator/paralellseriel.h |  4 ++--
 eisgenerator/resistor.h       | 10 +++++-----
 eisgenerator/warburg.h        | 10 +++++-----
 main.cpp                      |  5 ++---
 model.cpp                     | 36 +++++++++++++++++------------------
 normalize.cpp                 |  2 +-
 paralellseriel.cpp            | 12 ++++++------
 resistor.cpp                  | 12 ++++++------
 warburg.cpp                   | 14 +++++++-------
 15 files changed, 87 insertions(+), 86 deletions(-)

diff --git a/cap.cpp b/cap.cpp
index 2eee9f3..61e9041 100644
--- a/cap.cpp
+++ b/cap.cpp
@@ -7,7 +7,7 @@
 
 using namespace eis;
 
-Cap::Cap(double c): _C(c)
+Cap::Cap(fvalue c): _C(c)
 {
 
 }
@@ -35,17 +35,17 @@ Cap::Cap(std::string paramStr)
 	}
 }
 
-std::complex<double> Cap::execute(double omega)
+std::complex<fvalue> Cap::execute(fvalue omega)
 {
-	return std::complex<double>(0, 0.0-(1.0/(_C*omega)));
+	return std::complex<fvalue>(0, 0.0-(1.0/(_C*omega)));
 }
 
-std::vector<double> Cap::getParam()
+std::vector<fvalue> Cap::getParam()
 {
-	return std::vector<double>({_C});
+	return std::vector<fvalue>({_C});
 }
 
-void Cap::setParam(const std::vector<double>& param)
+void Cap::setParam(const std::vector<fvalue>& param)
 {
 	if(param.empty())
 	{
diff --git a/constantphase.cpp b/constantphase.cpp
index a3098ea..6022ba8 100644
--- a/constantphase.cpp
+++ b/constantphase.cpp
@@ -7,7 +7,7 @@
 
 using namespace eis;
 
-Cpe::Cpe(double q, double alpha): _Q(q), _alpha(alpha)
+Cpe::Cpe(fvalue q, fvalue alpha): _Q(q), _alpha(alpha)
 {
 
 }
@@ -38,18 +38,18 @@ Cpe::Cpe(std::string paramStr)
 	}
 }
 
-std::complex<double> Cpe::execute(double omega)
+std::complex<fvalue> Cpe::execute(fvalue omega)
 {
-	return std::complex<double>((1.0/(_Q*pow(omega, _alpha)))*cos((M_PI/2)*_alpha),
+	return std::complex<fvalue>((1.0/(_Q*pow(omega, _alpha)))*cos((M_PI/2)*_alpha),
 	                           0-(1.0/(_Q*pow(omega, _alpha)))*sin((M_PI/2)*_alpha));
 }
 
-std::vector<double> Cpe::getParam()
+std::vector<fvalue> Cpe::getParam()
 {
-	return std::vector<double>({_Q, _alpha});
+	return std::vector<fvalue>({_Q, _alpha});
 }
 
-void Cpe::setParam(const std::vector<double>& param)
+void Cpe::setParam(const std::vector<fvalue>& param)
 {
 	if(param.size() < 2)
 	{
diff --git a/eisgenerator/cap.h b/eisgenerator/cap.h
index dc5001e..d394f83 100644
--- a/eisgenerator/cap.h
+++ b/eisgenerator/cap.h
@@ -10,13 +10,13 @@ namespace eis
 class Cap: public Componant
 {
 private:
-	double _C;
+	fvalue _C;
 public:
 	Cap(std::string paramStr);
-	Cap(double c = 1e-6);
-	virtual std::complex<double> execute(double omega) override;
-	virtual std::vector<double> getParam() override;
-	virtual void setParam(const std::vector<double>& param) override;
+	Cap(fvalue c = 1e-6);
+	virtual std::complex<fvalue> execute(fvalue omega) override;
+	virtual std::vector<fvalue> getParam() override;
+	virtual void setParam(const std::vector<fvalue>& param) override;
 	virtual size_t paramCount() override;
 	virtual ~Cap() = default;
 };
diff --git a/eisgenerator/componant.h b/eisgenerator/componant.h
index 8d2ca10..141049e 100644
--- a/eisgenerator/componant.h
+++ b/eisgenerator/componant.h
@@ -3,23 +3,25 @@
 #include <iostream>
 #include <vector>
 
+#include "eistype.h"
+
 namespace eis
 {
 
 class Componant
 {
 	public:
-		virtual std::complex<double> execute(double omega)
+		virtual std::complex<fvalue> execute(fvalue omega)
 		{
 			std::cout<<"warning incompleat model\n";
-			return std::complex<double> (1,0);
+			return std::complex<fvalue> (1,0);
 		}
 
-		virtual std::vector<double> getParam()
+		virtual std::vector<fvalue> getParam()
 		{
-			return std::vector<double>();
+			return std::vector<fvalue>();
 		};
-		virtual void setParam(const std::vector<double>& param){};
+		virtual void setParam(const std::vector<fvalue>& param){};
 		virtual size_t paramCount(){return 0;}
 		virtual ~Componant() = default;
 
diff --git a/eisgenerator/constantphase.h b/eisgenerator/constantphase.h
index c9e35a1..1158717 100644
--- a/eisgenerator/constantphase.h
+++ b/eisgenerator/constantphase.h
@@ -10,14 +10,14 @@ namespace eis
 class Cpe: public Componant
 {
 private:
-	double _Q;
-	double _alpha;
+	fvalue _Q;
+	fvalue _alpha;
 public:
 	Cpe(std::string paramStr);
-	Cpe(double q = 1e-7, double alpha = 0.9);
-	virtual std::complex<double> execute(double omega) override;
-	virtual std::vector<double> getParam() override;
-	virtual void setParam(const std::vector<double>& param) override;
+	Cpe(fvalue q = 1e-7, fvalue alpha = 0.9);
+	virtual std::complex<fvalue> execute(fvalue omega) override;
+	virtual std::vector<fvalue> getParam() override;
+	virtual void setParam(const std::vector<fvalue>& param) override;
 	virtual size_t paramCount() override;
 	virtual ~Cpe() = default;
 };
diff --git a/eisgenerator/model.h b/eisgenerator/model.h
index 12029d0..0a654b3 100644
--- a/eisgenerator/model.h
+++ b/eisgenerator/model.h
@@ -31,18 +31,18 @@ public:
 	Model(const Model& in);
 	Model& operator=(const Model& in);
 	~Model();
-	DataPoint execute(double omaga);
+	DataPoint execute(fvalue omaga);
 	std::vector<DataPoint> executeSweep(const Range& omega);
-	bool executeParamSweep(const std::vector<Range>& componantRanges, const Range& omega, std::function<void(std::vector<DataPoint>&, const std::vector<double>&)> dataCb);
+	bool executeParamSweep(const std::vector<Range>& componantRanges, const Range& omega, std::function<void(std::vector<DataPoint>&, const std::vector<fvalue>&)> dataCb);
 	std::vector<DataPoint> executeParamByIndex(const std::vector<Range>& componantRanges, const Range& omega, size_t index);
 
 	std::string getModelStr();
 	std::vector<Componant*> getFlatComponants();
-	std::vector<double> getFlatParameters();
+	std::vector<fvalue> getFlatParameters();
 	size_t getFlatParametersCount();
-	bool setFlatParameters(const std::vector<double>& parameters);
+	bool setFlatParameters(const std::vector<fvalue>& parameters);
 
-	static std::vector<double> getSweepParamByIndex(const std::vector<Range>& componantRanges, size_t index);
+	static std::vector<fvalue> getSweepParamByIndex(const std::vector<Range>& componantRanges, size_t index);
 	static size_t getRequiredStepsForSweeps(const std::vector<Range>& componantRanges);
 };
 
diff --git a/eisgenerator/paralellseriel.h b/eisgenerator/paralellseriel.h
index 2e027cb..e764c97 100644
--- a/eisgenerator/paralellseriel.h
+++ b/eisgenerator/paralellseriel.h
@@ -15,7 +15,7 @@ public:
 	Parallel(const Parallel& in);
 	void operator=(const Parallel& in);
 	~Parallel();
-	virtual std::complex<double> execute(double omaga) override;
+	virtual std::complex<fvalue> execute(fvalue omaga) override;
 };
 
 class Serial: public Componant
@@ -27,7 +27,7 @@ public:
 	Serial(const Serial& in);
 	void operator=(const Serial& in);
 	~Serial();
-	virtual std::complex<double> execute(double omaga) override;
+	virtual std::complex<fvalue> execute(fvalue omaga) override;
 };
 
 }
diff --git a/eisgenerator/resistor.h b/eisgenerator/resistor.h
index 7462b67..42bc4d6 100644
--- a/eisgenerator/resistor.h
+++ b/eisgenerator/resistor.h
@@ -8,14 +8,14 @@ namespace eis
 class Resistor: public Componant
 {
 private:
-	double _R;
+	fvalue _R;
 
 public:
-	Resistor(double r);
+	Resistor(fvalue r);
 	Resistor(std::string paramStr);
-	virtual std::complex<double> execute(double omega)  override;
-	virtual std::vector<double> getParam() override;
-	virtual void setParam(const std::vector<double>& param) override;
+	virtual std::complex<fvalue> execute(fvalue omega)  override;
+	virtual std::vector<fvalue> getParam() override;
+	virtual void setParam(const std::vector<fvalue>& param) override;
 	virtual size_t paramCount() override;
 	virtual ~Resistor() = default;
 };
diff --git a/eisgenerator/warburg.h b/eisgenerator/warburg.h
index 635e49b..0974d99 100644
--- a/eisgenerator/warburg.h
+++ b/eisgenerator/warburg.h
@@ -10,13 +10,13 @@ namespace eis
 class Warburg: public Componant
 {
 private:
-	double _A = 2e4;
+	fvalue _A = 2e4;
 public:
 	Warburg(std::string paramStr);
-	Warburg(double a = 2e4);
-	virtual std::complex<double> execute(double omega) override;
-	virtual std::vector<double> getParam() override;
-	virtual void setParam(const std::vector<double>& param) override;
+	Warburg(fvalue a = 2e4);
+	virtual std::complex<fvalue> execute(fvalue omega) override;
+	virtual std::vector<fvalue> getParam() override;
+	virtual void setParam(const std::vector<fvalue>& param) override;
 	virtual size_t paramCount() override;
 	virtual ~Warburg() = default;
 };
diff --git a/main.cpp b/main.cpp
index 7e80c02..062131c 100644
--- a/main.cpp
+++ b/main.cpp
@@ -8,7 +8,6 @@
 #include "options.h"
 #include "normalize.h"
 
-
 static void printComponants(eis::Model& model)
 {
 	eis::Log(eis::Log::DEBUG)<<"Compnants:";
@@ -25,7 +24,7 @@ static void printComponants(eis::Model& model)
 	}
 }
 
-static void paramSweepCb(std::vector<eis::DataPoint>& data, const std::vector<double>& parameters)
+static void paramSweepCb(std::vector<eis::DataPoint>& data, const std::vector<fvalue>& parameters)
 {
 	static size_t i = 0;
 	++i;
@@ -99,7 +98,7 @@ int main(int argc, char** argv)
 	argp_parse(&argp, argc, argv, 0, 0, &config);
 
 	if(config.hertz)
-		config.omegaRange = config.omegaRange*2*M_PI;
+		config.omegaRange = config.omegaRange*static_cast<fvalue>(2*M_PI);
 
 	switch(config.mode)
 	{
diff --git a/model.cpp b/model.cpp
index b099c84..5ec2ad0 100644
--- a/model.cpp
+++ b/model.cpp
@@ -185,7 +185,7 @@ Model::~Model()
 	delete _model;
 }
 
-DataPoint Model::execute(double omega)
+DataPoint Model::execute(fvalue omega)
 {
 	if(_model)
 	{
@@ -198,7 +198,7 @@ DataPoint Model::execute(double omega)
 	{
 		Log(Log::WARN)<<"model not ready";
 	}
-	return DataPoint({std::complex<double>(0,0), 0});
+	return DataPoint({std::complex<fvalue>(0,0), 0});
 }
 
 void Model::addComponantToFlat(Componant* componant)
@@ -238,8 +238,8 @@ std::vector<DataPoint> Model::executeSweep(const Range& omega)
 
 	if(!omega.log)
 	{
-		double currOmega = omega.start;
-		double step = (omega.end - omega.start)/(omega.count-1);
+		fvalue currOmega = omega.start;
+		fvalue step = (omega.end - omega.start)/(omega.count-1);
 
 		for(size_t i = 0; i < omega.count; ++i)
 		{
@@ -249,10 +249,10 @@ std::vector<DataPoint> Model::executeSweep(const Range& omega)
 	}
 	else
 	{
-		double start = log10(omega.start);
-		double end = log10(omega.end);
-		double step = (end-start)/(omega.count-1);
-		double currOmegaL = start;
+		fvalue start = log10(omega.start);
+		fvalue end = log10(omega.end);
+		fvalue step = (end-start)/(omega.count-1);
+		fvalue currOmegaL = start;
 
 		for(size_t i = 0; i < omega.count; ++i)
 		{
@@ -265,7 +265,7 @@ std::vector<DataPoint> Model::executeSweep(const Range& omega)
 
 std::vector<DataPoint> Model::executeParamByIndex(const std::vector<Range>& componantRanges, const Range& omega, size_t index)
 {
-	std::vector<double> parameters = getSweepParamByIndex(componantRanges, index);
+	std::vector<fvalue> parameters = getSweepParamByIndex(componantRanges, index);
 	assert(setFlatParameters(parameters));
 
 	return executeSweep(omega);
@@ -279,7 +279,7 @@ size_t Model::getRequiredStepsForSweeps(const std::vector<Range>& componantRange
 	return stepsRequired;
 }
 
-std::vector<double> Model::getSweepParamByIndex(const std::vector<Range>& componantRanges, size_t index)
+std::vector<fvalue> Model::getSweepParamByIndex(const std::vector<Range>& componantRanges, size_t index)
 {
 	size_t parametersCount = componantRanges.size();
 	std::vector<size_t> parameterIndexies(parametersCount, 0);
@@ -290,14 +290,14 @@ std::vector<double> Model::getSweepParamByIndex(const std::vector<Range>& compon
 		index -= parameterIndexies[i];
 	}
 
-	std::vector<double> parameters(parametersCount, 0);
+	std::vector<fvalue> parameters(parametersCount, 0);
 	for(size_t i = 0; i < parametersCount; ++i)
 		parameters[i] = parameterIndexies[i]*componantRanges[i].stepSize()+componantRanges[i].start;
 	return parameters;
 }
 
 bool Model::executeParamSweep(const std::vector<Range>& componantRanges, const Range& omega,
-                              std::function<void(std::vector<DataPoint>&, const std::vector<double>&)> dataCb)
+                              std::function<void(std::vector<DataPoint>&, const std::vector<fvalue>&)> dataCb)
 {
 	size_t parametersCount = getFlatParametersCount();
 	if(componantRanges.size() != parametersCount)
@@ -322,7 +322,7 @@ bool Model::executeParamSweep(const std::vector<Range>& componantRanges, const R
 
 	size_t stepsRequired = getRequiredStepsForSweeps(componantRanges);
 
-	std::vector<double> currentParam(parametersCount, 0);
+	std::vector<fvalue> currentParam(parametersCount, 0);
 	for(size_t i = 0; i < parametersCount; ++i)
 		currentParam[i] = componantRanges[i].start;
 
@@ -338,7 +338,7 @@ bool Model::executeParamSweep(const std::vector<Range>& componantRanges, const R
 	return true;
 }
 
-bool Model::setFlatParameters(const std::vector<double>& parameters)
+bool Model::setFlatParameters(const std::vector<fvalue>& parameters)
 {
 	if(parameters.size() != getFlatParametersCount())
 		return false;
@@ -346,7 +346,7 @@ bool Model::setFlatParameters(const std::vector<double>& parameters)
 	size_t i = 0;
 	for(Componant* componant : getFlatComponants())
 	{
-		std::vector<double> params;
+		std::vector<fvalue> params;
 		for(size_t j = 0; j < componant->paramCount(); ++j)
 			params.push_back(parameters[i++]);
 		componant->setParam(params);
@@ -355,13 +355,13 @@ bool Model::setFlatParameters(const std::vector<double>& parameters)
 	return true;
 }
 
-std::vector<double> Model::getFlatParameters()
+std::vector<fvalue> Model::getFlatParameters()
 {
-	std::vector<double> params;
+	std::vector<fvalue> params;
 	std::vector<Componant*> componants = getFlatComponants();
 	for(Componant* componant : componants)
 	{
-		for(double param : componant->getParam())
+		for(fvalue param : componant->getParam())
 			params.push_back(param);
 	}
 	return params;
diff --git a/normalize.cpp b/normalize.cpp
index c5f57eb..8494339 100644
--- a/normalize.cpp
+++ b/normalize.cpp
@@ -20,7 +20,7 @@ void eis::eraseSingularites(std::vector<eis::DataPoint>& data)
 			while(right < data.size()-2 && std::abs(eis::absGrad(data, right)) > 10)
 				++right;
 
-			std::complex<fvalue> mean = (data[left].im + data[right].im)/2.0;
+			std::complex<fvalue> mean = (data[left].im + data[right].im)/static_cast<fvalue>(2.0);
 			for(size_t j = left; j < right; ++j)
 				data[j].im = mean;
 		}
diff --git a/paralellseriel.cpp b/paralellseriel.cpp
index ffae512..458675b 100644
--- a/paralellseriel.cpp
+++ b/paralellseriel.cpp
@@ -25,14 +25,14 @@ Parallel::~Parallel()
 		delete componant;
 }
 
-std::complex<double> Parallel::execute(double omega)
+std::complex<fvalue> Parallel::execute(fvalue omega)
 {
-	std::complex<double> accum(0,0);
+	std::complex<fvalue> accum(0,0);
 	for(Componant* componant : componants)
 	{
-		accum += std::complex<double>(1,0)/componant->execute(omega);
+		accum += std::complex<fvalue>(1,0)/componant->execute(omega);
 	}
-	return std::complex<double>(1,0)/accum;
+	return std::complex<fvalue>(1,0)/accum;
 }
 
 Serial::Serial(std::vector<Componant*> componantsIn): componants(componantsIn)
@@ -58,9 +58,9 @@ Serial::~Serial()
 		delete componant;
 }
 
-std::complex<double> Serial::execute(double omega)
+std::complex<fvalue> Serial::execute(fvalue omega)
 {
-	std::complex<double> accum(0,0);
+	std::complex<fvalue> accum(0,0);
 	for(Componant* componant : componants)
 	{
 		accum += componant->execute(omega);
diff --git a/resistor.cpp b/resistor.cpp
index 58b524a..eb487bc 100644
--- a/resistor.cpp
+++ b/resistor.cpp
@@ -7,7 +7,7 @@
 
 using namespace eis;
 
-Resistor::Resistor(double r): _R(r)
+Resistor::Resistor(fvalue r): _R(r)
 {}
 
 Resistor::Resistor(std::string paramStr)
@@ -33,18 +33,18 @@ Resistor::Resistor(std::string paramStr)
 	}
 }
 
-std::complex<double> Resistor::execute(double omega)
+std::complex<fvalue> Resistor::execute(fvalue omega)
 {
 	(void)omega;
-	return std::complex<double>(_R, 0);
+	return std::complex<fvalue>(_R, 0);
 }
 
-std::vector<double> Resistor::getParam()
+std::vector<fvalue> Resistor::getParam()
 {
-	return std::vector<double>({_R});
+	return std::vector<fvalue>({_R});
 }
 
-void Resistor::setParam(const std::vector<double>& param)
+void Resistor::setParam(const std::vector<fvalue>& param)
 {
 	if(param.empty())
 	{
diff --git a/warburg.cpp b/warburg.cpp
index 6700f9c..2dd1f3a 100644
--- a/warburg.cpp
+++ b/warburg.cpp
@@ -7,7 +7,7 @@
 
 using namespace eis;
 
-Warburg::Warburg(double a): _A(a)
+Warburg::Warburg(fvalue a): _A(a)
 {
 
 }
@@ -33,18 +33,18 @@ Warburg::Warburg(std::string paramStr)
 	}
 }
 
-std::complex<double> Warburg::execute(double omega)
+std::complex<fvalue> Warburg::execute(fvalue omega)
 {
-	double N = _A/(sqrt(omega));
-	return std::complex<double>(N, 0-N);
+	fvalue N = _A/(sqrt(omega));
+	return std::complex<fvalue>(N, 0-N);
 }
 
-std::vector<double> Warburg::getParam()
+std::vector<fvalue> Warburg::getParam()
 {
-	return std::vector<double>({_A});
+	return std::vector<fvalue>({_A});
 }
 
-void Warburg::setParam(const std::vector<double>& param)
+void Warburg::setParam(const std::vector<fvalue>& param)
 {
 	if(param.size() != paramCount())
 	{
-- 
GitLab