/*transformata Karhunena-Loevego, http://neo.dmcs.p.lodz.pl/ptda/wuklay/wyklad_7.pdf*/
KLT (X) := block ([],
[w,k] : matrix_size(X),
load (descriptive),
f_mean : mean (transpose(X)),    /*wartość średnia wektora f*/
E_Mean : 1/k * (X . transpose(X)),
cov_f : E_Mean - (transpose(f_mean) . f_mean),    /*macierz kowariancji f*/
[lambda_vector,lambda] : eigens_by_jacobi(cov_f),    /*wartości własne i wektory własne macierzy kowariancji*/
T : lambda,    /*macierz transformacji*/
FF : T.X    /*transformata F*/
)$

iKLT (X) := block ([],
[w,k] : matrix_size(X),
load (descriptive),
f_mean : mean (transpose(X)),
E_Mean : 1/k * (X . transpose(X)),
cov_f : E_Mean - (transpose(f_mean) . f_mean),
[lambda_vector,lambda] : eigens_by_jacobi(cov_f),
T : lambda,
FF : T.X,
cov_FF= T * cov_f * transpose(T),    /*kowariancja transformaty F*/
f_reconstr=transpose(T) . FF        /*rekonstrukcja danych f*/
)$



A: read_matrix("C:\\matrix.txt");

cz_j_l : FALSE;
pom_cz_j_l : TRUE;

for i in A do 
(for j in i do    
(for a in A do
(for b in a do
(for x in A do
(for y in x do
(if pom_cz_j_l = TRUE then
(if (((j + b) + y) = (j + (b + y))) then cz_j_l : TRUE else (cz_j_l : FALSE, pom_cz_j_l : FALSE))))))));

print("Dzialanie okreslone na zbiorze A = ");
print(A);

if cz_j_l = TRUE then print("JEST LACZNE") else print("NIE JEST LACZNE");




ccprime(p):= /*generowanie licz wzglednie pierwszych*/
block([],
CC:[],
for i:2 thru p step 1 do 
block([],
if(gcd(p,i)=1) then CC:append(CC,[i])
),
return (first(random_permutation(CC)))
)$
RSA (p,q,m,t,d,n):= /*m to lista liczb, t - k kodowanie, d dekodowanie, d i n tylko do dekodowania*/
block([],
if(t="k") then 
block([],
n : p*q,
fn : (p-1)*(q-1),
d : ccprime(fn),
e : inv_mod(d,fn),
print("!!! KLUCZ => d=",d,",n=",n),
for i:1 step 1 thru length(m) do print(mod((m[i]^e),n))
) else 
block([],
for i:1 step 1 thru length(m) do print(mod((m[i]^d),n))
)
)$

/*RSA(3,11,[26,21,19],"k",0,0)*/
/*RSA(3,11,[14,21,7],"d",9,33)*/




//kodowanie pozycyjne//

decmodel(licz,model,alf,dl):=
block([],
temp:[0,1],
for i:1 thru dl step 1 do 
block([],
temp:dekoduj(licz,model,temp[1],temp[2],alf)
)
)$

dekoduj(licz,model,poc,kon,alf):=
block([],
sump:poc,
wsp:kon-poc,
for i:1 thru length(alf) step 1 do 
block(
if(i>1) then poc:sump,
sump:sump+(wsp*model[i]),
if(sump>licz) then block(print(alf[i]),i:length(alf))
),
return ([poc,sump])
)$


initmodel(tekst):=
block([],
temp:[0,1],
for i:1 thru length(tekst) step 1 do 
block([],
temp:sumpraw(tekst[i],tekst,temp[1],temp[2])
),
print("Alfabet:",unique(tekst)),
print("Dlugosc:",length(tekst)),
model:[],
for j:1 thru length(unique(tekst)) do model:append(model,[ile(unique(tekst)[j],tekst)]),
print(model),
print("Liczba z akresu ",temp)
)$1$

sumpraw(znak,lista,poc,kon):=
block([],
sump:poc,
wsp:kon-poc,
for i:1 thru ktory(znak,unique(lista)) step 1 do 
block(
if(i>1) then poc:sump,
sump:sump+(wsp*ile(unique(lista)[i],(lista)))
),
return ([poc,sump])
)$

ktory(znak,lista):=
block([],
ktu:0,
for i:1 thru length(lista) step 1 do 
if((znak=lista[i]) and (ktu=0)) then ktu:i,
return (ktu)
)$

ile(znak,lista):=
block([],
wys:0,
for i:1 thru length(lista) step 1 do 
if(lista[i]=znak) then wys:wys+1,
return (wys/length(lista))
)$




////

ile(x,y):=/*ile daje reszt*/
block([],
Z:[],
for i:1 thru totient(y) step 1 do Z:append(Z,[mod((x^i),y)]),
return(length(unique(Z)))
)$
cclass(p):= /*generowanie licz wzglednie pierwszych*/
block([],
CC:[],
for i:1 thru p step 1 do 
block([],
if(gcd(p,i)=1) then CC:append(CC,[i])
)
)$
genp(p):= /*generowanie pierwiastka pierwotnego*/
block([],
L:[],
cclass(p),
L:CC,
T:make_array(fixnum,length((L))),
T:unique(L),
W:[],
for j:1 thru length((L)) step 1 do 
if(ile(L[j],p)=totient(p)) then W:append(W,[L[j]]),
return (first(random_permutation(W)))
)$
DiffieHellman(p,a,b) :=/*algorytm Difie...*/
block([],
g:genp(p),
print("Wygenerowane g=",g),
I:(mod((g^a),p)),
print("Klucz publiczny I=",I),
J:(mod((g^b),p)),
print("Klucz publiczny J",J),
K1:(mod((J^a),p)),
print("K1=",K1),
K2:(mod((I^b),p)),
print("K2=",K2)
)$
\



ccprime(p):= /*generowanie licz wzglednie pierwszych*/
block([],
CC:[],
for i:2 thru p step 1 do 
block([],
if(gcd(p,i)=1) then CC:append(CC,[i])
),
return (first(random_permutation(CC)))
)$



///////////////////////////////////PEREŁKA !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//////////////////////////////////////
LZW KURWA MAC !!!!! =]]]]]]]]]


#text := ReadString("test.txt");
text :="abccd_abccd_acd_acd_acd_";
text_bez1 := Substring(text,2,Size(text)-1);
n:=255;
czy_jest := FALSE;
poz:=1;
poz2:=0;
 
#krok1 - Wypełnij słownik alfabetem źródła informacji.
slownik:=[1..255];
for i in slownik 
    do 
    slownik[i]:=CodeToString(i); 
    od;
    

#krok2 - c := pierwszy symbol wejściowy
c := text[1];
wynik := []; 
wynik2 :=[];


#krok3 - Dopóki są dane na wejściu: 
 
for s in text_bez1
    do
        for tmp in slownik
            do
                if (tmp=(c+s)) 
                    then czy_jest:=TRUE; 
                fi;
            od;
        if(czy_jest=TRUE)
            then c:=c+s;
            #Print("\nC+s="+c);
            czy_jest:=FALSE;
            #Print("Wartosc jest w tablicy\n");
        else 
            czy_jest:=FALSE;
            #Print("\nC="+c);
            #Append(wynik,List(c));
            #if (StringToCode(c)<255) then Append_(wynik,List(c+" ")) ; fi;
                       # for licz1 in slownik 
                        # do 
                                #if ( licz1 = c ) then 
                                    Add_(wynik,List(c)) ;
                                    #Add_(wynik2,c);
                                    #Print("\npoz1="+IntegerToString(poz2));
                                    #Print("jaka pozycja:"+IntegerToString(poz2));
                                    
                                #  fi; 
                                
                            #poz2:=poz2+1;
                       # od;
            poz:=1;
            poz2:=1;
            Add_(slownik,c+s);
            #Print("\nDodaje:"+(c+s));
            n:=n+1;
            c:=s;
            
        fi;
    od;
    #Append(wynik,List(c));

                         for licz1 in slownik 
                            do 
                                poz:=poz+1;
                                if(licz1=c) then 
                                    Add_(wynik,List(c)) ;
                                    #Add_(wynik2,c);
                                    #Print("\npoz2="+IntegerToString(poz));
                                    #Print("\nC="+c);
                                fi;
                            od;
                        
    #slownik;
    #wynik;
    poz3:=1;
    wyn:=[];
    for el in wynik
    do
    poz3:=1;
                         for licz1 in slownik 
                         do 
                                 if ( licz1 = el ) then 
                                    Append_(wyn,List(poz3)) ;
                                    #Add_(wynik2,c);
                                    #Print("\nPoz="+IntegerToString(poz3));
                                    #Print("jaka pozycja:"+IntegerToString(poz2));
                                    
                                  fi; 
                                
                             poz3:=poz3+1;
                        od;
    od;
    #slownik;
    wyn;
    
    
    
    
    
    # teraz dekompresja
    
    # Krok 1 - wypelnij slownik alfabetem zrodla informacji
    
    slownikDek:=[1..255];
    for i in slownikDek 
        do 
        slownikDek[i]:=CodeToString(i); 
        od;
    
    # Krok 2 - pk := pierwszy kod skompresowanych danych
    
    pk := wyn[1];
    
    # Krok 3 - Wypisz na wyjście ciąg związany z kodem pk, tj. słownikDek[pk]
    
    wynikDek := [slownikDek[pk]];
    czy_jest := FALSE;
    
    # Krok 4 - Dopóki są jeszcze jakieś słowa kodu: 
    # Wczytaj kod k
    # pc := słownik[pk] - ciąg skojarzony z poprzednim kodem
    # Jeśli słowo k jest w słowniku, dodaj do słownika ciąg (pc + pierwszy symbol ciągu słownik[k]), a na wyjście wypisz cały ciąg słownik[k].
    # W przeciwnym razie (przypadek scscs) dodaj do słownika ciąg (pc + pierwszy symbol pc) i tenże ciąg wypisz na wyjście.
    # pk := k
    #text := "abccd_abccd_acd_acd_acd_";
    
    Remove_(wyn,1);
    for el in wyn
    do
        k:=el;
        if (el>1) then
            pc := slownikDek[pk];
            
            #Print("\nK="+IntegerToString(k));
            #Print(slownikDek);
            #size:=Size(slownikDek);
            for tmp in slownikDek
                do
                    if (tmp=slownikDek[k]) 
                        then czy_jest:=TRUE; 
                        #Print("\nJest="+tmp+" - "+slownikDek[k]);
                
                        else 
                        #Print("\nNie ma");
                        ;
                    fi;
                    #pozDek:=pozDek+1;
                od;
        
            #Print(czy_jest);
            if(czy_jest=TRUE)
                then 
                
                #Print("\nPc="+pc+" slownikDek[k][1]="+slownikDek[k][1]);
                Add_(slownikDek,pc+slownikDek[k][1]);
                Add_(wynikDek,slownikDek[k]);
                czy_jest:=FALSE;
                #Print("Wartosc jest w tablicy\n");
            else 
                czy_jest:=FALSE;
                #Print("\nPc+pc[1]="+pc+pc[1]);
                Add_(slownikDek,pc+pc[1]);
                Add_(wynikDek,pc);
            fi;
            pk:=k;
        fi;
    od;
        
    #    wynikDek;
        wynikKon:=[];
        for el in wynikDek
            do
            Append_(wynikKon,List(el));
            od;
 wynikKon;