33

package ru.lab1;

import java.io.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

public class Main {
    static String FILE_NAME1 = "F1.txt";
    static String FILE_NAME2 = "F2.txt";


    public static void main(String[] args) throws IOException {
        Map<String, Integer> frequencyDictionary1 = new HashMap<>();
        Map<String, Integer> frequencyDictionary2 = new HashMap<>();
        Map<String, Integer> frequencyDictionaryPair1 = new HashMap<>();
        Map<String, Integer> frequencyDictionaryPair2 = new HashMap<>();

        writeF1(frequencyDictionary1);
        writeF2(frequencyDictionary2);
        counterPair(FILE_NAME1, frequencyDictionaryPair1);
        counterPair(FILE_NAME2, frequencyDictionaryPair2);

        System.out.println("Entropy for F1 = " + shennon(probabilityCalculate(frequencyDictionary1)));
        System.out.println("Entropy for F2 = " + shennon(probabilityCalculate(frequencyDictionary2)));
        System.out.println("Entropy for pair F1 = " + shennon(probabilityCalculate(frequencyDictionaryPair1)) / 2);
        System.out.println("Entropy for pair F2 = " + shennon(probabilityCalculate(frequencyDictionaryPair2)) / 2);

        // Считаем теоретическую вероятность
        ArrayList temp = new ArrayList();
        for (int i = 0; i < 4; i++) temp.add(0.25);

        System.out.println("Theory entropy for F1 = " + shennon(temp));

        temp.clear();
        temp.add(0.05);
        temp.add(0.15);
        temp.add(0.1);
        temp.add(0.7);

        System.out.println("Theory entropy for F2 = " + shennon(temp));
    }

    /**
     * Считает вхождения всех пар символов (соседних друг с другом)
     * @param filename файл из которого будут считываться данные
     * @param frequencyDictionaryPair результат метода будет здесь
     * @throws IOException
     */
    private static void counterPair(String filename, Map<String, Integer> frequencyDictionaryPair) throws IOException {
        String s;
        BufferedReader reader = new BufferedReader(new FileReader(filename));
        s = reader.readLine();

        for (int i = 0; i < s.length() - 1; i++) {
            merge(frequencyDictionaryPair, s.charAt(i) + "" + s.charAt(i + 1));
        }
    }

    /**
     * Вычисляет фактические вероятности
     * @param frequencyDictionary количество определенных символов или их последовательностей
     * @return ArrayList полученных вероятностей
     */
    private static ArrayList probabilityCalculate(Map<String, Integer> frequencyDictionary) {
        ArrayList<Double> probability = new ArrayList<>();
        int generalCount = 0;

        for (Map.Entry<String, Integer> symbol : frequencyDictionary.entrySet()) {
            generalCount += symbol.getValue();
        }

        for (Map.Entry<String, Integer> symbol : frequencyDictionary.entrySet()) {
            probability.add(symbol.getValue().doubleValue() / generalCount);
            //System.out.println(symbol.getKey() + " " + symbol.getValue() + " " + (symbol.getValue().doubleValue() / generalCount));
        }

        return probability;
    }

    private static double log2(double x){
        return Math.log(x)/Math.log(2);
    }

    private static double shennon(ArrayList<Double> probability) {
        double entropy = 0;

        for (Double p : probability) {
            entropy += p * log2(p);
        }

        return -entropy;
    }

    /**
     * Генерирует в файл равновероятную последовательность из четырех символов
     * @param frequencyDictionary1 словарь для посчета количества каждого символа
     * @throws IOException
     */
    private static void writeF1(Map<String, Integer> frequencyDictionary1) throws IOException {
        File file = new File(FILE_NAME1);
        FileWriter writer = new FileWriter(file);

        int rnd;

        while (file.length() < 10000) {
            for (int i = 0; i < 1024; i++) {
                rnd = (int) (Math.random() * 4);

                writer.append((char) (rnd + 65));
                merge(frequencyDictionary1, (char) (rnd + 65) + ""); // счетчик символов
            }
            writer.flush();
        }
    }

    /**
     * Последовательно и независимо генерирует символы с определенными вероятностями и записывает их в файл
     * @param frequencyDictionary2 словарь для посчета количества каждого символа
     * @throws IOException
     */
    private static void writeF2(Map<String, Integer> frequencyDictionary2) throws IOException {
        File file = new File(FILE_NAME2);
        FileWriter writer = new FileWriter(file);

        int rnd;
        while (file.length() < 10000) {
            for (int i = 0; i < 1024; i++) {
                rnd = (int) (Math.random() * 100 + 1);

                if (rnd <= 5) {
                    writer.append((char) 65); // вероятность 0.05
                    merge(frequencyDictionary2, (char) 65 + "");
                } else if (rnd > 5 && rnd <= 20) {
                    writer.append((char) 66); // вероятность 0.15
                    merge(frequencyDictionary2, (char) 66 + "");
                } else if (rnd > 20 && rnd <= 30) {
                    writer.append((char) 67); //вероятность 0.1
                    merge(frequencyDictionary2, (char) 67 + "");
                } else if (rnd > 30) {
                    writer.append((char) 68); // вероятноть 0.7
                    merge(frequencyDictionary2, (char) 68 + "");
                }
            }
            writer.flush();
        }
    }

    private static void merge(Map<String, Integer> map, String symbol) {
        if (map.containsKey(symbol)) {
            int oldCount = map.get(symbol);
            map.put(symbol, ++oldCount);
        } else {
            map.put(symbol, 1);
        }
    }
}