mprintf("\n")
mprintf("\n------------Parametri S------------\n")
mprintf("\n      Created by Paolo Piazza      \n"); mprintf("\n")
mprintf("AVVISO: I numeri complessi sono forniti e da\n")
mprintf("fornire nel formato vettore [modulo fase] con \n")
mprintf("la fase in gradi.\n"); mprintf("\n")
mprintf(" Inserire i valori dei parametri S:\n"); mprintf("\n")
mprintf("   s11  s12\n") 
mprintf("   s21  s22\n") 
mprintf("\n")

funcprot(0)
function [s11p] = ins_s11()
s11p = input("s11: ");
//Correzione del dato
    mprintf("Digitare una scelta:\n")
    mprintf("1: conferma dato, 2: reinserisci dato, 3: uscita programma.\n")
    conferma = input("Scelta: ");
    while conferma,
        select(conferma)
        case 1 then
            break;
        case 2 then
            s11p = input("s11: ");
            mprintf("Digitare una scelta:\n")
            mprintf("1: conferma dato, 2: reinserisci dato, 3: uscita programma.\n")
            conferma = input("Scelta: ");
        case 3 then
            abort;
        else
            conferma = input("Scelta: ");
        end
    end
//Fine script correzione dato
endfunction

function [s21p] = ins_s21()
s21p = input("s21: ");
//Correzione del dato
    mprintf("Digitare una scelta:\n")
    mprintf("1: conferma dato, 2: reinserisci dato, 3: uscita programma.\n")
    conferma = input("Scelta: ");
    while conferma,
        select(conferma)
        case 1 then
            break;
        case 2 then
            s21p = input("s21: ");
            mprintf("Digitare una scelta:\n")
            mprintf("1: conferma dato, 2: reinserisci dato, 3: uscita programma.\n")
            conferma = input("Scelta: ");
        case 3 then
            abort;
        else
            conferma = input("Scelta: ");
        end
    end
//Fine script correzione dato
endfunction

function [s12p] = ins_s12()
s12p = input("s12: ");
//Correzione del dato
    mprintf("Digitare una scelta:\n")
    mprintf("1: conferma dato, 2: reinserisci dato, 3: uscita programma.\n")
    conferma = input("Scelta: ");
    while conferma,
        select(conferma)
        case 1 then
            break;
        case 2 then
            s12p = input("s12: ");
            mprintf("Digitare una scelta:\n")
            mprintf("1: conferma dato, 2: reinserisci dato, 3: uscita programma.\n")
            conferma = input("Scelta: ");
        case 3 then
            abort;
        else
            conferma = input("Scelta: ");
        end
    end
//Fine script correzione dato
endfunction

function [s22p] = ins_s22()
s22p = input("s22: ");
//Correzione del dato
    mprintf("Digitare una scelta:\n")
    mprintf("1: conferma dato, 2: reinserisci dato, 3: uscita programma.\n")
    conferma = input("Scelta: ");
    while conferma,
        select(conferma)
        case 1 then
            break;
        case 2 then
            s22p = input("s22: ");
            mprintf("Digitare una scelta:\n")
            mprintf("1: conferma dato, 2: reinserisci dato, 3: uscita programma.\n")
            conferma = input("Scelta: ");
        case 3 then
            abort;
        else
            conferma = input("Scelta: ");
        end
    end
//Fine script correzione dato
endfunction

funcprot(0)
// Conversione da forma polare a cartesiana e viceversa
// Script elaborato da RenzoDF, disponibile liberamente 
// su www.electroyou.it
//----------------------INIZIO SCRIPT----------------------------
k0=%pi/180; j=%i;
format('v',6)
// pc() - Converte da polare a cartesiana.
function [c] = pc(m,f)
 if argn(2) == 1 then
  //Se singolo argomento di ingresso modulo e fase su 2 col. adiacenti
  c = m(:,1:2:$).*cos(m(:,2:2:$)*k0) + j*m(:,1:2:$).*sin(m(:,2:2:$)*k0);
 elseif argn(2) == 2 then
  //Se doppio argomento, modulo e fase in matrici separate
  c = m.*cos(f*k0) + j*m.*sin(f*k0);
 end
endfunction
//-----------------------------------------------------
// cp() - Converte da cartesiana a polare.
function [m,f] = cp(c)
    [nr nc]=size(c);
  if argn(1) == 1 then
   //Se richiesto singolo argomento, 
  //modulo e fase ritornano su due colonne adiacenti
   m=zeros(nr,2*nc); //definisco matrice con colonne doppie
   m(:,1:2:$) = abs(c);
   m(:,2:2:$) = phasemag(c);
 elseif argn(1) == 2 then
  //Se richiesto doppio argomento, 
 //modulo e fase ritornano su matrici separate
   f  = phasemag(c);
  m = abs(c);
 end
endfunction
//-----------------------FINE SCRIPT----------------------------

s11p = ins_s11(); s11 = pc(s11p); s11m = abs(s11);
s21p = ins_s21(); s21 = pc(s21p); s21m = abs(s21);
s12p = ins_s12(); s12 = pc(s12p); s12m = abs(s12);
s22p = ins_s22(); s22 = pc(s22p); s22m = abs(s22);
D = (s11*s22)-(s12*s21)
Dm = abs(D);
K = (1-s11m^2-s22m^2+Dm^2)/(2*abs(s12*s21));
mprintf("\nD = \n"); disp(cp(D))
mprintf("\nK = \n"); disp(K); mprintf("\n")

funcprot(0)
function varargout = scelta_calcolo()
mprintf("\nScegliere cosa si vuole calcolare:\n")
mprintf(" 1: Γin\n")
mprintf(" 2: Γout\n")
mprintf(" 3: Ga\n")
mprintf(" 4: Gp\n")
mprintf(" 5: Gt\n")
mprintf(" 6: Cerchio di stabilità in ingresso\n")
mprintf(" 7: Cerchio di stabilità in uscita\n")
mprintf(" 8: Cerchi equi-Ga (conoscendo Ga)\n")
mprintf(" 9: Cerchi equi-Gp (conoscendo Gp)\n")
mprintf("10: NF\n")
mprintf("11: Cerchi equi-noise\n")
mprintf("12: Cerchi equi-Gt (conoscendo Γs e Gt)\n")
mprintf("13: Terminazioni ottime\n")
mprintf("14: Uscita\n")
mprintf("\n")

scelta = input("Scelta: ");
while scelta <> 14
while ((scelta < 1) & (scelta > 14))
    scelta = input("Scelta non valida. Riprovare: ")
end
select(scelta)
case 1 then //Γin
    Gamma_l_p = input("Inserire Γl in [modulo fase]: ");
//Correzione del dato
    mprintf("Digitare una scelta:\n")
    mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
    conferma = input("Scelta: ");
    while conferma,
        select(conferma)
        case 1 then
            break;
        case 2 then
            Gamma_l_p = input("Inserire Γl in [modulo fase]: ");
            mprintf("Digitare una scelta:\n")
            mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
            conferma = input("Scelta: ");
        case 3 then
            scelta_calcolo();
        else
            conferma = input("Scelta: ");
        end
    end
//Fine script correzione dato
    Gamma_l = pc(Gamma_l_p); Gamma_l_m = abs(Gamma_l);
    Gamma_in = s11+((s12*s21*Gamma_l)/(1-(s22*Gamma_l)));
    format('v',6);
    mprintf("\nΓin = "); disp(cp(Gamma_in))
case 2 then //Γout
    Gamma_s_p = input("Inserire Γs in [modulo fase]: ");
//Correzione del dato
    mprintf("Digitare una scelta:\n")
    mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
    conferma = input("Scelta: ");
    while conferma,
        select(conferma)
        case 1 then
            break;
        case 2 then
            Gamma_s_p = input("Inserire Γs in [modulo fase]: ");
            mprintf("Digitare una scelta:\n")
            mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
            conferma = input("Scelta: ");
        case 3 then
            scelta_calcolo();
        else
            conferma = input("Scelta: ");
        end
    end
//Fine script correzione dato
    Gamma_s = pc(Gamma_s_p); Gamma_s_m = abs(Gamma_s);
    Gamma_out = s22+((s12*s21*Gamma_s)/(1-(s11*Gamma_s)));
    format('v',6);
    mprintf("\nΓout = "); disp(cp(Gamma_out))
case 3 then //Ga
    Gamma_s_p = input("Inserire Γs in [modulo fase]: ");
//Correzione del dato
    mprintf("Digitare una scelta:\n")
    mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
    conferma = input("Scelta: ");
    while conferma,
        select(conferma)
        case 1 then
            break;
        case 2 then
            Gamma_s_p = input("Inserire Γs in [modulo fase]: ");
            mprintf("Digitare una scelta:\n")
            mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
            conferma = input("Scelta: ");
        case 3 then
            scelta_calcolo();
        else
            conferma = input("Scelta: ");
        end
    end
//Fine script correzione dato
    Gamma_s = pc(Gamma_s_p); Gamma_s_m = abs(Gamma_s);
    Gamma_out = s22+((s12*s21*Gamma_s)/(1-(s11*Gamma_s)));
    Gamma_out_m = abs(Gamma_out);
    Ga = ((1-(Gamma_s_m)^2)*(s21m)^2)/((1-(Gamma_out_m)^2)*(abs(1-s11*Gamma_s))^2);
    GadB = 10*log10(Ga);
    format('v',6);
    mprintf("\nΓout = "); disp(cp(Gamma_out))
    mprintf("\nGa[dB] = "); disp(GadB)
case 4 then //Gp
    Gamma_l_p = input("Inserire Γl in [modulo fase]: ");
//Correzione del dato
    mprintf("Digitare una scelta:\n")
    mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
    conferma = input("Scelta: ");
    while conferma,
        select(conferma)
        case 1 then
            break;
        case 2 then
            Gamma_l_p = input("Inserire Γl in [modulo fase]: ");
            mprintf("Digitare una scelta:\n")
            mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
            conferma = input("Scelta: ");
        case 3 then
            scelta_calcolo();
        else
            conferma = input("Scelta: ");
        end
    end
//Fine script correzione dato
    Gamma_l = pc(Gamma_l_p); Gamma_l_m = abs(Gamma_l);
    Gamma_in = s11+((s12*s21*Gamma_l)/(1-s22*Gamma_l));
    Gp = ((s21m)^2*(1-Gamma_l_m^2))/((1-(abs(Gamma_in))^2)*(abs(1-s22*Gamma_l))^2);
    GpdB = 10*log10(Gp);
    format('v',6);
    mprintf("\nΓin = "); disp(cp(Gamma_in))
    mprintf("\nGp[dB] = "); disp(GpdB)
case 5 then //Gt
    Gamma_l_p = input("Inserire Γl in [modulo fase]: ");
//Correzione del dato
    mprintf("Digitare una scelta:\n")
    mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
    conferma = input("Scelta: ");
    while conferma,
        select(conferma)
        case 1 then
            break;
        case 2 then
            Gamma_l_p = input("Inserire Γl in [modulo fase]: ");
            mprintf("Digitare una scelta:\n")
            mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
            conferma = input("Scelta: ");
        case 3 then
            scelta_calcolo();
        else
            conferma = input("Scelta: ");
        end
    end
//Fine script correzione dato
    Gamma_s_p = input("Inserire Γs in [modulo fase]: ");
//Correzione del dato
    mprintf("Digitare una scelta:\n")
    mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
    conferma = input("Scelta: ");
    while conferma,
        select(conferma)
        case 1 then
            break;
        case 2 then
            Gamma_s_p = input("Inserire Γs in [modulo fase]: ");
            mprintf("Digitare una scelta:\n")
            mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
            conferma = input("Scelta: ");
        case 3 then
            scelta_calcolo();
        else
            conferma = input("Scelta: ");
        end
    end
//Fine script correzione dato
    Gamma_l = pc(Gamma_l_p); Gamma_l_m = abs(Gamma_l);
    Gamma_s = pc(Gamma_s_p); Gamma_s_m = abs(Gamma_s);
    Gamma_in = s11+((s12*s21*Gamma_l)/(1-s22*Gamma_l));
    Gt = ((1-Gamma_l_m^2)*s21m^2)*(1-Gamma_s_m^2)/((abs(1-Gamma_in*Gamma_s))^2*(abs(1-s22*Gamma_l))^2);
    GtdB = 10*log10(Gt);
    format('v',6);
    mprintf("\nΓin = "); disp(cp(Gamma_in))
    mprintf("\nGt[dB] = "); disp(GtdB)
case 6 then //Cerchio di stabilità in ingresso
    cs = (conj(s11-D*conj(s22)))/(s11m^2-Dm^2);
    rs = abs(s12*s21)/abs(Dm^2-s11m^2);
    format('v',6);
    mprintf("\ncs = "); disp(cp(cs))
    mprintf("\nrs = "); disp(rs)
case 7 then //Cerchio di stabilità in uscita
    cl = (conj(s22-D*conj(s11)))/(s22m^2-Dm^2);
    rl = abs(s12*s21)/abs(Dm^2-s22m^2);
    format('v',6);
    mprintf("\ncl = \n"); disp(cp(cl))
    mprintf("\nrl = \n"); disp(rl)
case 8 then //Cerchi equi-Ga
    GadB = input("Inserire il valore di Ga in dB: ");
//Correzione del dato
    mprintf("Digitare una scelta:\n")
    mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
    conferma = input("Scelta: ");
    while conferma,
        select(conferma)
        case 1 then
            break;
        case 2 then
            GadB = input("Inserire il valore di Ga in dB: ");
            mprintf("Digitare una scelta:\n")
            mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
            conferma = input("Scelta: ");
        case 3 then
            scelta_calcolo();
        else
            conferma = input("Scelta: ");
        end
    end
//Fine script correzione dato
    Ga = 10^(GadB/10);
    ga = Ga/(s21m^2);
    ca = ga*(conj(s11-D*conj(s22)))/(1+ga*(s11m^2-Dm^2));
    ra = (sqrt(1-2*K*ga*abs(s12*s21)+ga^2*(abs(s12*s21))^2))/abs(1+ga*(s11m^2-Dm^2));
    format('v',6);
    mprintf("\nga = "); disp(ga)
    mprintf("\nca = "); disp(cp(ca))
    mprintf("\nra = "); disp(ra)
case 9 then //Cerchi equi-Gp
    GpdB = input("Inserire il valore di Gp in dB: ")
//Correzione del dato
    mprintf("Digitare una scelta:\n")
    mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
    conferma = input("Scelta: ");
    while conferma,
        select(conferma)
        case 1 then
            break;
        case 2 then
            GpdB = input("Inserire il valore di Gp in dB: ");
            mprintf("Digitare una scelta:\n")
            mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
            conferma = input("Scelta: ");
        case 3 then
            scelta_calcolo();
        else
            conferma = input("Scelta: ");
        end
    end
//Fine script correzione dato
    Gp = 10^(GpdB/10);
    gp = Gp/(s21m^2);
    c_p = gp*(conj(s22-D*conj(s11)))/(1+gp*(s22m^2-Dm^2));
    rp = (sqrt(1-2*K*gp*abs(s12*s21)+gp^2*(abs(s12*s21))^2))/abs(1+gp*(s22m^2-Dm^2));
    format('v',6);
    mprintf("\ngp = "); disp(gp)
    mprintf("\ncp = "); disp(cp(c_p))
    mprintf("\nrp = "); disp(rp)
case 10 then //NF
    NFmindB = input("Inserire il valore di NFmin in dB: ");
//Correzione del dato
    mprintf("Digitare una scelta:\n")
    mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
    conferma = input("Scelta: ");
    while conferma,
        select(conferma)
        case 1 then
            break;
        case 2 then
            NFmindB = input("Inserire il valore di NFmin in dB: ");
            mprintf("Digitare una scelta:\n")
            mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
            conferma = input("Scelta: ");
        case 3 then
            scelta_calcolo();
        else
            conferma = input("Scelta: ");
        end
    end
//Fine script correzione dato
    NFmin = 10^(NFmindB/10);
    rn = input("Inserire il valore di rn: ");
//Correzione del dato
    mprintf("Digitare una scelta:\n")
    mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
    conferma = input("Scelta: ");
    while conferma,
        select(conferma)
        case 1 then
            break;
        case 2 then
            rn = input("Inserire il valore di rn: ");
            mprintf("Digitare una scelta:\n")
            mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
            conferma = input("Scelta: ");
        case 3 then
            scelta_calcolo();
        else
            conferma = input("Scelta: ");
        end
    end
//Fine script correzione dato
    Gamma_on_p = input("Inserire Γon in [modulo fase]: ");
//Correzione del dato
    mprintf("Digitare una scelta:\n")
    mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
    conferma = input("Scelta: ");
    while conferma,
        select(conferma)
        case 1 then
            break;
        case 2 then
            Gamma_on_p = input("Inserire Γon in [modulo fase]: ");
            mprintf("Digitare una scelta:\n")
            mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
            conferma = input("Scelta: ");
        case 3 then
            scelta_calcolo();
        else
            conferma = input("Scelta: ");
        end
    end
//Fine script correzione dato
    Gamma_s_p = input("Inserire Γs in [modulo fase]: ");
//Correzione del dato
    mprintf("Digitare una scelta:\n")
    mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
    conferma = input("Scelta: ");
    while conferma,
        select(conferma)
        case 1 then
            break;
        case 2 then
            Gamma_s_p = input("Inserire Γs in [modulo fase]: ");
            mprintf("Digitare una scelta:\n")
            mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
            conferma = input("Scelta: ");
        case 3 then
            scelta_calcolo();
        else
            conferma = input("Scelta: ");
        end
    end
//Fine script correzione dato
    Gamma_on = pc(Gamma_on_p); Gamma_on_m = abs(Gamma_on);
    Gamma_s = pc(Gamma_s_p); Gamma_s_m = abs(Gamma_s);
    NF = NFmin+(4*rn*(abs(Gamma_s-Gamma_on))^2)/((1-Gamma_s_m^2)*(abs(1+Gamma_on))^2);
    if (NF < 1) then 
        mprintf("Dati non corretti.")
        break
    end
    NFdB = 10*log10(NF);
    format('v',6);
    mprintf("\nNF[dB] = "); disp(NFdB)
case 11 then //Cerchi equi-noise
    NFmindB = input("Inserire il valore di NFmin in dB: ");
//Correzione del dato
    mprintf("Digitare una scelta:\n")
    mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
    conferma = input("Scelta: ");
    while conferma,
        select(conferma)
        case 1 then
            break;
        case 2 then
            NFmindB = input("Inserire il valore di NFmin in dB: ");
            mprintf("Digitare una scelta:\n")
            mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
            conferma = input("Scelta: ");
        case 3 then
            scelta_calcolo();
        else
            conferma = input("Scelta: ");
        end
    end
//Fine script correzione dato
    NFmin = 10^(NFmindB/10);
    rn = input("Inserire il valore di rn: ");
//Correzione del dato
    mprintf("Digitare una scelta:\n")
    mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
    conferma = input("Scelta: ");
    while conferma,
        select(conferma)
        case 1 then
            break;
        case 2 then
            rn = input("Inserire il valore di rn: ");
            mprintf("Digitare una scelta:\n")
            mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
            conferma = input("Scelta: ");
        case 3 then
            scelta_calcolo();
        else
            conferma = input("Scelta: ");
        end
    end
//Fine script correzione dato
    Gamma_on_p = input("Inserire Γon in [modulo fase]: ");
//Correzione del dato
    mprintf("Digitare una scelta:\n")
    mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
    conferma = input("Scelta: ");
    while conferma,
        select(conferma)
        case 1 then
            break;
        case 2 then
            Gamma_on_p = input("Inserire Γon in [modulo fase]: ");
            mprintf("Digitare una scelta:\n")
            mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
            conferma = input("Scelta: ");
        case 3 then
            scelta_calcolo();
        else
            conferma = input("Scelta: ");
        end
    end
//Fine script correzione dato
    NFdB = input("Inserire il valore di NF in dB: ");
//Correzione del dato
    mprintf("Digitare una scelta:\n")
    mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
    conferma = input("Scelta: ");
    while conferma,
        select(conferma)
        case 1 then
            break;
        case 2 then
            NFdB = input("Inserire il valore di NF in dB: ");
            mprintf("Digitare una scelta:\n")
            mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
            conferma = input("Scelta: ");
        case 3 then
            scelta_calcolo();
        else
            conferma = input("Scelta: ");
        end
    end
//Fine script correzione dato
    NF = 10^(NFdB/10);
    Gamma_on = pc(Gamma_on_p); Gamma_on_m = abs(Gamma_on);
    Ni = (NF-NFmin)*(abs(1+Gamma_on))^2/(4*rn);
    ci = Gamma_on/(1+Ni);
    ri2 = (Ni*(1+Ni)-Ni*Gamma_on_m^2)/(1+Ni)^2;
    if (ri2 < 0) then 
        mprintf("Cerchio non esistente.")
        break
    end
    ri = sqrt(ri2);
    format('v',6);
    mprintf("\nNi = "); disp(Ni)
    mprintf("\nci = "); disp(cp(ci))
    mprintf("\nri = "); disp(ri)
case 12 then //Cerchi equi-Gt
    GtdB = input("Inserire il valore di Gt in dB: ");
//Correzione del dato
    mprintf("Digitare una scelta:\n")
    mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
    conferma = input("Scelta: ");
    while conferma,
        select(conferma)
        case 1 then
            break;
        case 2 then
            GtdB = input("Inserire il valore di Gt in dB: ");
            mprintf("Digitare una scelta:\n")
            mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
            conferma = input("Scelta: ");
        case 3 then
            scelta_calcolo();
        else
            conferma = input("Scelta: ");
        end
    end
//Fine script correzione dato
    Gt = 10^(GtdB/10);
    Gamma_s_p = input("Inserire Γs in [modulo fase]: ");
//Correzione del dato
    mprintf("Digitare una scelta:\n")
    mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
    conferma = input("Scelta: ");
    while conferma,
        select(conferma)
        case 1 then
            break;
        case 2 then
            Gamma_s_p = input("Inserire Γs in [modulo fase]: ");
            mprintf("Digitare una scelta:\n")
            mprintf("1: conferma dato, 2: reinserisci dato, 3: ritorno al menù di scelta.\n")
            conferma = input("Scelta: ");
        case 3 then
            scelta_calcolo();
        else
            conferma = input("Scelta: ");
        end
    end
//Fine script correzione dato
    Gamma_s = pc(Gamma_s_p); Gamma_s_m = abs(Gamma_s);
    Gamma_out = s22+((s12*s21*Gamma_s)/(1-(s11*Gamma_s)));
    Gamma_out_m = abs(Gamma_out);
    gti = (Gt*(abs(1-s11*Gamma_s))^2)/((s21m)^2*(1-(Gamma_s_m)^2));
    ct = gti*conj(Gamma_out)/(1+gti*Gamma_out_m^2);
    rt2 = ((1-gti)/(1+gti*Gamma_out_m^2))+(Gamma_out_m^2*gti^2/(1+gti*Gamma_out_m^2)^2);
    if (rt2 < 0) then 
        mprintf("Cerchio non esistente.")
        break
        end
    rt = sqrt(rt2);
    format('v',6);
    mprintf("\nΓout = "); disp(cp(Gamma_out))
    mprintf("\ngti = "); disp(gti)
    mprintf("\nct = "); disp(cp(ct))
    mprintf("\nrt = "); disp(rt)
case 13 then //Terminazioni ottime
    B1 = 1-s22m^2+s11m^2-Dm^2;
    B2 = 1-s11m^2+s22m^2-Dm^2;
    C1 = s11-D*conj(s22);
    C2 = s22-D*conj(s11);
    C1_m = abs(C1); C2_m = abs(C2);
    Gamma_sopt_m = B1/(2*C1_m)-sqrt((B1^2-4*C1_m^2)/(4*C1_m^2));
    Gamma_sopt_f = phasemag(conj(C1));
    Gamma_lopt_m = B2/(2*C2_m)-sqrt((B2^2-4*C2_m^2)/(4*C2_m^2));
    Gamma_lopt_f = phasemag(conj(C2));
    Gamma_sopt = [Gamma_sopt_m Gamma_sopt_f];
    Gamma_lopt = [Gamma_lopt_m Gamma_lopt_f];
    format('v',6);
    mprintf("\nB1 = "); disp(B1)
    mprintf("\nB2 = "); disp(B2)
    mprintf("\nC1 = "); disp(cp(C1))
    mprintf("\nC2 = "); disp(cp(C2))
    mprintf("\nΓsopt = "); disp(Gamma_sopt)
    mprintf("\nΓlopt = "); disp(Gamma_lopt)
end
    mprintf("\n")
    mprintf("Si vuole calcolare altro? Scegliere il numero corrispondente:\n")
    mprintf(" 1: Γin\n")
    mprintf(" 2: Γout\n")
    mprintf(" 3: Ga\n")
    mprintf(" 4: Gp\n")
    mprintf(" 5: Gt\n")
    mprintf(" 6: Cerchio di stabilità in ingresso\n")
    mprintf(" 7: Cerchio di stabilità in uscita\n")
    mprintf(" 8: Cerchi equi-Ga (conoscendo Ga)\n")
    mprintf(" 9: Cerchi equi-Gp (conoscendo Gp)\n")
    mprintf("10: NF\n")
    mprintf("11: Cerchi equi-noise\n")
    mprintf("12: Cerchi equi-Gt (conoscendo Γs e Gt)\n")
    mprintf("13: Terminazioni ottime\n")
    mprintf("14: Uscita\n")
    mprintf("\n")
    scelta = input("Scelta: ");
end
abort
endfunction
scelta_calcolo()