function standard
% ----------------------------------------------------------------------- %
% Aufgabenstellung:
%   Die Funktion
%
%       f(x1,x2) = (x1^2 - x2^2)^2 + (1 - x1)^2
%
%   soll unter Verwendung der STANDARD FUZZY ARITHMETIK 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.
%   Bei der Auswertung sollen die Quadrate als Intervallpotenz und
%   aufgeloest durch Multiplikation berechnet werden.
% ----------------------------------------------------------------------- %

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')



%% Berechnung mit Standard Fuzzy Arithmetik

% Ergebnisvariablen
zp = zeros(length(mu), 2);  % Auswertung mit Potenz
zm = zeros(length(mu), 2);  % Auswertung mit Multiplikation

% Anwendung der Intervallarithmetik fuer die einzelnen Alpha-Schnitte
for j = m+1:-1:1 

	x1j = x1(j, :);       % Intervall von x1 bei Level j 
	x2j = x2(j, :);       % Intervall von x2 bei Level j 
    
    % ------------------------------------------------------------------- %
    % Berechnung mit Potenz
    
    % Term 1: (x1^2 - x2^2)
    term_1 = i_add(i_pot(x1j, 2), -i_pot(x2j, 2));
    
    % Term 2: (1 - x1)
    term_2 = i_add([1, 1], -x1j);
 
    % Summe: (Term 1)^2 + (Term 2)^2
    zp(j,:) = i_add( i_pot(term_1, 2), i_pot(term_2, 2) );
        
    
    % ------------------------------------------------------------------- %
    % Berechnung mit Multiplikation statt Potenz
    
    % Term 1: (x1*x1 - x2*x2)
    term_1 = i_add(i_mult(x1j, x1j), -i_mult(x2j, x2j));
    
    % Term 2: (1 - x1)
    term_2 = i_add([1, 1], -x1j);
 
    % Summe: (Term 1)*(Term 1) + (Term 2)*(Term 2)
    zm(j,:) = i_add( i_mult(term_1, term_1), i_mult(term_2, term_2) );
    
    
end 


%% Plot der resultierenden Fuzzy-Zahlen zp und zm

fig_count = fig_count + 1;
h = figure(fig_count);
set(h, 'Name', 'Standard Fuzzy-Arithmetik')
subplot(2,1,1)
plot(zp([1:end/2, end:-1:end/2+1]), [mu; mu(end:-1:1)], 'b')
xlabel('x')
ylabel('\mu')
title('Ergebnis mit Potenz')
subplot(2,1,2)
plot(zm([1:end/2, end:-1:end/2+1]), [mu; mu(end:-1:1)], 'b')
xlabel('x')
ylabel('\mu')
title('Ergebnis mit Multiplikation')
end

%% Implementierung der Intervalloperationen

% Addition
function res = i_add(x1, x2)
%#TODO
end

% Multiplikation
function res = i_mult(x1, x2)
%#TODO
end

% Potenz
function res = i_pot(x, n)
%#TODO
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
