double[][]     matrix;

   final String         docPath; // a initialiser par le constructeur 

    public void calculate() {
        for(int kCol = 0, n = matrix.length; kCol < n; kCol++) {
            double colSum = 0;
            for(int kLine = 0, k = matrix.length; kLine < k; kLine++) {
            	colSum += matrix[kLine][kCol];
            }
            if(colSum > 0) {
            	for(int kLine = 0, k = matrix.length; kLine < k; kLine++) {
		    if(matrix[kLine][kCol] > 0) {
			matrix[kLine][kCol] = matrix[kLine][kCol] / colSum;
                    }
                }
            	
            } 
        }
    }

    public int[] getDangling() {
	
	int   n = getSize();
	int[] d = new int[n];
	boolean foundOne = false;
	
	for (int i=0; i < n; i++) {
	    for (int j=0; j < n; j++) {
		if (matrix[j][i] > 0 && j != i) {
		    foundOne = true;
		    break;
		} 
	    }
	    if (foundOne) {
		d[i] = 0;
	    } 
	    else {
		d[i] = 1;
	    }
	    foundOne = false;
	}
	return d;
    }

    private double[][] getDanglingNodeMatrix() {
	
	int n = getSize();
	
	double inv_n = (double)1/n;
	
	int[] dangling = getDangling();
	
	double[][] dNodes = new double[n][n];
	
	for (int i = 0; i < n; i++) {
	    for (int j = 0; j < n; j++) {
		
		if (dangling[i] == 0) {
		    dNodes[j][i] = 0;
		} else {
		    dNodes[j][i] = beta * inv_n;
		}
	    }
	}
	return dNodes;
    }


    public int getSize() {
    	return matrix.length;
    }


    private double norm(double[] a, double[] b) {
	
	double norm = 0;
	int n = a.length;
	for (int i=0; i < n; i++) {
	    norm += Math.abs(a[i]-b[i]);
	}
	return norm;
    }
    
    private double beta = 0.8;

    private double epsilon = 0.0001;
    
    double[] pR;
    
    public void findPageRank() throws Throwable {
	
	int k = 0; 
	
	double[][] H = matrix;
	
	int n = getSize();
	
	double inv_n = (double)1/n;
	
	
	double error = 1;
	
	// Les valeurs du vecteur PageRank
        pR = new double[n];
        
        // La copie du vecteur PageRank de l'iteration precedente
        // on en a besoin pour calculer l'erreur
        double[] tmpPR = new double[n];
	
        // Valeurs initiales
        for (int i=0; i < n; i++) {
	    pR[i] = inv_n;
        }
	
        double[][] dNodes= getDanglingNodeMatrix();
    	
    	double tNodes=(1 - beta) * inv_n; // teleportation 
	// contribution des noeuds pendants, i.e. aller aleatoirement a une
	// autre page,  qui n'est pas reliee depuis la page courante
	
    	// calcul matrice G 
    	for (int i=0; i < n; i++) {
	    
	    for (int j=0; j < n; j++) {
		if(dNodes[i][j] != 0) {
		    H[i][j] = beta*H[i][j] + dNodes[i][j] + tNodes;
		}
		else {
		    H[i][j] = tNodes;
		}
	    }
    	}
	
    	// Iterer jusqu'a convergence.
    	while (error >= epsilon) {
	    
            // Copie du vecteur PageRank avant sa mise a jour
	    for (int i=0; i < n; i++) {
            	tmpPR[i] = pR[i];
            }
	    
	    double dummy =0;

	    for (int kLine=0; kLine < n; kLine++) {
		
		dummy =0;
        	
		for (int kCol=0; kCol < n; kCol++) {
		    
		    dummy += H[kLine][kCol]*pR[kCol];
            	}
        	
		pR[kLine] = dummy;
	    }
	    
	    error = norm(pR,tmpPR);
	    
	    System.out.println("\n Iteration: "+ k +",   PageRank convergence error: "+error);
	    for(int i = 0; i < n; i++) {
		System.out.println("Index: " + i + " -->  PageRank: " + pR[i]);
	    }

	    k++;
	} // fin de la grande boucle tant que l'erreur est plus grande qu'epsilon while(error >= epsilon)
	final double m = 1 - (double) 1/n;
	for(int kDoc = 0; kDoc < n; kDoc++) {
	    BufferedWriter rankOutput = new BufferedWriter
		(new FileWriter(docPath + "/rankscore_"+ String . valueOf(kDoc) +".txt"));
	    rankOutput . write(String . valueOf(Math.pow(pR[kDoc],m)));
	    rankOutput . flush();
	    rankOutput . close();
	}
	
    } // fin de la fonction findPageRank()