From: Benjamin Auder <benjamin.auder@somewhere>
Date: Thu, 12 Jan 2017 19:39:50 +0000 (+0100)
Subject: C-part of tests ready [TODO: R part]
X-Git-Url: https://git.auder.net/variants/img/pieces/scripts/doc/html/index.css?a=commitdiff_plain;h=afa07d41c7592ac0ccd55d7af23c3bfef213291e;p=valse.git

C-part of tests ready [TODO: R part]
---

diff --git a/.gitignore b/.gitignore
index b5f5640..767ee1a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
+#global ignores
 .Rhistory
 .RData
-*.o
-*.so
+*.swp
+*~
diff --git a/src/.gitignore b/src/.gitignore
new file mode 100644
index 0000000..d8d0ef0
--- /dev/null
+++ b/src/.gitignore
@@ -0,0 +1,5 @@
+#ignore object files, library and test executables
+*.o
+*.so
+test.*
+!test.*.c
diff --git a/src/sources/EMGLLF.c b/src/sources/EMGLLF.c
index 42419ac..1439416 100644
--- a/src/sources/EMGLLF.c
+++ b/src/sources/EMGLLF.c
@@ -5,23 +5,23 @@
 // TODO: don't recompute indexes every time......
 void EMGLLF_core(
 	// IN parameters
-	const double* phiInit, // parametre initial de moyenne renormalisé
-	const double* rhoInit, // parametre initial de variance renormalisé
-	const double* piInit,	 // parametre initial des proportions
-	const double* gamInit, // paramètre initial des probabilités a posteriori de chaque échantillon
+	const float* phiInit, // parametre initial de moyenne renormalisé
+	const float* rhoInit, // parametre initial de variance renormalisé
+	const float* piInit,	 // parametre initial des proportions
+	const float* gamInit, // paramètre initial des probabilités a posteriori de chaque échantillon
 	int mini, // nombre minimal d'itérations dans l'algorithme EM
 	int maxi, // nombre maximal d'itérations dans l'algorithme EM
-	double gamma, // puissance des proportions dans la pénalisation pour un Lasso adaptatif
-	double lambda, // valeur du paramètre de régularisation du Lasso
-	const double* X, // régresseurs
-	const double* Y, // réponse
-	double tau, // seuil pour accepter la convergence
+	float gamma, // puissance des proportions dans la pénalisation pour un Lasso adaptatif
+	float lambda, // valeur du paramètre de régularisation du Lasso
+	const float* X, // régresseurs
+	const float* Y, // réponse
+	float tau, // seuil pour accepter la convergence
 	// OUT parameters (all pointers, to be modified)
-	double* phi, // parametre de moyenne renormalisé, calculé par l'EM
-	double* rho, // parametre de variance renormalisé, calculé par l'EM
-	double* pi, // parametre des proportions renormalisé, calculé par l'EM
-	double* LLF, // log vraisemblance associée à cet échantillon, pour les valeurs estimées des paramètres
-	double* S,
+	float* phi, // parametre de moyenne renormalisé, calculé par l'EM
+	float* rho, // parametre de variance renormalisé, calculé par l'EM
+	float* pi, // parametre des proportions renormalisé, calculé par l'EM
+	float* LLF, // log vraisemblance associée à cet échantillon, pour les valeurs estimées des paramètres
+	float* S,
 	// additional size parameters
 	int n, // nombre d'echantillons
 	int p, // nombre de covariables
@@ -37,32 +37,32 @@ void EMGLLF_core(
 
 	//Other local variables
 	//NOTE: variables order is always [maxi],n,p,m,k
-	double* gam = (double*)malloc(n*k*sizeof(double));
+	float* gam = (float*)malloc(n*k*sizeof(float));
 	copyArray(gamInit, gam, n*k);
-	double* b = (double*)malloc(k*sizeof(double));
-	double* Phi = (double*)malloc(p*m*k*sizeof(double));
-	double* Rho = (double*)malloc(m*m*k*sizeof(double));
-	double* Pi = (double*)malloc(k*sizeof(double));
-	double* gam2 = (double*)malloc(k*sizeof(double));
-	double* pi2 = (double*)malloc(k*sizeof(double));
-	double* Gram2 = (double*)malloc(p*p*k*sizeof(double));
-	double* ps = (double*)malloc(m*k*sizeof(double));
-	double* nY2 = (double*)malloc(m*k*sizeof(double));
-	double* ps1 = (double*)malloc(n*m*k*sizeof(double));
-	double* ps2 = (double*)malloc(p*m*k*sizeof(double));
-	double* nY21 = (double*)malloc(n*m*k*sizeof(double));
-	double* Gam = (double*)malloc(n*k*sizeof(double));
-	double* X2 = (double*)malloc(n*p*k*sizeof(double));
-	double* Y2 = (double*)malloc(n*m*k*sizeof(double));
+	float* b = (float*)malloc(k*sizeof(float));
+	float* Phi = (float*)malloc(p*m*k*sizeof(float));
+	float* Rho = (float*)malloc(m*m*k*sizeof(float));
+	float* Pi = (float*)malloc(k*sizeof(float));
+	float* gam2 = (float*)malloc(k*sizeof(float));
+	float* pi2 = (float*)malloc(k*sizeof(float));
+	float* Gram2 = (float*)malloc(p*p*k*sizeof(float));
+	float* ps = (float*)malloc(m*k*sizeof(float));
+	float* nY2 = (float*)malloc(m*k*sizeof(float));
+	float* ps1 = (float*)malloc(n*m*k*sizeof(float));
+	float* ps2 = (float*)malloc(p*m*k*sizeof(float));
+	float* nY21 = (float*)malloc(n*m*k*sizeof(float));
+	float* Gam = (float*)malloc(n*k*sizeof(float));
+	float* X2 = (float*)malloc(n*p*k*sizeof(float));
+	float* Y2 = (float*)malloc(n*m*k*sizeof(float));
 	gsl_matrix* matrix = gsl_matrix_alloc(m, m);
 	gsl_permutation* permutation = gsl_permutation_alloc(m);
-	double* YiRhoR = (double*)malloc(m*sizeof(double));
-	double* XiPhiR = (double*)malloc(m*sizeof(double));
-	double dist = 0.;
-	double dist2 = 0.;
+	float* YiRhoR = (float*)malloc(m*sizeof(float));
+	float* XiPhiR = (float*)malloc(m*sizeof(float));
+	float dist = 0.;
+	float dist2 = 0.;
 	int ite = 0;
-	double EPS = 1e-15;
-	double* dotProducts = (double*)malloc(k*sizeof(double));
+	float EPS = 1e-15;
+	float* dotProducts = (float*)malloc(k*sizeof(float));
 
 	while (ite < mini || (ite < maxi && (dist >= tau || dist2 >= sqrt(tau))))
 	{
@@ -90,7 +90,7 @@ void EMGLLF_core(
 				//ps2(:,mm,r)=transpose(X2(:,:,r))*Y2(:,mm,r);
 				for (int u=0; u<p; u++)
 				{
-					double dotProduct = 0.;
+					float dotProduct = 0.;
 					for (int v=0; v<n; v++)
 						dotProduct += X2[ai(v,u,r,n,m,k)] * Y2[ai(v,mm,r,n,m,k)];
 					ps2[ai(u,mm,r,n,m,k)] = dotProduct;
@@ -101,7 +101,7 @@ void EMGLLF_core(
 				for (int s=0; s<p; s++)
 				{
 					//Gram2(j,s,r)=transpose(X2(:,j,r))*(X2(:,s,r));
-					double dotProduct = 0.;
+					float dotProduct = 0.;
 					for (int u=0; u<n; u++)
 						dotProduct += X2[ai(u,j,r,n,p,k)] * X2[ai(u,s,r,n,p,k)];
 					Gram2[ai(j,s,r,p,p,k)] = dotProduct;
@@ -117,7 +117,7 @@ void EMGLLF_core(
 		for (int r=0; r<k; r++)
 		{
 			//b(r) = sum(sum(abs(phi(:,:,r))));
-			double sumAbsPhi = 0.;
+			float sumAbsPhi = 0.;
 			for (int u=0; u<p; u++)
 				for (int v=0; v<m; v++)
 					sumAbsPhi += fabs(phi[ai(u,v,r,p,m,k)]);
@@ -126,16 +126,16 @@ void EMGLLF_core(
 		//gam2 = sum(gam,1);
 		for (int u=0; u<k; u++)
 		{
-			double sumOnColumn = 0.;
+			float sumOnColumn = 0.;
 			for (int v=0; v<n; v++)
 				sumOnColumn += gam[mi(v,u,n,k)];
 			gam2[u] = sumOnColumn;
 		}
 		//a=sum(gam*transpose(log(pi)));
-		double a = 0.;
+		float a = 0.;
 		for (int u=0; u<n; u++)
 		{
-			double dotProduct = 0.;
+			float dotProduct = 0.;
 			for (int v=0; v<k; v++)
 				dotProduct += gam[mi(u,v,n,k)] * log(pi[v]);
 			a += dotProduct;
@@ -144,7 +144,7 @@ void EMGLLF_core(
 		//tant que les proportions sont negatives
 		int kk = 0;
 		int pi2AllPositive = 0;
-		double invN = 1./n;
+		float invN = 1./n;
 		while (!pi2AllPositive)
 		{
 			//pi2(:)=pi(:)+0.1^kk*(1/n*gam2(:)-pi(:));
@@ -164,15 +164,15 @@ void EMGLLF_core(
 
 		//t(m) la plus grande valeur dans la grille O.1^k tel que ce soit décroissante ou constante
 		//(pi.^gamma)*b
-		double piPowGammaDotB = 0.;
+		float piPowGammaDotB = 0.;
 		for (int v=0; v<k; v++)
 			piPowGammaDotB += pow(pi[v],gamma) * b[v];
 		//(pi2.^gamma)*b
-		double pi2PowGammaDotB = 0.;
+		float pi2PowGammaDotB = 0.;
 		for (int v=0; v<k; v++)
 			pi2PowGammaDotB += pow(pi2[v],gamma) * b[v];
 		//transpose(gam2)*log(pi2)
-		double prodGam2logPi2 = 0.;
+		float prodGam2logPi2 = 0.;
 		for (int v=0; v<k; v++)
 			prodGam2logPi2 += gam2[v] * log(pi2[v]);
 		while (-invN*a + lambda*piPowGammaDotB < -invN*prodGam2logPi2 + lambda*pi2PowGammaDotB
@@ -190,9 +190,9 @@ void EMGLLF_core(
 				prodGam2logPi2 += gam2[v] * log(pi2[v]);
 			kk++;
 		}
-		double t = pow(0.1,kk);
+		float t = pow(0.1,kk);
 		//sum(pi+t*(pi2-pi))
-		double sumPiPlusTbyDiff = 0.;
+		float sumPiPlusTbyDiff = 0.;
 		for (int v=0; v<k; v++)
 			sumPiPlusTbyDiff += (pi[v] + t*(pi2[v] - pi[v]));
 		//pi=(pi+t*(pi2-pi))/sum(pi+t*(pi2-pi));
@@ -207,7 +207,7 @@ void EMGLLF_core(
 				for (int i=0; i<n; i++)
 				{
 					//< X2(i,:,r) , phi(:,mm,r) >
-					double dotProduct = 0.0;
+					float dotProduct = 0.0;
 					for (int u=0; u<p; u++)
 						dotProduct += X2[ai(i,u,r,n,p,k)] * phi[ai(u,mm,r,n,m,k)];
 					//ps1(i,mm,r)=Y2(i,mm,r)*dot(X2(i,:,r),phi(:,mm,r));
@@ -215,12 +215,12 @@ void EMGLLF_core(
 					nY21[ai(i,mm,r,n,m,k)] = Y2[ai(i,mm,r,n,m,k)] * Y2[ai(i,mm,r,n,m,k)];
 				}
 				//ps(mm,r)=sum(ps1(:,mm,r));
-				double sumPs1 = 0.0;
+				float sumPs1 = 0.0;
 				for (int u=0; u<n; u++)
 					sumPs1 += ps1[ai(u,mm,r,n,m,k)];
 				ps[mi(mm,r,m,k)] = sumPs1;
 				//nY2(mm,r)=sum(nY21(:,mm,r));
-				double sumNy21 = 0.0;
+				float sumNy21 = 0.0;
 				for (int u=0; u<n; u++)
 					sumNy21 += nY21[ai(u,mm,r,n,m,k)];
 				nY2[mi(mm,r,m,k)] = sumNy21;
@@ -237,7 +237,7 @@ void EMGLLF_core(
 				{
 					//sum(phi(1:j-1,mm,r).*transpose(Gram2(j,1:j-1,r)))+sum(phi(j+1:p,mm,r)
 					// .*transpose(Gram2(j,j+1:p,r)))
-					double dotPhiGram2 = 0.0;
+					float dotPhiGram2 = 0.0;
 					for (int u=0; u<j; u++)
 						dotPhiGram2 += phi[ai(u,mm,r,p,m,k)] * Gram2[ai(j,u,r,p,p,k)];
 					for (int u=j+1; u<p; u++)
@@ -262,12 +262,12 @@ void EMGLLF_core(
 		/////////////
 
 		int signum;
-		double sumLogLLF2 = 0.0;
+		float sumLogLLF2 = 0.0;
 		for (int i=0; i<n; i++)
 		{
-			double sumLLF1 = 0.0;
-			double sumGamI = 0.0;
-			double minDotProduct = INFINITY;
+			float sumLLF1 = 0.0;
+			float sumGamI = 0.0;
+			float minDotProduct = INFINITY;
 
 			for (int r=0; r<k; r++)
 			{
@@ -300,7 +300,7 @@ void EMGLLF_core(
 				if (dotProducts[r] < minDotProduct)
 					minDotProduct = dotProducts[r];
 			}
-			double shift = 0.5*minDotProduct;
+			float shift = 0.5*minDotProduct;
 			for (int r=0; r<k; r++)
 			{
 				//compute det(rho(:,:,r)) [TODO: avoid re-computations]
@@ -310,7 +310,7 @@ void EMGLLF_core(
 						matrix->data[u*m+v] = rho[ai(u,v,r,m,m,k)];
 				}
 				gsl_linalg_LU_decomp(matrix, permutation, &signum);
-				double detRhoR = gsl_linalg_LU_det(matrix, signum);
+				float detRhoR = gsl_linalg_LU_det(matrix, signum);
 
 				Gam[mi(i,r,n,k)] = pi[r] * detRhoR * exp(-0.5*dotProducts[r] + shift);
 				sumLLF1 += Gam[mi(i,r,n,k)] / pow(2*M_PI,m/2.0);
@@ -327,7 +327,7 @@ void EMGLLF_core(
 		}
 		
 		//sum(pen(ite,:))
-		double sumPen = 0.0;
+		float sumPen = 0.0;
 		for (int r=0; r<k; r++)
 			sumPen += pow(pi[r],gamma) * b[r];
 		//LLF(ite)=-1/n*sum(log(LLF2(ite,:)))+lambda*sum(pen(ite,:));
@@ -338,14 +338,14 @@ void EMGLLF_core(
 			dist = (LLF[ite] - LLF[ite-1]) / (1.0 + fabs(LLF[ite]));
 		
 		//Dist1=max(max((abs(phi-Phi))./(1+abs(phi))));
-		double Dist1 = 0.0;
+		float Dist1 = 0.0;
 		for (int u=0; u<p; u++)
 		{
 			for (int v=0; v<m; v++)
 			{
 				for (int w=0; w<k; w++)
 				{
-					double tmpDist = fabs(phi[ai(u,v,w,p,m,k)]-Phi[ai(u,v,w,p,m,k)]) 
+					float tmpDist = fabs(phi[ai(u,v,w,p,m,k)]-Phi[ai(u,v,w,p,m,k)]) 
 						/ (1.0+fabs(phi[ai(u,v,w,p,m,k)]));
 					if (tmpDist > Dist1)
 						Dist1 = tmpDist;
@@ -353,14 +353,14 @@ void EMGLLF_core(
 			}
 		}
 		//Dist2=max(max((abs(rho-Rho))./(1+abs(rho))));
-		double Dist2 = 0.0;
+		float Dist2 = 0.0;
 		for (int u=0; u<m; u++)
 		{
 			for (int v=0; v<m; v++)
 			{
 				for (int w=0; w<k; w++)
 				{
-					double tmpDist = fabs(rho[ai(u,v,w,m,m,k)]-Rho[ai(u,v,w,m,m,k)]) 
+					float tmpDist = fabs(rho[ai(u,v,w,m,m,k)]-Rho[ai(u,v,w,m,m,k)]) 
 						/ (1.0+fabs(rho[ai(u,v,w,m,m,k)]));
 					if (tmpDist > Dist2)
 						Dist2 = tmpDist;
@@ -368,12 +368,12 @@ void EMGLLF_core(
 			}
 		}
 		//Dist3=max(max((abs(pi-Pi))./(1+abs(Pi))));
-		double Dist3 = 0.0;
+		float Dist3 = 0.0;
 		for (int u=0; u<n; u++)
 		{
 			for (int v=0; v<k; v++)
 			{
-				double tmpDist = fabs(pi[v]-Pi[v]) / (1.0+fabs(pi[v]));
+				float tmpDist = fabs(pi[v]-Pi[v]) / (1.0+fabs(pi[v]));
 				if (tmpDist > Dist3)
 					Dist3 = tmpDist;
 			}
diff --git a/src/sources/EMGLLF.h b/src/sources/EMGLLF.h
index d09d27c..005c05b 100644
--- a/src/sources/EMGLLF.h
+++ b/src/sources/EMGLLF.h
@@ -3,23 +3,23 @@
 
 void EMGLLF_core(
 	// IN parameters
-	const double* phiInit,
-	const double* rhoInit,
-	const double* piInit,
-	const double* gamInit,
+	const float* phiInit,
+	const float* rhoInit,
+	const float* piInit,
+	const float* gamInit,
 	int mini,
 	int maxi,
-	double gamma,
-	double lambda,
-	const double* X,
-	const double* Y,
-	double tau,
+	float gamma,
+	float lambda,
+	const float* X,
+	const float* Y,
+	float tau,
 	// OUT parameters
-	double* phi,
-	double* rho,
-	double* pi,
-	double* LLF,
-	double* S,
+	float* phi,
+	float* rho,
+	float* pi,
+	float* LLF,
+	float* S,
 	// additional size parameters
 	int n,
 	int p,
diff --git a/src/sources/EMGrank.c b/src/sources/EMGrank.c
index 0791892..3d5a9c7 100644
--- a/src/sources/EMGrank.c
+++ b/src/sources/EMGrank.c
@@ -3,13 +3,13 @@
 #include "utils.h"
 
 // Compute pseudo-inverse of a square matrix
-static double* pinv(const double* matrix, int dim)
+static float* pinv(const float* matrix, int dim)
 {
 	gsl_matrix* U = gsl_matrix_alloc(dim,dim);
 	gsl_matrix* V = gsl_matrix_alloc(dim,dim);
 	gsl_vector* S = gsl_vector_alloc(dim);
 	gsl_vector* work = gsl_vector_alloc(dim);
-	double EPS = 1e-10; //threshold for singular value "== 0"
+	float EPS = 1e-10; //threshold for singular value "== 0"
 	
 	//copy matrix into U
 	copyArray(matrix, U->data, dim*dim);
@@ -19,12 +19,12 @@ static double* pinv(const double* matrix, int dim)
 	gsl_vector_free(work);
 
 	// Obtain pseudo-inverse by V*S^{-1}*t(U)
-	double* inverse = (double*)malloc(dim*dim*sizeof(double));
+	float* inverse = (float*)malloc(dim*dim*sizeof(float));
 	for (int i=0; i<dim; i++)
 	{
 		for (int ii=0; ii<dim; ii++)
 		{
-			double dotProduct = 0.0;
+			float dotProduct = 0.0;
 			for (int j=0; j<dim; j++)
 				dotProduct += V->data[i*dim+j] * (S->data[j] > EPS ? 1.0/S->data[j] : 0.0) * U->data[ii*dim+j];
 			inverse[i*dim+ii] = dotProduct;
@@ -40,17 +40,17 @@ static double* pinv(const double* matrix, int dim)
 // TODO: comment EMGrank purpose
 void EMGrank_core(
 	// IN parameters
-	const double* Pi, // parametre de proportion
-	const double* Rho, // parametre initial de variance renormalisé
+	const float* Pi, // parametre de proportion
+	const float* Rho, // parametre initial de variance renormalisé
 	int mini, // nombre minimal d'itérations dans l'algorithme EM
 	int maxi, // nombre maximal d'itérations dans l'algorithme EM
-	const double* X, // régresseurs
-	const double* Y, // réponse
-	double tau, // seuil pour accepter la convergence
+	const float* X, // régresseurs
+	const float* Y, // réponse
+	float tau, // seuil pour accepter la convergence
 	const int* rank, // vecteur des rangs possibles
 	// OUT parameters
-	double* phi, // parametre de moyenne renormalisé, calculé par l'EM
-	double* LLF, // log vraisemblance associé à cet échantillon, pour les valeurs estimées des paramètres
+	float* phi, // parametre de moyenne renormalisé, calculé par l'EM
+	float* LLF, // log vraisemblance associé à cet échantillon, pour les valeurs estimées des paramètres
 	// additional size parameters
 	int n, // taille de l'echantillon
 	int p, // nombre de covariables
@@ -58,20 +58,20 @@ void EMGrank_core(
 	int k) // nombre de composantes
 {
 	// Allocations, initializations
-	double* Phi = (double*)calloc(p*m*k,sizeof(double));
-	double* hatBetaR = (double*)malloc(p*m*sizeof(double));
+	float* Phi = (float*)calloc(p*m*k,sizeof(float));
+	float* hatBetaR = (float*)malloc(p*m*sizeof(float));
 	int signum;
-	double invN = 1.0/n;
+	float invN = 1.0/n;
 	int deltaPhiBufferSize = 20;
-	double* deltaPhi = (double*)malloc(deltaPhiBufferSize*sizeof(double));
+	float* deltaPhi = (float*)malloc(deltaPhiBufferSize*sizeof(float));
 	int ite = 0;
-	double sumDeltaPhi = 0.0;
-	double* YiRhoR = (double*)malloc(m*sizeof(double));
-	double* XiPhiR = (double*)malloc(m*sizeof(double));
-	double* Xr = (double*)malloc(n*p*sizeof(double));
-	double* Yr = (double*)malloc(n*m*sizeof(double));
-	double* tXrXr = (double*)malloc(p*p*sizeof(double));
-	double* tXrYr = (double*)malloc(p*m*sizeof(double));
+	float sumDeltaPhi = 0.0;
+	float* YiRhoR = (float*)malloc(m*sizeof(float));
+	float* XiPhiR = (float*)malloc(m*sizeof(float));
+	float* Xr = (float*)malloc(n*p*sizeof(float));
+	float* Yr = (float*)malloc(n*m*sizeof(float));
+	float* tXrXr = (float*)malloc(p*p*sizeof(float));
+	float* tXrYr = (float*)malloc(p*m*sizeof(float));
 	gsl_matrix* matrixM = gsl_matrix_alloc(p, m);
 	gsl_matrix* matrixE = gsl_matrix_alloc(m, m);
 	gsl_permutation* permutation = gsl_permutation_alloc(m);
@@ -115,7 +115,7 @@ void EMGrank_core(
 			{
 				for (int jj=0; jj<p; jj++)
 				{
-					double dotProduct = 0.0;
+					float dotProduct = 0.0;
 					for (int u=0; u<cardClustR; u++)
 						dotProduct += Xr[mi(u,j,n,p)] * Xr[mi(u,jj,n,p)];
 					tXrXr[mi(j,jj,p,p)] = dotProduct;
@@ -123,14 +123,14 @@ void EMGrank_core(
 			}
 
 			//Get pseudo inverse = (t(Xr)*Xr)^{-1}
-			double* invTXrXr = pinv(tXrXr, p);
+			float* invTXrXr = pinv(tXrXr, p);
 			
 			// Compute tXrYr = t(Xr) * Yr
 			for (int j=0; j<p; j++)
 			{
 				for (int jj=0; jj<m; jj++)
 				{
-					double dotProduct = 0.0;
+					float dotProduct = 0.0;
 					for (int u=0; u<cardClustR; u++)
 						dotProduct += Xr[mi(u,j,n,p)] * Yr[mi(u,j,n,m)];
 					tXrYr[mi(j,jj,p,m)] = dotProduct;
@@ -142,7 +142,7 @@ void EMGrank_core(
 			{
 				for (int jj=0; jj<m; jj++)
 				{
-					double dotProduct = 0.0;
+					float dotProduct = 0.0;
 					for (int u=0; u<p; u++)
 						dotProduct += invTXrXr[mi(j,u,p,p)] * tXrYr[mi(u,jj,p,m)];
 					matrixM->data[j*m+jj] = dotProduct;
@@ -164,7 +164,7 @@ void EMGrank_core(
 			{
 				for (int jj=0; jj<m; jj++)
 				{
-					double dotProduct = 0.0;
+					float dotProduct = 0.0;
 					for (int u=0; u<m; u++)
 						dotProduct += U[j*m+u] * S->data[u] * V->data[jj*m+u];
 					hatBetaR[mi(j,jj,p,m)] = dotProduct;
@@ -176,7 +176,7 @@ void EMGrank_core(
 			{
 				for (int jj=0; jj<m; jj++)
 				{
-					double dotProduct=0.0;
+					float dotProduct=0.0;
 					for (int u=0; u<m; u++)
 						dotProduct += hatBetaR[mi(j,u,p,m)] * Rho[ai(u,jj,r,m,m,k)];
 					phi[ai(j,jj,r,p,m,k)] = dotProduct;
@@ -188,11 +188,11 @@ void EMGrank_core(
 		// Etape E //
 		/////////////
 		
-		double sumLogLLF2 = 0.0;
+		float sumLogLLF2 = 0.0;
 		for (int i=0; i<n; i++)
 		{
-			double sumLLF1 = 0.0;
-			double maxLogGamIR = -INFINITY;
+			float sumLLF1 = 0.0;
+			float maxLogGamIR = -INFINITY;
 			for (int r=0; r<k; r++)
 			{
 				//Compute
@@ -207,7 +207,7 @@ void EMGrank_core(
 						matrixE->data[j*m+jj] = Rho[ai(j,jj,r,m,m,k)];
 				}
 				gsl_linalg_LU_decomp(matrixE, permutation, &signum);
-				double detRhoR = gsl_linalg_LU_det(matrixE, signum);
+				float detRhoR = gsl_linalg_LU_det(matrixE, signum);
 
 				//compute Y(i,:)*Rho(:,:,r)
 				for (int j=0; j<m; j++)
@@ -226,10 +226,10 @@ void EMGrank_core(
 				}
 
 				//compute dotProduct < Y(:,i)*rho(:,:,r)-X(i,:)*phi(:,:,r) . Y(:,i)*rho(:,:,r)-X(i,:)*phi(:,:,r) >
-				double dotProduct = 0.0;
+				float dotProduct = 0.0;
 				for (int u=0; u<m; u++)
 					dotProduct += (YiRhoR[u]-XiPhiR[u]) * (YiRhoR[u]-XiPhiR[u]);
-				double logGamIR = log(Pi[r]) + log(detRhoR) - 0.5*dotProduct;
+				float logGamIR = log(Pi[r]) + log(detRhoR) - 0.5*dotProduct;
 
 				//Z(i) = index of max (gam(i,:))
 				if (logGamIR > maxLogGamIR)
@@ -247,14 +247,14 @@ void EMGrank_core(
 		*LLF = -invN * sumLogLLF2;
 
 		//newDeltaPhi = max(max((abs(phi-Phi))./(1+abs(phi))));
-		double newDeltaPhi = 0.0;
+		float newDeltaPhi = 0.0;
 		for (int j=0; j<p; j++)
 		{
 			for (int jj=0; jj<m; jj++)
 			{
 				for (int r=0; r<k; r++)
 				{
-					double tmpDist = fabs(phi[ai(j,jj,r,p,m,k)]-Phi[ai(j,jj,r,p,m,k)])
+					float tmpDist = fabs(phi[ai(j,jj,r,p,m,k)]-Phi[ai(j,jj,r,p,m,k)])
 						/ (1.0+fabs(phi[ai(j,jj,r,p,m,k)]));
 					if (tmpDist > newDeltaPhi)
 						newDeltaPhi = tmpDist;
diff --git a/src/sources/EMGrank.h b/src/sources/EMGrank.h
index 8123e68..92c3f73 100644
--- a/src/sources/EMGrank.h
+++ b/src/sources/EMGrank.h
@@ -3,17 +3,17 @@
 
 void EMGrank_core(
 	// IN parameters
-	const double* Pi,
-	const double* Rho,
+	const float* Pi,
+	const float* Rho,
 	int mini,
 	int maxi,
-	const double* X,
-	const double* Y,
-	double tau,
+	const float* X,
+	const float* Y,
+	float tau,
 	const int* rank,
 	// OUT parameters
-	double* phi,
-	double* LLF,
+	float* phi,
+	float* LLF,
 	// additional size parameters
 	int n,
 	int p,
diff --git a/src/sources/constructionModelesLassoMLE.c b/src/sources/constructionModelesLassoMLE.c
index 4ab62ad..a48f7d0 100644
--- a/src/sources/constructionModelesLassoMLE.c
+++ b/src/sources/constructionModelesLassoMLE.c
@@ -7,25 +7,25 @@
 // TODO: comment on constructionModelesLassoMLE purpose
 void constructionModelesLassoMLE_core(
 	// IN parameters
-	const double* phiInit, // parametre initial de moyenne renormalisé
-	const double* rhoInit, // parametre initial de variance renormalisé
-	const double* piInit,// parametre initial des proportions
-	const double* gamInit, // paramètre initial des probabilités a posteriori de chaque échantillon
+	const float* phiInit, // parametre initial de moyenne renormalisé
+	const float* rhoInit, // parametre initial de variance renormalisé
+	const float* piInit,// parametre initial des proportions
+	const float* gamInit, // paramètre initial des probabilités a posteriori de chaque échantillon
 	int mini,// nombre minimal d'itérations dans l'algorithme EM
 	int maxi,// nombre maximal d'itérations dans l'algorithme EM
-	double gamma,// valeur de gamma : puissance des proportions dans la pénalisation pour un Lasso adaptatif
-	const double* glambda, // valeur des paramètres de régularisation du Lasso
-	const double* X, // régresseurs
-	const double* Y, // réponse
-	double seuil,// seuil pour prendre en compte une variable
-	double tau,// seuil pour accepter la convergence
+	float gamma,// valeur de gamma : puissance des proportions dans la pénalisation pour un Lasso adaptatif
+	const float* glambda, // valeur des paramètres de régularisation du Lasso
+	const float* X, // régresseurs
+	const float* Y, // réponse
+	float seuil,// seuil pour prendre en compte une variable
+	float tau,// seuil pour accepter la convergence
 	const int* A1, // matrice des coefficients des parametres selectionnes
 	const int* A2, // matrice des coefficients des parametres non selectionnes
 	// OUT parameters
-	double* phi,// estimateur ainsi calculé par le Lasso
-	double* rho,// estimateur ainsi calculé par le Lasso
-	double* pi, // estimateur ainsi calculé par le Lasso
-	double* lvraisemblance, // estimateur ainsi calculé par le Lasso
+	float* phi,// estimateur ainsi calculé par le Lasso
+	float* rho,// estimateur ainsi calculé par le Lasso
+	float* pi, // estimateur ainsi calculé par le Lasso
+	float* lvraisemblance, // estimateur ainsi calculé par le Lasso
 	// additional size parameters
 	int n, // taille de l'echantillon
 	int p, // nombre de covariables
@@ -58,7 +58,7 @@ void constructionModelesLassoMLE_core(
 			continue;
 
 		//Xa = X(:,a)
-		double* Xa = (double*)malloc(n*lengthA*sizeof(double));
+		float* Xa = (float*)malloc(n*lengthA*sizeof(float));
 		for (int i=0; i<n; i++)
 		{
 			for (int j=0; j<lengthA; j++)
@@ -66,7 +66,7 @@ void constructionModelesLassoMLE_core(
 		}
 
 		//phia = phiInit(a,:,:)
-		double* phia = (double*)malloc(lengthA*m*k*sizeof(double));
+		float* phia = (float*)malloc(lengthA*m*k*sizeof(float));
 		for (int j=0; j<lengthA; j++)
 		{
 			for (int mm=0; mm<m; mm++)
@@ -78,11 +78,11 @@ void constructionModelesLassoMLE_core(
 
 		//[phiLambda,rhoLambda,piLambda,~,~] = EMGLLF(...
 		//	phiInit(a,:,:),rhoInit,piInit,gamInit,mini,maxi,gamma,0,X(:,a),Y,tau);
-		double* phiLambda = (double*)malloc(lengthA*m*k*sizeof(double));
-		double* rhoLambda = (double*)malloc(m*m*k*sizeof(double));
-		double* piLambda = (double*)malloc(k*sizeof(double));
-		double* LLF = (double*)malloc((maxi+1)*sizeof(double));
-		double* S = (double*)malloc(lengthA*m*k*sizeof(double));
+		float* phiLambda = (float*)malloc(lengthA*m*k*sizeof(float));
+		float* rhoLambda = (float*)malloc(m*m*k*sizeof(float));
+		float* piLambda = (float*)malloc(k*sizeof(float));
+		float* LLF = (float*)malloc((maxi+1)*sizeof(float));
+		float* S = (float*)malloc(lengthA*m*k*sizeof(float));
 		EMGLLF_core(phia,rhoInit,piInit,gamInit,mini,maxi,gamma,0.0,Xa,Y,tau,
 			phiLambda,rhoLambda,piLambda,LLF,S,
 			n,lengthA,m,k);
@@ -154,12 +154,12 @@ void constructionModelesLassoMLE_core(
 		free(b);
 
 		int signum;
-		double* densite = (double*)calloc(L*n,sizeof(double));
-		double sumLogDensit = 0.0;
+		float* densite = (float*)calloc(L*n,sizeof(float));
+		float sumLogDensit = 0.0;
 		gsl_matrix* matrix = gsl_matrix_alloc(m, m);
 		gsl_permutation* permutation = gsl_permutation_alloc(m);
-		double* YiRhoR = (double*)malloc(m*sizeof(double));
-		double* XiPhiR = (double*)malloc(m*sizeof(double));
+		float* YiRhoR = (float*)malloc(m*sizeof(float));
+		float* XiPhiR = (float*)malloc(m*sizeof(float));
 		for (int i=0; i<n; i++)
 		{
 			//~ for r=1:k
@@ -176,7 +176,7 @@ void constructionModelesLassoMLE_core(
 						matrix->data[u*m+v] = rho[ai4(u,v,r,lambdaIndex,m,m,k,L)];
 				}
 				gsl_linalg_LU_decomp(matrix, permutation, &signum);
-				double detRhoR = gsl_linalg_LU_det(matrix, signum);
+				float detRhoR = gsl_linalg_LU_det(matrix, signum);
 
 				//compute Y(i,:)*rho(:,:,r,lambdaIndex)
 				for (int u=0; u<m; u++)
@@ -196,7 +196,7 @@ void constructionModelesLassoMLE_core(
 				// On peut remplacer X par Xa dans ce dernier calcul, mais je ne sais pas si c'est intéressant ...
 
 				// compute dotProduct < delta . delta >
-				double dotProduct = 0.0;
+				float dotProduct = 0.0;
 				for (int u=0; u<m; u++)
 					dotProduct += (YiRhoR[u]-XiPhiR[u]) * (YiRhoR[u]-XiPhiR[u]);
 
diff --git a/src/sources/constructionModelesLassoMLE.h b/src/sources/constructionModelesLassoMLE.h
index 6a20dc7..2058e48 100644
--- a/src/sources/constructionModelesLassoMLE.h
+++ b/src/sources/constructionModelesLassoMLE.h
@@ -3,25 +3,25 @@
 
 void constructionModelesLassoMLE_core(
 	// IN parameters
-	const double* phiInit,
-	const double* rhoInit,
-	const double* piInit,
-	const double* gamInit,
+	const float* phiInit,
+	const float* rhoInit,
+	const float* piInit,
+	const float* gamInit,
 	int mini,
 	int maxi,
-	double gamma,
-	const double* glambda,
-	const double* X,
-	const double* Y,
-	double seuil,
-	double tau,
+	float gamma,
+	const float* glambda,
+	const float* X,
+	const float* Y,
+	float seuil,
+	float tau,
 	const int* A1,
 	const int* A2,
 	// OUT parameters
-	double* phi,
-	double* rho,
-	double* pi,
-	double* lvraisemblance,
+	float* phi,
+	float* rho,
+	float* pi,
+	float* lvraisemblance,
 	// additional size parameters
 	int n,
 	int p,
diff --git a/src/sources/constructionModelesLassoRank.c b/src/sources/constructionModelesLassoRank.c
index e7712a9..031e76c 100644
--- a/src/sources/constructionModelesLassoRank.c
+++ b/src/sources/constructionModelesLassoRank.c
@@ -7,19 +7,19 @@
 // TODO: comment on constructionModelesLassoRank purpose
 void constructionModelesLassoRank_core(
 	// IN parameters
-	const double* Pi,// parametre initial des proportions
-	const double* Rho, // parametre initial de variance renormalisé
+	const float* Pi,// parametre initial des proportions
+	const float* Rho, // parametre initial de variance renormalisé
 	int mini, // nombre minimal d'itérations dans l'algorithme EM
 	int maxi, // nombre maximal d'itérations dans l'algorithme EM
-	const double* X,// régresseurs
-	const double* Y,// réponse
-	double tau, // seuil pour accepter la convergence
+	const float* X,// régresseurs
+	const float* Y,// réponse
+	float tau, // seuil pour accepter la convergence
 	const int* A1, // matrice des coefficients des parametres selectionnes
 	int rangmin,	//rang minimum autorisé
 	int rangmax,	//rang maximum autorisé
 	// OUT parameters (all pointers, to be modified)
-	double* phi,// estimateur ainsi calculé par le Lasso
-	double* lvraisemblance,// estimateur ainsi calculé par le Lasso
+	float* phi,// estimateur ainsi calculé par le Lasso
+	float* lvraisemblance,// estimateur ainsi calculé par le Lasso
 	// additional size parameters
 	int n,// taille de l'echantillon
 	int p,// nombre de covariables
@@ -73,24 +73,24 @@ for (int r=0; r<k; r++)
 			continue;
 
 		//from now on, longueurActive > 0
-		double* phiLambda = (double*)malloc(longueurActive*m*k*sizeof(double));
-		double LLF;
+		float* phiLambda = (float*)malloc(longueurActive*m*k*sizeof(float));
+		float LLF;
 		for (int j=0; j<Size; j++)
 		{
 			//[phiLambda,LLF] = EMGrank(Pi(:,lambdaIndex),Rho(:,:,:,lambdaIndex),mini,maxi,X(:,active),Y,tau,Rank(j,:));
 			int* rank = (int*)malloc(k*sizeof(int));
 			for (int r=0; r<k; r++)
 				rank[r] = Rank[mi(j,r,Size,k)];
-			double* Xactive = (double*)malloc(n*longueurActive*sizeof(double));
+			float* Xactive = (float*)malloc(n*longueurActive*sizeof(float));
 			for (int i=0; i<n; i++)
 			{
 				for (int jj=0; jj<longueurActive; jj++)
 					Xactive[mi(i,jj,n,longueurActive)] = X[mi(i,active[jj],n,p)];
 			}
-			double* PiLambda = (double*)malloc(k*sizeof(double));
+			float* PiLambda = (float*)malloc(k*sizeof(float));
 			for (int r=0; r<k; r++)
 				PiLambda[r] = Pi[mi(r,lambdaIndex,k,L)];
-			double* RhoLambda = (double*)malloc(m*m*k*sizeof(double));
+			float* RhoLambda = (float*)malloc(m*m*k*sizeof(float));
 			for (int u=0; u<m; u++)
 			{
 				for (int v=0; v<m; v++)
@@ -109,7 +109,7 @@ for (int r=0; r<k; r++)
 			//lvraisemblance((lambdaIndex-1)*Size+j,:) = [LLF, dot(Rank(j,:), length(active)-Rank(j,:)+m)];
 			lvraisemblance[mi(lambdaIndex*Size+j,0,L*Size,2)] = LLF;
 			//dot(Rank(j,:), length(active)-Rank(j,:)+m)
-			double dotProduct = 0.0;
+			float dotProduct = 0.0;
 			for (int r=0; r<k; r++)
 				dotProduct += Rank[mi(j,r,Size,k)] * (longueurActive-Rank[mi(j,r,Size,k)]+m);
 			lvraisemblance[mi(lambdaIndex*Size+j,1,Size*L,2)] = dotProduct;
diff --git a/src/sources/constructionModelesLassoRank.h b/src/sources/constructionModelesLassoRank.h
index 56951d7..60f6623 100644
--- a/src/sources/constructionModelesLassoRank.h
+++ b/src/sources/constructionModelesLassoRank.h
@@ -4,19 +4,19 @@
 // Main job on raw inputs (after transformation from mxArray)
 void constructionModelesLassoRank_core(
 	// IN parameters
-	const double* Pi,
-	const double* Rho,
+	const float* Pi,
+	const float* Rho,
 	int mini,
 	int maxi,
-	const double* X,
-	const double* Y,
-	double tau,
+	const float* X,
+	const float* Y,
+	float tau,
 	const int* A1,
 	int rangmin,
 	int rangmax,
 	// OUT parameters
-	double* phi,
-	double* lvraisemblance,
+	float* phi,
+	float* lvraisemblance,
 	// additional size parameters
 	int n,
 	int p,
diff --git a/src/sources/selectiontotale.c b/src/sources/selectiontotale.c
index 04ec0a4..3b2e015 100644
--- a/src/sources/selectiontotale.c
+++ b/src/sources/selectiontotale.c
@@ -7,23 +7,23 @@
 // Main job on raw inputs (after transformation from mxArray)
 void selectiontotale_core(
 	// IN parameters
-	const double* phiInit, // parametre initial de moyenne renormalisé
-	const double* rhoInit, // parametre initial de variance renormalisé
-	const double* piInit,// parametre initial des proportions
-	const double* gamInit, // paramètre initial des probabilités a posteriori de chaque échantillon
+	const float* phiInit, // parametre initial de moyenne renormalisé
+	const float* rhoInit, // parametre initial de variance renormalisé
+	const float* piInit,// parametre initial des proportions
+	const float* gamInit, // paramètre initial des probabilités a posteriori de chaque échantillon
 	int mini, // nombre minimal d'itérations dans lambdaIndex'algorithme EM
 	int maxi, // nombre maximal d'itérations dans lambdaIndex'algorithme EM
-	double gamma, // valeur de gamma : puissance des proportions dans la pénalisation pour un Lasso adaptatif
-	const double* glambda, // valeur des paramètres de régularisation du Lasso
-	const double* X,// régresseurs
-	const double* Y,// réponse
-	double seuil, // seuil pour prendre en compte une variable
-	double tau, // seuil pour accepter la convergence
+	float gamma, // valeur de gamma : puissance des proportions dans la pénalisation pour un Lasso adaptatif
+	const float* glambda, // valeur des paramètres de régularisation du Lasso
+	const float* X,// régresseurs
+	const float* Y,// réponse
+	float seuil, // seuil pour prendre en compte une variable
+	float tau, // seuil pour accepter la convergence
 	// OUT parameters (all pointers, to be modified)
 	int* A1, // matrice des coefficients des parametres selectionnes
 	int* A2, // matrice des coefficients des parametres non selectionnes
-	double* Rho,// estimateur ainsi calculé par le Lasso
-	double* Pi,// estimateur ainsi calculé par le Lasso
+	float* Rho,// estimateur ainsi calculé par le Lasso
+	float* Pi,// estimateur ainsi calculé par le Lasso
 	// additional size parameters
 	int n,// taille de lambdaIndex'echantillon
 	int p,// nombre de covariables
@@ -51,11 +51,11 @@ void selectiontotale_core(
 	for (lambdaIndex=0; lambdaIndex<L; lambdaIndex++)
 	{
 		//allocate output variables
-		double* phi = (double*)malloc(p*m*k*sizeof(double));
-		double* rho = (double*)malloc(m*m*k*sizeof(double));
-		double* pi = (double*)malloc(k*sizeof(double));
-		double* LLF = (double*)malloc(maxi*sizeof(double));
-		double* S = (double*)malloc(p*m*k*sizeof(double));
+		float* phi = (float*)malloc(p*m*k*sizeof(float));
+		float* rho = (float*)malloc(m*m*k*sizeof(float));
+		float* pi = (float*)malloc(k*sizeof(float));
+		float* LLF = (float*)malloc(maxi*sizeof(float));
+		float* S = (float*)malloc(p*m*k*sizeof(float));
 		EMGLLF_core(phiInit,rhoInit,piInit,gamInit,mini,maxi,gamma,glambda[lambdaIndex],X,Y,tau,
 			phi,rho,pi,LLF,S,
 			n,p,m,k);
@@ -72,7 +72,7 @@ void selectiontotale_core(
 			int cpt2 = 0;
 			for (int jj=0; jj<m; jj++)
 			{
-				double maxPhi = 0.0;
+				float maxPhi = 0.0;
 				for (int r=0; r<k; r++)
 				{
 					if (fabs(phi[ai(j,jj,r,p,m,k)]) > maxPhi)
diff --git a/src/sources/selectiontotale.h b/src/sources/selectiontotale.h
index fa2ba84..d225592 100644
--- a/src/sources/selectiontotale.h
+++ b/src/sources/selectiontotale.h
@@ -4,23 +4,23 @@
 // Main job on raw inputs (after transformation from mxArray)
 void selectiontotale_core(
 	// IN parameters
-	const double* phiInit,
-	const double* rhoInit,
-	const double* piInit,
-	const double* gamInit,
+	const float* phiInit,
+	const float* rhoInit,
+	const float* piInit,
+	const float* gamInit,
 	int mini,
 	int maxi,
-	double gamma,
-	const double* glambda,
-	const double* X,
-	const double* Y,
-	double seuil,
-	double tau,
+	float gamma,
+	const float* glambda,
+	const float* X,
+	const float* Y,
+	float seuil,
+	float tau,
 	// OUT parameters
 	int* A1,
 	int* A2,
-	double* Rho,
-	double* Pi,
+	float* Rho,
+	float* Pi,
 	// additional size parameters
 	int n,
 	int p,
diff --git a/src/test/.Makefile.swp b/src/test/.Makefile.swp
deleted file mode 100644
index bfa54d3..0000000
Binary files a/src/test/.Makefile.swp and /dev/null differ
diff --git a/src/test/Makefile b/src/test/Makefile
index 796b424..459a5cb 100644
--- a/src/test/Makefile
+++ b/src/test/Makefile
@@ -1,8 +1,8 @@
 CC = gcc
 CFLAGS = -g -std=gnu99 -Wno-implicit-function-declaration
 LDFLAGS = -lm -lgsl -lcblas -lgomp
-LDFLAGS_TEST = -Lobj/ -lvalse_core
-LIB = valse_core.so
+TEST_LDFLAGS = -L. libvalse_core.so
+LIB = libvalse_core.so
 LIB_SRC = $(wildcard ../sources/*.c)
 LIB_OBJ = $(LIB_SRC:.c=.o)
 INCLUDES = -I../sources
@@ -12,23 +12,23 @@ all: $(LIB) test.EMGLLF test.EMGrank test.constructionModelesLassoMLE test.EMGra
 $(LIB): $(LIB_OBJ)
 	$(CC) -shared -o $@ $^ $(LDFLAGS)
 
-test.EMGLLF: test.EMGLLF.o
+test.EMGLLF: test.EMGLLF.o utils.o
 	$(CC) -o $@ $^ $(LDFLAGS) $(TEST_LDFLAGS)
 
-test.constructionModelesLassoMLE: test.constructionModelesLassoMLE.o
+test.constructionModelesLassoMLE: test.constructionModelesLassoMLE.o utils.o
 	$(CC) -o $@ $^ $(LDFLAGS) $(TEST_LDFLAGS)
 
-test.EMGrank: test.EMGrank.o
+test.EMGrank: test.EMGrank.o utils.o
 	$(CC) -o $@ $^ $(LDFLAGS) $(TEST_LDFLAGS)
 
-test.constructionModelesLassoRank: test.constructionModelesLassoRank.o
+test.constructionModelesLassoRank: test.constructionModelesLassoRank.o utils.o
 	$(CC) -o $@ $^ $(LDFLAGS) $(TEST_LDFLAGS)
 
-test.selectionTotale: test.selectionTotale.o
+test.selectionTotale: test.selectionTotale.o utils.o
 	$(CC) -o $@ $^ $(LDFLAGS) $(TEST_LDFLAGS)
 
 %.o: %.c
-	$(CC) -o $@ -c $< $(CFLAGS) $(INCLUDES)
+	$(CC) -fPIC -o $@ -c $< $(CFLAGS) $(INCLUDES)
 
 clean:
 	rm -f *.o ../sources/*.o
diff --git a/src/test/OLD_TEST_MATLAB/TODO b/src/test/OLD_TEST_MATLAB/TODO
index d4b05cf..73301dd 100644
--- a/src/test/OLD_TEST_MATLAB/TODO
+++ b/src/test/OLD_TEST_MATLAB/TODO
@@ -1,4 +1,3 @@
 1) transformer les .m en .R
-2) sauvegarder les résultats + entrée/sorties à partir du code R uniquement
-3) dans test.Truc.c, prendre en entrée les paramètres de data/ juste sauvegardés,
-   puis comparer les sorties aux sorties enregistrées
+2) sauvegarder les résultats + entrée/sorties à partir du code R uniquement,
+   dans le dossier src/test/data (** sous forme de vecteurs, sep=" " **)
diff --git a/src/test/test.EMGLLF.c b/src/test/test.EMGLLF.c
index e938b3a..1720641 100644
--- a/src/test/test.EMGLLF.c
+++ b/src/test/test.EMGLLF.c
@@ -68,8 +68,8 @@ int main(int argc, char** argv)
 	free(pi);
 	free(ref_pi);
 
-	float* ref_LLF = readArray_real("LLF", maxi);
-	compareArray_real("LLF", LLF, ref_LLF);
+	float* ref_LLF = readArray_real("LLF");
+	compareArray_real("LLF", LLF, ref_LLF, maxi);
 	free(LLF);
 	free(ref_LLF);
 
diff --git a/src/test/utils.c b/src/test/utils.c
index 8895cda..a6370b0 100644
--- a/src/test/utils.c
+++ b/src/test/utils.c
@@ -1,3 +1,8 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+#include <string.h>
+
 // Check if array == refArray
 void compareArray(const char* ID, const void* array, const void* refArray, int size,
 	int isinteger)
@@ -44,7 +49,7 @@ void* readArray(const char* fileName, int isinteger)
 	strcat(command, " | wc -l");
 	FILE *countSpaces = popen(command, "r");
 	char* buffer = (char*)calloc(32, sizeof(char));
-	fgets(buffer, sizeof(buffer), command);
+	fgets(buffer, sizeof(buffer), countSpaces);
 	int n = atoi(buffer) + 1;
 	free(buffer);
 	pclose(countSpaces);
@@ -92,7 +97,7 @@ int* readArray_int(const char* fileName)
 
 float* readArray_real(const char* fileName)
 {
-	return (int*)readArray(fileName, 0);
+	return (float*)readArray(fileName, 0);
 }
 
 int read_int(const char* fileName)