lab4

package ru.favarish;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

public class Lab4 extends Lab3{
    static final String FILE_NAME = "src/ru/favarish/Lab3.java";
    static int GLOBAL_COUNT = 0;

    public static void main(String[] args) throws IOException {

        String strFile = readCodeFile(FILE_NAME);

        Map<String, Integer> frequencyDictionary = counterSingle("AAAAABBBBBCCCCCDDEEF");
        Map<String, Integer> frequencyDictionaryPair = counterPair(strFile);

        ArrayList<Shennon> probabilitySingle = probabilityMapCalculate(frequencyDictionary);
        ArrayList<Shennon> probabilityPair = probabilityMapCalculate(frequencyDictionaryPair);

        Collections.sort(probabilitySingle);
        Collections.sort(probabilityPair);

        //todo не работает тут хз почему
        shennonCoding(0, probabilitySingle.size() - 1, probabilitySingle, "");
        shennonCoding(0, probabilityPair.size() - 1, probabilityPair, "");

        if (DEBUG_MODE == 1) {
            for (Shennon elem : probabilitySingle) {
                System.out.println(elem);
            }
            System.out.println();
            for (Shennon elem : probabilityPair) {
                System.out.println(elem);
            }
        }

        String newStrFile1 = coding(strFile, getCodeMap(probabilitySingle));

        Map<String, Integer> frequencyDictionaryShennon = counterSingle(newStrFile1);
        Map<String, Integer> frequencyDictionaryPairShennon = counterPair(newStrFile1);
        Map<String, Integer> frequencyDictionarythreeShennon = counterPair(newStrFile1);

        System.out.println("Entropy single symbols = " + shennon(probabilityCalculate(frequencyDictionaryShennon)));
        System.out.println("Entropy pair symbols = " + shennon(probabilityCalculate(frequencyDictionaryPairShennon)) / 2);
        System.out.println("Entropy three symbols = " + shennon(probabilityCalculate(frequencyDictionaryPairShennon)) / 3);

        System.out.println("GLOBAL_COUNT=" + GLOBAL_COUNT);

    }

    /**
     * Метод возвращает закодирванную строку согласно кодам пришедшего листа
     * @param strFile изначальный файл, который нужно закодировать
     * @param list таблица кодов
     * @return закодированный файл
     */
    private static String coding(String strFile, HashMap<String, String> list) {
        StringBuilder result = new StringBuilder();

        for (int i = 0; i < strFile.length(); i++) {
            String temp = String.valueOf(strFile.charAt(i));
            result.append(list.get(temp));
        }

        return String.valueOf(result);
    }

    /**
     * Получить мапу K=символ v=код по Шеннону
     * @param list
     * @return
     */
    private static HashMap<String, String> getCodeMap(ArrayList<Shennon> list) {
        HashMap<String, String> result = new HashMap<>();

        for (Shennon elem : list) {
            result.put(elem.getSymbol(), elem.getCode().toString());
        }

        return result;
    }

    /**
     * Рекурсивный метод подсчета кодов Шеннона
     * @param start
     * @param finish
     * @param probability
     * @param code
     */
    public static void shennonCoding(int start, int finish, ArrayList<Shennon> probability, String code) {
        if (code.equals("0")) {
            System.out.println("0");
        } else if (code.equals("1")) {
            System.out.println("1");
        }

        int center = 0;
        if (finish - start >= 1) {
            double difference = Math.abs(sum(start, finish - 1, probability) - sum(finish - 1, finish, probability));

            for (int i = start; i < finish; i++) {
                double newDifference = Math.abs(sum(start, i, probability) - sum(i + 1, finish, probability));
                if (newDifference < difference) {
                    center = i;
                    difference = newDifference;
                }
            }

            shennonCoding(start, center, probability, "0");
            addCodeInDiapason(start, finish, probability, "0");
            shennonCoding(center + 1, finish, probability, "1");
            addCodeInDiapason(start, finish, probability, "1");
//            addCodeInDiapason(start, finish, probability, code);
        }

    }

    /**
     * Метод добавляет code к StringBuilder'у Shennon элемента ArrayList'а
     * @param start стартовая позиция для добвления
     * @param finish конечная позиция для добавления кода
     * @param list лист типа Shennon
     * @param code прибавляемый код
     */
    public static void addCodeInDiapason(int start, int finish, ArrayList<Shennon> list, String code) {
        for (int i = start; i <= finish; i++) {
            list.get(i).getCode().append(code);
        }

        if (DEBUG_MODE == 1) {
            GLOBAL_COUNT++;
        }
    }

    /**
     * Метод суммирует вероятности из выбранного диапазона
     * @param start стартовая позиция
     * @param finish конечная позиция
     * @param list
     * @return сумму вероятностей в выбранном диапазоне
     */
    public static double sum(int start, int finish, ArrayList<Shennon> list) {
        double result = 0;
        for (int i = start; i < finish; i++) {
            result += list.get(i).getProbability();
        }

        return result;
    }


    /**
     * Метод считает фактические вероятности
     * @param frequencyDictionary
     * @return мапа символа и его веростности
     */
    public static ArrayList<Shennon> probabilityMapCalculate(Map<String, Integer> frequencyDictionary) {
        ArrayList<Shennon> 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(new Shennon(symbol.getKey(), symbol.getValue().doubleValue() / generalCount));

            if (DEBUG_MODE == 1) {
                System.out.println(symbol.getKey() + " " + symbol.getValue() + " " + (symbol.getValue().doubleValue() / generalCount));
            }
        }

        return probability;
    }
}


package ru.favarish;

public class Shennon implements Comparable<Shennon>{

    private String symbol;
    private double probability;
    private StringBuilder code;

    public Shennon(String symbol, double probability) {
        this.symbol = symbol;
        this.probability = probability;
        this.code = new StringBuilder();
    }


    @Override
    public int compareTo(Shennon o) {
        double temp = o.probability - this.probability;
        if (temp < 0) {
            return -1;
        } else if (temp > 0) {
            return 1;
        } else {
            return 0;
        }
    }

    public String getSymbol() {
        return symbol;
    }

    public double getProbability() {
        return probability;
    }

    public StringBuilder getCode() {
        return code;
    }

    @Override
    public String toString() {
        return "Shennon{" +
                "symbol='" + symbol + '\'' +
                ", probability=" + probability +
                ", code=" + code +
                '}';
    }
}