codigo

package analise.redes.sociais;

import java.io.File;
import java.io.FileNotFoundException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Formatter;
import java.util.Scanner;
import org.la4j.Matrix;
import org.la4j.decomposition.EigenDecompositor;
import org.la4j.matrix.dense.Basic2DMatrix;

public class ANALISEREDESSOCIAIS {

    private final static String SEPARADOR_DADOS_FICH = ",";

    private static final Scanner input = new Scanner(System.in);
    private static final Formatter output = new Formatter(System.out);

    public static void main(String[] args) throws FileNotFoundException {
        if (args[0].equals("-n")) {
            String nomeFicheiroNos = args[1];
            String nomeFicheiroRamos = args[2];
            //Contagem do número de elementos
            int nElems = contagemEntidades(nomeFicheiroNos);

            if (nElems == 0) {
                System.out.println("Ficheiro de entrada com erros");
                System.out.println("(Erro: O ficheiro de entrada contém menos de 1 ou mais de 200 nós)");
            } else {
                //Criação da Matriz de Adjacência
                double matrizAdjacencia[][] = new double[nElems][nElems];
                //Criação do vetor de Id's
                String vetorIds[] = new String[nElems];
                double valoresProprios[] = new double[nElems];
                double vetorProprio[] = new double[nElems];
                double matrizB[][] = new double[nElems][nElems];
                double matrizC[][] = new double[nElems][nElems];
                preenchimentoVetorIds(vetorIds, nomeFicheiroNos);
                int erro = preenchimentoMatrizAdjacencia(matrizAdjacencia, vetorIds, nomeFicheiroRamos);
                if (erro == 1) {
                    System.out.println("O ficheiro de entrada continha um erro que foi corrigido");
                    System.out.println("(Erro: Estabelecer uma relação entre o mesmo Id)");
                }
                int op;
                do {
                    op = menu();
                    switch (op) {
                        case 1:
                            System.out.println("");
                            impressaoMatrizAdjacencia(matrizAdjacencia, nElems);
                            System.out.println("");
                            break;
                        case 2:
                            System.out.println("");
                            for (int indice = 0; indice < nElems; indice++) {
                                float grau = calculoDoGrauDeUmNo(indice, nElems, matrizAdjacencia);
                                System.out.println("O nó de Id " + vetorIds[indice] + " tem grau " + grau);
                            }
                            System.out.println("");
                            break;
                        case 3:
                            System.out.println("");
                            obterValoresProprios(matrizAdjacencia, nElems, valoresProprios, vetorProprio);
                            output.format("%s%.3f%n","A centralidade tem valor ", descobrirCentralidadeVetor(vetorProprio));
                            System.out.println("");
                            break;
                        case 4:
                            System.out.println("");
                            output.format("%s%.3f%n","O grau médio é ", grauMedio(nElems, matrizAdjacencia));
                            System.out.println("");
                            break;
                        case 5:
                            System.out.println("");
                            float densidade = densidadeRede(nElems, matrizAdjacencia);
                            output.format("%s%.3f%n","A densidade da rede tem valor ", densidade);
                            System.out.println("");
                            break;
                        case 6:
                            System.out.println("");
                            clonarMatriz(matrizAdjacencia, matrizB);
                            int comprimento = pedirComprimento();
                            System.out.println("k=1:");
                            impressaoMatrizAdjacencia(matrizAdjacencia, nElems);
                            for (int k = 2; k <= comprimento; k++) {
                                System.out.println("k=" + k + ":");
                                produtoMatrizes(matrizAdjacencia, matrizB, matrizC);
                                clonarMatriz(matrizC, matrizB);
                                impressaoMatrizAdjacencia(matrizB, nElems);
                            }
                            System.out.println("");
                            break;
                        case 0:
                            System.out.println("");
                            System.out.println("Já fez todas as gravações necessárias? Confirma terminar (s/n)?");
                            char resp = (input.next()).charAt(0);
                            if ((resp != 's') && (resp != 'S')) {
                                op = 1;
                            }
                            break;
                        default:
                            System.out.println("");
                            System.out.println("Opção incorreta. Repita");
                            System.out.println("");
                            break;
                    }
                } while (op != 0);
            }

        } else if (args[0].equals("-t")) {
            int k = Integer.parseInt(args[2]);
            String nomeFicheiroNos = args[3];
            //String nomeFicheiroNos = "rs_media_nos.csv";
            String nomeFicheiroRamos = args[4];
            String[] temp = nomeFicheiroNos.split("_");
            String dataSist = getDateTime();
            Formatter outfile = new Formatter(new File("out_" + temp[1] + "_" + dataSist + ".txt"));
            int nElems = contagemEntidades(nomeFicheiroNos);

            if (nElems == 0) {
                outfile.format("%n%s%n%n%s%n", "Ficheiro de entrada com erros", "(Erro: O ficheiro de entrada contém menos de 1 ou mais de 200 nós)");
            } else {
                double matrizAdjacencia[][] = new double[nElems][nElems];
                String vetorIds[] = new String[nElems];
                double valoresProprios[] = new double[nElems];
                double vetorProprio[] = new double[nElems];
                double matrizB[][] = new double[nElems][nElems];
                double matrizC[][] = new double[nElems][nElems];
                preenchimentoVetorIds(vetorIds, nomeFicheiroNos);
                int erro = preenchimentoMatrizAdjacencia(matrizAdjacencia, vetorIds, nomeFicheiroRamos);
                if (erro == 1) {
                    outfile.format("%n%s%n%n%s%n", "O ficheiro de entrada continha um erro que foi corrigido", "(Erro: Estabelecer uma relação entre o mesmo Id)");
                }

                outfile.format("%s%n%n", "1 - Impressão da matriz de adjacências (com relações):");
                impressaoMatrizAdjacenciaFicheiro(matrizAdjacencia, nElems, outfile);
                outfile.format("%s%n%n", "2 - Cálculo do grau de todos os nós:");
                for (int indice = 0; indice < nElems; indice++) {
                    float grau = calculoDoGrauDeUmNo(indice, nElems, matrizAdjacencia);
                    outfile.format("%s%n", "O nó de Id " + vetorIds[indice] + " tem grau " + grau);
                }
                outfile.format("%n%s%n", "3 - Centralidade do vetor próprio:");
                obterValoresProprios(matrizAdjacencia, nElems, valoresProprios, vetorProprio);
                outfile.format("%n%s%.3f%s%n", "A centralidade tem valor ", descobrirCentralidadeVetor(vetorProprio), ".");
                outfile.format("%n%s%n", "4 - Cálculo do grau médio:");
                outfile.format("%n%s%.3f%s%n", "O grau médio é ", grauMedio(nElems, matrizAdjacencia), ".");
                outfile.format("%n%s%n", "5 - Cálculo da densidade da rede:");
                float densidade = densidadeRede(nElems, matrizAdjacencia);
                outfile.format("%n%s%.3f%s%n", "A densidade da rede tem valor ", densidade, ".");
                outfile.format("%n%s%n", "6 - Cálculo de uma potência da matriz de adjacências:");
                outfile.format("%n%s%n", "k=1:");
                clonarMatriz(matrizAdjacencia, matrizB);
                impressaoMatrizAdjacenciaFicheiro(matrizAdjacencia, nElems, outfile);
                for (int i = 2; i <= k; i++) {
                    outfile.format("%n%s%n", "k=" + i + ":");
                    produtoMatrizes(matrizAdjacencia, matrizB, matrizC);
                    clonarMatriz(matrizC, matrizB);
                    impressaoMatrizAdjacenciaFicheiro(matrizB, nElems, outfile);
                }
            }
            outfile.close();

        }

    }

    public static int menu() {
        int op;
        String menu = " MENU:"
                + "\n"
                + "\n 1 - Impressão da matriz de adjacências (com relações)"
                + "\n 2 - Cálculo do grau de todos os nós"
                + "\n 3 - Centralidade do vetor próprio"
                + "\n 4 - Cálculo do grau médio"
                + "\n 5 - Cálculo da densidade da rede"
                + "\n 6 - Cálculo de uma potência da matriz de adjacências"
                + "\n 0 - Terminar"
                + "\n"
                + "\n Digite a sua opção: ";
        output.format("%s", menu);
        op = input.nextInt();
        input.nextLine();
        return op;
    }

    public static int contagemEntidades(String nomeFicheiroNos) throws FileNotFoundException {
        int contagem = 0;
        Scanner inputFile = new Scanner(new File(nomeFicheiroNos));
        while (inputFile.hasNextLine()) {
            String linha = inputFile.nextLine();
            if ((linha.trim()).length() > 0) {
                contagem = contagem + 1;
            }
        }
        if ((contagem - 1) <= 0 || (contagem - 1) > 200) {
            return 0;
        }
        return (contagem - 1);
    }

    public static void preenchimentoVetorIds(String vetorIds[], String nomeFicheiroNos) throws FileNotFoundException {
        Scanner inputFile = new Scanner(new File(nomeFicheiroNos));
        int i = 0;
        inputFile.nextLine();
        while (inputFile.hasNextLine()) {
            String linha = inputFile.nextLine();
            if (linha.trim().length() > 0) {
                String[] temp = linha.split(SEPARADOR_DADOS_FICH);
                vetorIds[i] = temp[0];
                i++;
            }
        }
    }

    public static void impressaoMatrizAdjacencia(double matrizAdjacencia[][], int nElems) {
        for (int i = 0; i < nElems; i++) {
            for (int j = 0; j < nElems; j++) {
                output.format("%5s", matrizAdjacencia[i][j]);
            }
            output.format("%n%n", "");
        }
    }

    public static void impressaoMatrizAdjacenciaFicheiro(double matrizAdjacencia[][], int nElems, Formatter outfile) {
        for (int i = 0; i < nElems; i++) {
            for (int j = 0; j < nElems; j++) {
                outfile.format("%5s", matrizAdjacencia[i][j]);
            }
            outfile.format("%n%n", "");
        }
    }

    public static int procurarPosicaoVetor(String vetor[], String elemento) {
        for (int i = 0; i < vetor.length; i++) {
            if (elemento.equals(vetor[i])) {
                return i;
            }
        }
        return 0;
    }

    public static int preenchimentoMatrizAdjacencia(double matrizAdjacencia[][], String vetorIds[], String nomeFicheiroRamos) throws FileNotFoundException {
        Scanner inputFile = new Scanner(new File(nomeFicheiroRamos));
        int flag = 0;
        int pos1, pos2;
        inputFile.nextLine();
        while (inputFile.hasNextLine()) {
            String linha = inputFile.nextLine();
            if (linha.trim().length() > 0) {
                String[] temp = linha.split(SEPARADOR_DADOS_FICH);
                pos1 = procurarPosicaoVetor(vetorIds, temp[0].trim());
                pos2 = procurarPosicaoVetor(vetorIds, temp[1].trim());
                if (pos1 == pos2) {
                    flag = 1;
                }
                if (!(pos1 == pos2)) {
                    matrizAdjacencia[pos1][pos2] = 1;
                    matrizAdjacencia[pos2][pos1] = 1;
                }
            }
        }
        return flag;
    }

    public static float calculoDoGrauDeUmNo(int no, int nElems, double matrizAdjacencia[][]) {
        float grau = 0;
        for (int i = 0; i < nElems; i++) {
            if (matrizAdjacencia[no][i] != 0) {
                grau = grau + 1;
            }
        }
        return grau;
    }

    public static void obterValoresProprios(double matrizAdjacencia[][], int nElems, double valoresProprios[], double vetorProprio[]) {
        Matrix a = new Basic2DMatrix(matrizAdjacencia);
        EigenDecompositor eigenD = new EigenDecompositor(a);
        Matrix[] mattD = eigenD.decompose();
        double matA[][] = mattD[0].toDenseMatrix().toArray();
        double matB[][] = mattD[1].toDenseMatrix().toArray();
        for (int i = 0; i < nElems; i++) {
            for (int j = 0; j < nElems; j++) {
                if (i == j) {
                    valoresProprios[i] = matB[i][j];
                }
            }
        }
        int indice = verIndiceDoMaiorElementoNumVetor(valoresProprios);
        for (int c = 0; c < nElems; c++) {
            vetorProprio[c] = matA[c][indice];
        }
    }

    public static int verIndiceDoMaiorElementoNumVetor(double vetor[]) {
        double valor = vetor[0];
        int indice = 0;
        for (int i = 1; i < vetor.length; i++) {
            if (vetor[i] > valor) {
                valor = vetor[i];
                indice = i;
            }
        }
        return indice;
    }

    public static double descobrirCentralidadeVetor(double vetorProprio[]) {
        int indice = verIndiceDoMaiorElementoNumVetor(vetorProprio);
        double centralidade = vetorProprio[indice];
        return centralidade;
    }

    public static float grauMedio(int nElems, double matrizAdjacencia[][]) {
        float grauMedio = 0;
        for (int j = 0; j < nElems; j++) {
            grauMedio = grauMedio + calculoDoGrauDeUmNo(j, nElems, matrizAdjacencia);
        }
        return grauMedio / nElems;
    }

    public static float densidadeRede(int nElem, double matrizAdjacencia[][]) {
        float maxRamos = (nElem * nElem - nElem) / 2;
        float numRamos = numRamos(matrizAdjacencia, nElem);
        return numRamos / maxRamos;
    }

    public static float numRamos(double matrizAdjacencia[][], int nElem) {
        int numRamos = 0;
        for (int i = 0; i < nElem - 1; i++) {
            for (int j = i + 1; j < nElem; j++) {
                if (matrizAdjacencia[i][j] == 1) {
                    numRamos++;
                }
            }
        }
        return numRamos;
    }

    public static int pedirComprimento() {
        int comprimento;
        do {
            System.out.print("Digite o comprimento das ligações desejado: ");
            comprimento = input.nextInt();
            System.out.println("");
            input.nextLine();
        } while (comprimento < 1);
        return comprimento;
    }

    public static void clonarMatriz(double[][] matrizAdjacencias, double[][] matrizB) {
        for (int i = 0; i < matrizAdjacencias.length; i++) {
            matrizB[i] = matrizAdjacencias[i].clone();
        }
    }

    public static void produtoMatrizes(double[][] matrizAdjacencias, double[][] matrizB, double[][] matrizC) {
        double soma = 0;
        for (int j = 0; j < matrizAdjacencias.length; j++) {
            for (int i = 0; i < matrizAdjacencias[j].length; i++) {
                soma = 0;
                for (int k = 0; k < matrizAdjacencias.length; k++) {
                    soma = soma + matrizAdjacencias[j][k] * matrizB[k][i];
                }
                matrizC[j][i] = soma;
            }
        }
    }

    private static String getDateTime() {
        DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
        Date date = new Date();
        String data = dateFormat.format(date);
        String[] temp = data.split(" ");
        String[] temp1 = temp[0].split("/");
        String dataFinal = temp1[0] + temp1[1] + temp1[2];
        return dataFinal;
    }
}