diff --git a/cap.cpp b/cap.cpp
index 2eee9f3ec047ccec9f534cc48dcc7087d11c2361..61e9041dabc5c0ad680df5701b7c906bbd173dd8 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 a3098eadaecde80c36435e2e84af5967b96b365f..6022ba85d52da43f1931e8f8e4cdc7db6539b641 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 dc5001eece98ddbf480dea6fe6ee0c48db84f616..d394f833b3d05a23553fa4baa34d893195fb351e 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 8d2ca10387b36c8ec85738c687e8a111f3974b3a..141049e50eb674a472e3dd74ebc72295d31e649f 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 c9e35a14d5b45b7071138838e5eb1d024909fcfd..11587171c525bd7200310251423969943d4cec28 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 12029d030222189883ebffe6659cf00974bc5f7a..0a654b39e58c118227502b0101ca21a6325987bd 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 2e027cb9df0f4e86115c3cd91c672fe0bf27bb47..e764c970083106ec9ad887bae40ee4bc72f3c74e 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 7462b673492e428e401fdfa1b0a3a5a0406e6133..42bc4d68eb64cacddd4b1248affffa4c1b15e525 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 635e49b266535ae8c12a2d5555747f38095f6e9e..0974d9949933a6d39afacdd04d691db3ff9e816c 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 7e80c028ae16b8aa5192941d2e783774205e5f06..062131c1d1f58f43bab88a8b28a7e4d67612c80e 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 b099c84a45e9fa2ddd7e8f7930700ba53fe4ed9f..5ec2ad0ed415beb6cc19ce25c0237d0d471c1345 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 c5f57ebe6d404496c94f1fca473d3418e6112a0b..849433971f4415cbe6bd343f0f77cb03be5cc6fb 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 ffae512b3bafab4e692c0d35badaa0225b4267a4..458675b300bf256b49344fee74b4d64e9f3c8411 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 58b524a5872db40f4bddb9bfe66a58167ee07788..eb487bcd4398c9dedd1cc5a5f60ffca731b0dccd 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 6700f9c8e373be60c26011954a54ab97a2588eaa..2dd1f3aaae42cc63073e968363a4a619741e425f 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())
 	{