function reduced_trafo
% ----------------------------------------------------------------------- %
% Aufgabenstellung:
%   Die Funktion
%
%       f(x1,x2) = (x1^2 - x2^2)^2 + (1 - x1)^2
%
%   soll unter Verwendung der reduzierten TRANSFORMATIONSMETHODE 
%   ausgewertet werden.
%   x1 wird als dreieckige Fuzzy-Zahl mit x1 = tfn(2,3,1) und x2 als quasi-
%   gaussfoermige Fuzzy-Zahl mit Mittelwert 0.5 und Standardabweichung 0.5
%   angenommen.
% ----------------------------------------------------------------------- %

fig_count = 0;

% Definition der Diskretisierungszahl m
m = 24;

% mu-Vektor auf Basis von m
mu = (0 : (1/m) : 1)';


% Definition der Fuzzy-Zahlen x1 und x2 

% dreieckige Fuzzy-Zahl
x1 = tfn(2, 3, 1, mu);

% quasi-gaussfoermige Fuzzy Zahl
x2 = gfn(0.5, 0.5, mu);


% Plot der Zugehoerigkeitsfunktionen von x1 und x2
fig_count = fig_count + 1;
h = figure(fig_count);
set(h, 'Name', 'Standard Fuzzy-Arithmetik')
plot(x1([1:end/2, end:-1:end/2+1]), [mu; mu(end:-1:1)], 'b', ...
    x2([1:end/2, end:-1:end/2+1]), [mu; mu(end:-1:1)], 'r')
xlabel('x')
ylabel('\mu')
title('Zugehoerigkeiten der Fuzzy-Zahlen x1 und x2')
legend('x1', 'x2')


%% Initialisierung der Ergebnisfelder

% Verstaerkunsfaktoren eta1 und eta2
eta1 = zeros(m,1);
eta2 = zeros(m,1);

% Ergebnisse
zlp = zeros(m+1,1); % Potenz, linker Ast der Zugehoerigkeitsfunktion
zrp = zeros(m+1,1); % Potenz, rechter Ast der Zugehoerigkeitsfunktion
zlm = zeros(m+1,1); % Multiplikation, linker Ast der Zugehoerigkeitsfunktion
zrm = zeros(m+1,1); % Multiplikation, rechter Ast der Zugehoerigkeitsfunktion


%% Anwendung der Transformationsmethode

% Schleife ueber alle Alpha-Schnitte
% Beginn bei j = m+1, d.h. bei dem Zugehoerigkeitswerte mu = 1
for j = m+1:-1:1
    
    % reduzierte Transformation der Alpha-Schnitte
    X1 = transred(2, 1, x1(j,1), x1(j,2));
    X2 = transred(2, 2, x2(j,1), x2(j,2));
    
    
    % Ausertung der Funktion mit Potenz und Multiplikation
    
    Zp = (X1.^2 - X2.^2).^2 + (1 - X1).^2;
    
    Zm = (X1.*X1 - X2.*X2).*(X1.*X1 - X2.*X2) + (1 - X1).*(1 - X1);
    
    
    % Ruecktransformation: Teil I
    
    zlp(j) = min(Zp);
    zrp(j) = max(Zp);
    
    zlm(j) = min(Zm);
    zrm(j) = max(Zm);
    
    if j <= m
        
        %	Ruecktransformation: Teil II
        
        zlp(j) = min([zlp(j),zlp(j+1)]);
        zrp(j) = max([zrp(j),zrp(j+1)]);
        
        zlm(j) = min([zlm(j),zlm(j+1)]);
        zrm(j) = max([zrm(j),zrm(j+1)]);
        
        % Berechnung der Verstaerkungsfaktoren eta1 und eta2
        
        eta1(j) = 1 / ( 2*(x1(j,2)-x1(j,1)) ) * (Zp(4)-Zp(2)+Zp(3)-Zp(1));
        eta2(j) = 1 / ( 2*(x2(j,2)-x2(j,1)) ) * (Zp(4)-Zp(3)+Zp(2)-Zp(1));
        
    end
    
end

%% Berechnung der relativen Einflussmasse rho1 und rho2

temp1 = sum(mu(1:m).*abs(eta1.*(x1(1:m,1) + x1(1:m,2))));
temp2 = sum(mu(1:m).*abs(eta2.*(x2(1:m,1) + x2(1:m,2))));

rho1 = temp1./(temp1 + temp2);
rho2 = temp2./(temp1 + temp2);


%% Plot der resultierenden Fuzzy-Zahlen zp und zm

fig_count = fig_count + 1;
h = figure(fig_count);
set(h, 'Name', 'Transformationsmethode')
subplot(2,1,1)
plot([zlp; zrp(end:-1:1)], [mu; mu(end:-1:1)], 'b')
xlabel('x')
ylabel('\mu')
title('Ergebnis mit Potenz')
subplot(2,1,2)
plot([zlm; zrm(end:-1:1)], [mu; mu(end:-1:1)], 'b')
xlabel('x')
ylabel('\mu')
title('Ergebnis mit Multiplikation')


% Output of the normalized sensitivities rho1 and rho2

fig_count = fig_count + 1;
h = figure(fig_count);
set(h, 'Name', 'Transformationsmethode')
pie([rho1, rho2])
title('Einflussmass \rho')
legend('x1', 'x2')

end

%% Transformation der Alpha-Schnitte

function array = transred(n,i,a,b)

% Function for transforming the interval [a,b] into its corresponding
% array according to the transformation method in reduced form.
% [a,b] represents the alpha-cut interval of the i-th fuzzy parameter
% at the current level of membership, and n is the number of independent
% fuzzy parameters (= dimension of the input-variable space).


alpha = %#TODO;
beta = %#TODO;

array = [];

for p = 1 : 2^(i-1)
    
    array ... %#TODO
    
end

end


%% Implementierung der Fuzzy-Zahlen

% Dreieckige Fuzzy Zahl
function x = tfn(mean_, alpha_, beta_, mu_)
% mean_     - Modalwert (oder Kern) der Fuzzy-Zahl
% alpha_    - Abweichung nach links
% beta_     - Abweichung nach rechts
% mu_       - mu-Vektor an denen die Alpha-Schnitte gebildet werden sollen
%
% mu =  { 1 + (x - mean_) / alpha_      x = [mean_ - alpha_, mean_]
%       { 1 - (x - mean_) / beta_       x = [mean_, mean_ + beta_]
%       { 0                             sonst
%
% Bsp. Alpha-Schnitte:  
%       mu=1  ->  x = mean_
%       mu=0  ->  x = [mean_ - alpha_, mean_ + beta_]
%

x1l = %#TODO;    % untere Grenze des alpha-Schnitts
x1r = %#TODO;    % obere Grenze des alpha-Schnitts

x = [x1l, x1r];
end

% quasi-gaussfoermige Fuzzy-Zahl
function x = gfn(mean_, sigma_, mu_)
% mean_     - Modalwert (oder Kern) der Fuzzy-Zahl
% sigma_    - Standardabweichung
%
% mu =  { exp( -(x - mean_).^2 / (2*sigma_) ) 
%                               x = [mean_ - 3*sigma_, mean_ + 3*sigma_]
%       { 0                     sonst
%
% Bsp. Alpha-Schnitte:
%       mu = 1          ->  x = mean_
%       mu < exp(-9/2)  ->  x = [mean_ - 3*sigma_, mean_ + 3*sigma_]
%

x = zeros(length(mu_), 2);

idx = mu_ > exp(-9/2);

x(idx, 1) = %#TODO;
x(idx, 2) = %#TODO;

x(~idx, 1) = %#TODO;
x(~idx, 2) = %#TODO;
end
