function x = idwtdaub(xdaub, J, Hord)
% Inversa daubechies wavelet transform
%       x = idwtdaub(xdaub, J, Hord)
%
% xdaub Daubechies transform av en signal.
% J     Antalet uppdelningssteg.
% Hord  Daubechies filterordning. Om Hord är en vektor, antas den
%       innehålla Daubechies filterkoefficienter.
% x     Den rekonstruerade signalen.

N = length(xdaub);
% kolla att x:s längd kan delas till dividerbar med 2^J
if rem(N, 2^J) ~= 0
    error('The length of x must be a multiple of 2^J');
end


if J == 0 % 0 uppdelningssteg
    x = xdaub;
    return;
elseif J < 0
    error('J must be >= 0');
end

% bestäm om xdaub är rad- eller kolumnvektor. Beräkningarna utförs till 
% en kolumnvektor, men resultatet returneras i samma format som xdaub. 
xs = size(xdaub);
if (xs(1) ~= 1) && (xs(2) == 1)
    % radvektor
    xdaub = xdaub'; % transportera xdaub till kolumnvektor 
    rowvec = true;
elseif (xs(2) ~= 1) && (xs(1) == 1)
    % kolumnvektor
    rowvec = false;
else
    error('invalid transform vector size');
end


if length(Hord) == 1
    % beräkna Daubechies filterkoefficienter
    H = 2 * hdaub(Hord);
else % Hord innehåller filterkoefficienter
    H = 2 * Hord;
end
% anropa den rekursiva implementationen som beräknar själva inversa 
% transformen.
x = idwtdaub_rec(xdaub, J, H);

% returnera x i samma format som xdaub
if rowvec
    x = x';
end


function x = idwtdaub_rec(xdaub, J, H)
% Rekursiv implementation av inversa daubechies wavelet transform
%       x = idwtdaub_rec(xdaub, J, H)
%
% xdaub:Daubechies transform av signal.
% J:    Antalet uppdelningssteg.
% H:    Daubechies filterkoefficienter (genererade med hdaub(...) ) som har
%       använts för att beräkna xdaub.
% x:    Den rekonstruerade signalen.

N = length(xdaub);
LH = N / 2; % xH:s längd

xLix = 1:LH; % index för xL
xHix = (LH+1):N; % index för xH

if J == 1
    % Om J=1 (en uppdelningssteg), är xdaub = [xL, xH] och sekvensen x kan
    % rekonstrueras genom att ena xL och xH. 
    xL = xdaub( xLix );
    xH = xdaub( xHix );
else % J > 1
    % om J>1 (flera uppdelningssteg), kan xL rekonstueras från första halvan
    % av xdaub. x fås genom att sedan ena xL med xH.
    % xdaub = [xL...LL, xL...LH, ..., xLH, xH], de två första sekvenser har
    % längden LH(1), sedan LH(2) osv. xH börjar från 2*L(xL...LL) + LH(xL...H) 
    % + ... + L(xLH) = 2*LH(1) + LH(2) + ... + LH(J-1). Obs. att J =
    % length(LH) - 1.
    % Rekonstruera xL    
    xL = idwtdaub_rec( xdaub(xLix), J-1, H);
    xH = xdaub(xHix);
end

% ena xL och xH
x = idaubstp(xL, xH, H);