laboras

%% RLE kodavimas
clear all
clc
j = 1;
i = 1;
load('Temperature.mat');

%Paleidžiamas ciklas per visas temp. reikšmes
while i <= length(Temperature)
    val = Temperature(i);
    rleEncodedTemp(j) = val;
    repeat = 1;

    %Tikrinama ar sekanti reikšmė yra tokia pati
    while i < length(Temperature) && val == Temperature(i + 1)
        repeat = repeat + 1; %pasikartojimų skaičius
        i = i + 1; %pereinama prie kitos temp. reikšmės
    end

    %Kitu elementu masyve įrašomas pasikartojimų skaičius
    j = j + 1;
    rleEncodedTemp(j) = repeat;

    j = j + 1;
    i = i + 1;
end

%Pirminės sekos dydis bitais
sizeOrig = length(dec2bin(max(Temperature))) * length(Temperature);

maxEncodedValue = max(rleEncodedTemp(1:2:end));
minEncodedValue = min(rleEncodedTemp(1:2:end));
if minEncodedValue < 0
    encodedValueLength = length(dec2bin(maxEncodedValue - minEncodedValue));
else
    encodedValueLength = length(dec2bin(maxEncodedValue))
end

maxEncodedRepetition = max(rleEncodedTemp(2:2:end));
repetitionLength = length(dec2bin(maxEncodedRepetition))

%Užkoduotos RLE koduote sekos dydis bitais
encodedSize = (encodedValueLength + repetitionLength) * (length(rleEncodedTemp) / 2);

%Duomenų dydžio sumažėjimas
sizeOrig
encodedSize
compression = (sizeOrig - encodedSize) / sizeOrig
%% Delta kodavimas
clear all
clc
load('Temperature.mat');

deltaTemp(1) = Temperature(1);

for i = 2:length(Temperature)
    deltaTemp(i) = Temperature(i) - Temperature(i-1);
end

%Pirminės sekos dydis bitais
sizeOrig = length(dec2bin(max(Temperature))) * length(Temperature);

%Užkoduotos sekos dydis bitais
firstValueSize = length(dec2bin(deltaTemp(1)));
differenceValuesSize = length(dec2bin(max(deltaTemp(2:end)) - min(deltaTemp(2:end))));
encodedSize = differenceValuesSize * (length(Temperature) - 1) + firstValueSize;

%Duomenų dydžio sumažėjimas
sizeOrig
encodedSize
compression = (sizeOrig - encodedSize) / sizeOrig
%% RLE kodu užkoduotos Delta vertės
clear all
clc
load('Temperature.mat');

%Delta užkodavimas
deltaTemp(1) = Temperature(1);

for i = 2:length(Temperature)
    deltaTemp(i) = Temperature(i) - Temperature(i-1);
end

%RLE kodavimas
j = 1;
i = 1;
while i <= length(deltaTemp)
    val = deltaTemp(i);
    rleEncodedTemp(j) = val;
    repeat = 1;

    while i < length(deltaTemp) && val == deltaTemp(i + 1)
        repeat = repeat + 1;
        i = i + 1;
    end

    %Kitu elementu masyve įrašomas pasikartojimų skaičius
    j = j + 1;
    rleEncodedTemp(j) = repeat;

    j = j + 1;
    i = i + 1;
end

%Užkoduotos Delta sekos dydis bitais
firstValueSize = length(dec2bin(deltaTemp(1)));
differenceValuesSize = length(dec2bin(max(deltaTemp(2:end)) - min(deltaTemp(2:end))));
deltaEncodedSize = differenceValuesSize * (length(Temperature) - 1) + firstValueSize;

%RLE - delta kodo dydis bitais
rleFirstValSize = length(dec2bin(rleEncodedTemp(1)))

maxEncodedValue = max(rleEncodedTemp(3:2:end));
minEncodedValue = min(rleEncodedTemp(3:2:end));
if minEncodedValue < 0
    encodedValueLength = length(dec2bin(maxEncodedValue - minEncodedValue));
else
    encodedValueLength = length(dec2bin(maxEncodedValue));
end

maxEncodedRepetition = max(rleEncodedTemp(2:2:end));
repetitionLength = length(dec2bin(maxEncodedRepetition));

%Užkoduotos RLE koduote sekos dydis bitais
sizeEncodedRle = ((encodedValueLength + repetitionLength) * (length(rleEncodedTemp) / 2)) + rleFirstValSize;

%Duomenų dydžio sumažėjimas
deltaEncodedSize
sizeEncodedRle
compression = (deltaEncodedSize - sizeEncodedRle) / deltaEncodedSize

%% Hafmano kodavimas
clear all
clc
load('Temperature.mat');
tempOrig = Temperature;

tempValues = [];

%Sudaromas visų esamų temp. verčių masyvas (be pasikartojimų)
for i = 1:length(tempOrig)
    valueExist = 0;
    for j = 1:length(tempValues)
        if tempValues(j) == tempOrig(i)
            valueExist = 1;
        end
    end

    if valueExist == 0
        tempValues(end + 1) = tempOrig(i);
    end
end

valuesProbability = [];

%Nustatoma kiekvienos vertės atsiradimo tikimybė
for i = 1:length(tempValues)
    repeatCount = 0;

    %Tam tikros vertės pasikartojimų skaičius
    for j = 1:length(tempOrig)
        if tempValues(i) == tempOrig(j)
            repeatCount = repeatCount + 1;
        end
    end

    %Pasikartojimo tikimybė
    valuesProbability(i) = repeatCount / length(tempOrig);
end


%Hafmano žodynas
dict = huffmandict(tempValues, valuesProbability);


%Hafmano būdu užkoduota temp. verčių seka
tempEncoded = huffmanenco(tempOrig, dict);

%Neužkoduotos sekos dydis bitais
sizeOrig = length(dec2bin(max(tempOrig))) * length(tempOrig)

%Užkoduotos Hafmano būdu sekos dydis bitais
sizeEncoded = length(tempEncoded)
%% Pasikartojantys kodai
clear all
clc
load('Temperature.mat');
tempOrig = Temperature;

%Funkcija, užkoduojanti seką pasikartojančio kodo būdu
%kai įvesties sekos elemento dydis 8 bitai, o pasikartojimų skaičius 3
tempEncoded = my_repetition(tempOrig, 3)

%Neužkoduotos sekos dydis bitais
sizeOrig = 8 * length(tempOrig)

%Užkoduotos sekos dydis bitais
sizeEncoded = length(tempEncoded)

%Duomenų padidėjimas
dataIncrease = (sizeEncoded - sizeOrig) / sizeOrig

%% Hemingo kodavimas
clear all
clc
load('Temperature.mat');

%Hemingo kodavimas, kai neužkoduoto dvejetainio pavidalo sekos elemento
%dydis - 11, užkoduoto - 15
m = 4;
n = 2^m -1; %15
k = n - m; %11

tempOrig = Temperature;

%Funkcija kodavimui Hemingo būdu
tempEncoded = my_hamming_encode(tempOrig, n, k);

%Neužkoduotos sekos dydis bitais
sizeOrig = 11 * length(tempOrig)

%Užkoduotos sekos dydis bitais
sizeEncoded = length(tempEncoded)

%Duomenų padidėjimas
dataIncrease = (sizeEncoded - sizeOrig) / sizeOrig


%------------FUNKCIJOS (ATSKIRI FAILAI)------------------------

%Funkcija grąžina dvejetainę seką su pasikartojimais
function out = my_repetition (in, numOfRep)
    out = '';
    out_idx = 1;
    %Algoritmas skirtai kiekvienai temperatūros vertei sekoje
    for i = 1:length(in)
        %Temp. vertės konvertavimas į 8 skaitmenų dvejetainį pavidalą
        b = dec2bin(in(i), 8);

        %Kiekvieno skaitmens pasikartojimas
        k = 1;
        for j = 1:8
            c(k:k + numOfRep - 1) = b(j);
            k = k + numOfRep;
        end

        %Skaitmens pridėjimas prie visos užkoduotos sekos masyvo
        out(out_idx:out_idx + 8 * numOfRep - 1)  = c(1:8 * numOfRep);
        out_idx = out_idx + 8 * numOfRep;
    end
end

%--------------

function encoded_data = my_hamming_encode (in, n, k)
    ind = 1;
    for i = 1:length(in)
        value = dec2bin(in(i), k);

        for j = 1:k
            bin_data(j) = str2num(value(j));
        end

        encoded_word = encode(bin_data, n, k, 'Hamming');

        encoded_data(ind:ind + n - 1) = encoded_word(1:n);
        ind = ind + n;
    end
end