Localize file www.TrSek.com/c/booldif/prac_ndf.c//************************************************************************//
// PRAC_NDF.C //
// Sluzi pre standartne operacie s Boolovskymi diferenciami, prevody //
// nasobicky atd. //
// //
// PS: Pocas toho ako som robil tuto DP (mimochodom druhu, raz som letel //
// zo statnic) som sa rozisiel s priatelkou, dostal povolavaci rozkaz, //
// zacal ako prvak na hutnickej a samozrejme vela inych o ktorych by som //
// mohol napisat, preto ak lustis tieto zdrojaky pomysli na to a nenadavaj//
// dakujem TRSEK 25.8.1997 //
//************************************************************************//
// Nieco v neporiadku napr. strcpy( vysl, "" ); dava do vysl="a" - hahaha //
//************************************************************************//
// Vyhrad miesto pre dalsie NDF //
// i: premenna zapis_NDF o:chyba malo pamate 25.8.1997 //
//************************************************************************//
int dalsie_NDF (zapis_NDF *h_fnc, int velkost )
{
int i;
h_fnc->poc_NDF++;
if ( h_fnc->poc_NDF > max_NDF ) return(12);
if( velkost == 0 ) velkost = h_fnc->pv_NDF; // taaake velke bude pole
v_NDF = (char *) farmalloc(velkost + 1 );
min_mem = min_mem + velkost + 8 ;
pamet(); // ukaz ako si na tom z pametou
if ( v_NDF == NULL ) return(11);
for (i=0; i<velkost; i++) v_NDF[i] = nic; // zapis je vyplneny prazdnymi polozkami
v_NDF[i]='\0'; // aby som nieco videl, lebo inac tam boli
// take bludy asi Borland Corp atd.
h_fnc->adept[ h_fnc->poc_NDF ] =0; // aj adept na vyhodenie ma nulu
h_fnc->t_vodic[ h_fnc->poc_NDF ] =0; // vzhladom na ktory t (a,b,c) zistujem chybu
h_fnc->t_chyba[ h_fnc->poc_NDF ] =0; // chyba je 0 alebo 1
return(0);
}
//************************************************************************//
// Prevedie do vnutorneho zapisu s ktorym potom pracujem //
// i:zapis_NDF o:chyba malo pamate 25.8.1997 //
//************************************************************************//
int vytvor_formu(zapis_NDF *h_fnc,char vstr[])
{
int i=0,err=0;
// prax ma naucila v BC si clovek nieje nicim isty takze zicher je zicher
znuluj(h_fnc,1);
// zisti pocet premennych
for (i=0 ; i<=strlen(vstr) ; i++)
{
if ( je_znak( vstr[i], jclen ) == TRUE ) // pre male a..z
if ( (vstr[i]-'a') >= h_fnc->pv_NDF ) h_fnc->pv_NDF=vstr[i]-'a'+1;
if ( je_znak( vstr[i], nclen ) == TRUE ) // pre velke A..Z
if ( (vstr[i]-224) >= h_fnc->pv_NDF ) h_fnc->pv_NDF=vstr[i]-224+1;
}
if ( strlen(vstr) == 0 ) return(0); // aj to sa stava !?
// vyhrad miesto pre zapis prveho
if ( (err=dalsie_NDF(h_fnc,0)) == 1) return(err);
// rozsekaj do vnutorneho zapisu
i=0;
while (i < strlen(vstr)) {
// neake nasobenie 0 ma za nasledok zrusenie clena
if ( vstr[i] == vstup_0[0] ) h_fnc->adept[ h_fnc->poc_NDF ]=1;
if ( je_znak( vstr[i], jclen ) == TRUE ) { // pre male a..z chyba kontrola na viacnasobny vyskyt jednoho prvku !!!
if (( v_NDF[ vstr[i] - 'a' ] == nclen ) && (h_fnc->adept[ h_fnc->poc_NDF ] == 0 ))
h_fnc->adept[ h_fnc->poc_NDF ] =1;
else v_NDF [ vstr[i] - 'a' ] = jclen;
}
else {
if ( je_znak( vstr[i], nclen ) == TRUE ) { // pre velke A..Z chyba kontrola na viacnasobny vyskyt jednoho prvku !!!
if (( v_NDF[ vstr[i] - 224 ] == jclen ) && (h_fnc->adept[ h_fnc->poc_NDF ] == 0 ))
h_fnc->adept[ h_fnc->poc_NDF ] =1;
else v_NDF[ vstr[i] - 224 ] = nclen;
}
else
if( je_znak( vstr[i], nic ) == FALSE )// vyhrad miesto pre zapis prveho
if ( (err=dalsie_NDF(h_fnc,0)) == 1) return(err);
}
i++;
}
return(0);
}
//************************************************************************//
// Vyhodi vsetky NDF, ktore su adeptami na vyhodenie //
// 25.8.1997 //
//************************************************************************//
void von_adept(zapis_NDF *h_fnc)
{
int x,y; // devky
// ak sa nachadza clen 0000000 teda nema ani jclen ani jeho negaciu
// ale ak sa nachadza nic tak az take nic to nieje ( skus pre f=a )
for (x=1; x<=h_fnc->poc_NDF; x++)
// spravit z neho adepta ???
if( ( h_fnc->adept[x] == 0 ) && ( h_fnc->pv_NDF > 0 ) ) {
h_fnc->adept[x]=1;
for (y=0; y<h_fnc->pv_NDF; y++)
if(( h_fnc->pNDF[x][y] == jclen ) || ( h_fnc->pNDF[x][y] == nclen ))
h_fnc->adept[x]=0;
}
//************************************************************************//
// Zistuje vsetky pohltenia, ktore sa nachadzaju //
// ak ich ma tak oznaci adept[i] na vyhodenie 25.8.1997 //
//************************************************************************//
void pohltenie(zapis_NDF *h_fnc)
{
int i,x,y,adp_i,adp_y;
int n_clen_i,n_clen_y; // su iba n-cleny ??
for (i=1; i<=h_fnc->poc_NDF-1; i++)
for (y=i+1; y<=h_fnc->poc_NDF; y++)
{
adp_i=0;adp_y=0;
// ci nahodou nieje len zo ziadnych clenov vtedy pohlti akykolvek iny clen
n_clen_i=1;n_clen_y=1;
for (x=0; x<h_fnc->pv_NDF; x++)
{
if ( h_fnc->pNDF[i][x] != nic ) n_clen_i=0;
if ( h_fnc->pNDF[y][x] != nic ) n_clen_y=0;
// zatial pohlcuje
if (( h_fnc->pNDF[i] [x] == nic ) && ( h_fnc->pNDF[y] [x] != nic )) adp_y=adp_y | 1 ;
if (( h_fnc->pNDF[y] [x] == nic ) && ( h_fnc->pNDF[i] [x] != nic )) adp_i=adp_i | 1 ;
// toto uz nie ma rozdielne
if ( (( h_fnc->pNDF[i] [x] == nclen ) && ( h_fnc->pNDF[y] [x] == jclen )) ||
(( h_fnc->pNDF[y] [x] == nclen ) && ( h_fnc->pNDF[i] [x] == jclen )) )
{
adp_i=adp_i | 2 ;
adp_y=adp_y | 2 ;
}
}
// su navlas podobne
if ((n_clen_i == 0) && ( adp_i == 0 ) && ( adp_y == 0 ))
h_fnc->adept[i]=1;
// je cas vyhodnotit
if ((n_clen_i == 0) && ( adp_i == 1 ) && ( adp_y != 1 ))
h_fnc->adept[i]=1;
if ((n_clen_y == 0) && ( adp_y == 1 ) && ( adp_i != 1 ))
h_fnc->adept[y]=1;
}
}
//************************************************************************//
// Filter pre dalsie spracovanie vyrazu //
// 25.8.1997 //
//************************************************************************//
int filter( char vstr[] )
{
int i=0,err=0;
while( i < strlen( vstr ) )
if (vstr[i] == ' ') strdel(vstr,i);
else i++;
for (i=0; i<strlen(vstr); i++) {
if (vstr[i]== '(') err++;
if (vstr[i]== ')') err--;
}
if ( err!=0 ) return(13);
int odstran_zatvorky( char vstr[], int alge )
{
int i,ii;
int b_nec,lava; // b_nec je to nasobenec ?? lava udava pocet lavych zatvoriek
char nasobitel[ max_ret ]; // obsah 1 zatvorky
char nasobenec[ max_ret ]; // obsah 2 zatvorky s cim idem nasobit
char vysl[ max_ret ]; // vysledny produkt
if ( ma_zatv(vstr) != 1 ) return (0);
pamet();
do { // budeme opakovat pokial ziadna zatvorka
if ( vstr[0] == '(' ) // taka lahodka, teraz mozme zacat
{ // ta co je posledna je jeho ??? aby to nebolo (a+c)(d+a)
lava=1;i=1;
while (( lava>0 ) && ( i < strlen( vstr ) )) {
if ( vstr[i] == '(' ) lava++;
if ( vstr[i] == ')' ) lava--;
i++;
}
if ( i == strlen( vstr )) {
strdel( vstr, 0 );
strdel( vstr, strlen(vstr)-1 );
}
}
nasobitel[0]='\0';nasobenec[0]='\0';
b_nec=0;
} // end if(lava==0
// je to OK daj do vysledku
if ((( vstr[i] == '+' ) && ( lava == 0 ) && ( b_nec == 0 )) ||
( i == strlen( vstr )))
{
odstran_zatvorky( nasobitel, 1 ); // zavola rekurzivne
for (ii=0; ii<strlen(nasobitel); ii++)
strchar( vysl, nasobitel[ii] );
nasobitel[0]='\0';
}
if ( b_nec == 0 ) strchar( nasobitel, vstr[i] ); // kopiruje do nasobitel pre pripad nasobenia
else strchar( nasobenec, vstr[i] ); // do nasobenec to uz je iste nasobenie
// hura idem roznasobovat
if ( vstr[i] == ')' ) {
lava--;
if (( lava == 0 ) && ( b_nec == 1 ))
{
odstran_zatvorky( nasobitel, 1 ); // zavola rekurzivne, co ak nieco obsahuje ???
odstran_zatvorky( nasobenec, 1 ); // zavola rekurzivne, co ak nieco obsahuje ???
nasobitel[0]='\0';nasobenec[0]='\0';
b_nec=0;
} // end if(lava==1
// odteraz kopirujem do nasobitel
// ked vydim to vstr[i+1] ako keby mi zuby trhalo
if (( lava == 0 ) &&
(( vstr[i+1] != '+' ) || ( strlen( vstr ) <= i+1 ))) b_nec=1;
} // end if(vstr[i]==')'
} // end for(i=0;
// to von blbosti odstranuje cleny ako aA atd, proste blbosti
strcpy( vstr, vysl ); // toto je spravny vysledok
vysl[0]='\0';
} while ( ma_zatv( vstr ) == 1 );
//************************************************************************//
// Roznasobi dva cleny (zatvorky) v NDF strukture //
// pozor rusi obsah prveho z nich 2.9.1997 //
//************************************************************************//
char *nasob_NDF( char nc[], char nt[], int alge )
{
char vysln[max_ret];
char pom_v[max_ret]; // pomocna
int pc=0,pt=0; // pokial roznasobil nc, nt
int ic=0,it=0; // devky premenne
// z toho ma tiez boli brucho
if ( strlen(nc) == 0 ) return(nt);
if ( strlen(nt) == 0 ) return(nc);
pom_v[0]='\0';
vysln[0]='\0'; // obcas hadzalo vysledky az strach
// clovek aby stale na nieco myslel
while ( pc <= strlen(nc) ) {
pt=0;
while ( pt <= strlen(nt) ) {
//************************************************************************//
// Prevedie retazec do NDF struktury rozne poupravuje pospekuluje //
// este ze funguje, vyp_sk ak chcem vnutit iny text 2.9.1997 //
//************************************************************************//
int diferencie( int medzi_v )
{
int i,x,y; // devky
int zx,zy;
int prem; // aka substituovana premenna sa zhoduje
int a_rezim=0; // opustit rezim a prejst do automatickeho ???
int p_chyb=0,p_pokusov=0; // pocet chyb, pocet pokusov
char subst[max_ret]; // ake cleny som substioval
char pom[max_ret]; // pomocna
char ret_f2[ max_ret ]; // musim zalohovat retazec
zapis_NDF pom_f; // pomocna f(NDF)
p_stat=0; min_mem=0; // znulujeme
zarad_stat( "Prevod do NDF tvaru",0 ); // dame do statistickych udajov
tlac_retazec(zx+1,zy+2,atributy[20]," Vykon vam deriv cie podŒa premenn˜ch ");
del_tmp( TmpSubor[2] ); // kto maze ten ide
del_tmp( TmpSubor[3] ); // ak spustim znova aby neboli duplicitne vysledky
znuluj( &subst_NDF,0 ); // nech tam niesu haus-numera
znuluj( &pom_f,0 ); // nech tam niesu haus-numera
znuluj( &slovnik,1 ); // slovnik znulovany
init_jadro(); // zicher je zicher
del_tmp( TmpSubor[1] ); // ak spustim dvkrat, aby kvakrat nebolo zapisane
filter( ret_f );
subst[0]='\0';
strcpy( ret_f2, ret_f ); // odzalohujem, lebo nahrad_vetvy
ret_do_NDF( ret_f2, &h_fnc, TmpSubor[0]); // retazec do NDF
zarad_stat( "",1 );
zac_subst = h_fnc.pv_NDF + 1; // od tejto prem zacinaju substitucie
// toto nech je predtym ako ulozi slovnik vzdy !!!
slovnik.pv_NDF = h_fnc.pv_NDF + 1; // bude mat tolko premennych ako h_fnc +
// vystup zapisujem ako dalsiu potrebuje zapis_slovnik
uloz_NDF( &h_fnc, " Vstupn funkcia\n f= ",TmpSubor[1]);// zobrazi NDF strukturu
index[0]=' ';index[1]=' ';
// derivacia podla vstupnych premennych
// derivacie bez vnutornych vstupov ???
if( medzi_v ) a_rezim=27;
for ( i=0; i<h_fnc.pv_NDF; i++ ) { // spravi komplet diferenciu podla i
index[0] = 'a'+i; index[1] = ' ';
difer_podla( &h_fnc, i, subst, &p_chyb, &p_pokusov, &a_rezim );
}
// derivacie bez vnutornych vstupov ???
if( medzi_v ) a_rezim=27;
else a_rezim=0;
tlac_retazec(zx+1,zy+2,atributy[20]," Deriv cie pre vetviace sa prim rne vstupy");
// aby vypisal, ze substioval, lebo testuje ci ret je vecsi ako 1 znak
dalsie_NDF( &subst_NDF, 1 );
subst_NDF.pv_NDF=1;
strcpy( pom, ret_f );
filter(pom);
for( x=0; x<h_fnc.pv_NDF; x++ )
// zistim ci ma viac ako jeden vstup (ci sa vobec vetvy)
if( kolko_vetiev( pom, x ) > 1 ) {
prem=0;
for( y=0; y< strlen( pom ); y++ )
if(( pom[y] == 'a' + x ) || ( pom[y] == 224 + x ))
{ // vetvy od primarneho vstupu
prem++;
subst_NDF.t_chyba[ subst_NDF.poc_NDF ] = prem;
subst_NDF.adept[ subst_NDF.poc_NDF ] = 'a' + x;
index[0]='a' + x;
index[1]='0' + subst_NDF.t_chyba[ subst_NDF.poc_NDF ];
// bude mat nazov ako nasledujuci dalsi
pom[y] = 'a'+zac_subst -1;
subst_NDF.pNDF[subst_NDF.poc_NDF ][0] = 'a' + x;
// to co som substioval
// az sa pokusis pouzit ret_f2 dobre si to rozmysli !!!
strcpy( ret_f2, ret_f );
for( i=strlen(ret_f)+1; i>y+1; i-- ) ret_f[i]=ret_f[i-1];
ret_f[y+1]='0'+prem;
// sprav NDF
ret_do_NDF( pom, &pom_f, TmpSubor[0] );
// vsetky okrem mojej
difer_podla( &pom_f, zac_subst-1, subst_NDF.pNDF[subst_NDF.poc_NDF ],
&p_chyb, &p_pokusov, &a_rezim );
// spat ako bolo
strcpy( ret_f, ret_f2 );
strcpy( pom, ret_f2 );
}
}
// poriadok v pamati
znuluj( &pom_f, 1 );
a_rezim=0;
if( medzi_v ) { // derivacie aj pre vnutorne vstupy ???
tlac_retazec(zx+1,zy+2,atributy[20]," Vykon vam deriv cie pre vn£torn‚ vodi‡e ");
// teraz hladame pre vnutorne vodice
strcpy( ret_f2, ret_f ); // obnovy tak ako bol vstup
znuluj( &subst_NDF, 1 ); // poriadok robi kamaratov s pamatou
while ( nahrad_vetvy( ret_f2, subst, &subst_NDF ) > 0 ) ;
index[0]=' ';index[1]=' '; // znuluj index
for( i = 1; i < subst_NDF.poc_NDF; i++ ) {
// to co tu mam zhoduje sa z niecim ???
prem = kontr_subst( subst_NDF.pNDF[i], i+1, subst_NDF.poc_NDF );
// nasiel som vetviaci sa vodic !!!
if( prem != 0 ) {
// znamena to, ze nasiel medzivoce
medzi_v=0;
// pre tento som nerobil diferenciu
if( subst_NDF.t_chyba[i] == 0 ) {
subst_NDF.t_chyba[i] = 1; // dostane oznacenie 1
// ma taky index napr. e1, e2
index[0]= subst_NDF.adept[i];
index[1]='0' + subst_NDF.t_chyba[i];
// retazec, ktory vznikol po substitucii do NDF
strcpy( pom, subst_NDF.pSubst[i] );
// vsetky okrem mojej
substitucie( pom, subst_NDF.adept[i] );
// nech vypisuje co substioval
strcpy( ret_f2, ret_f );
strcpy( ret_f, pom );
ret_do_NDF( pom, &h_fnc, TmpSubor[0] );
// spravi komplet diferenciu podla substituovaneho
strcpy( pom, subst_NDF.pNDF[i] );
difer_podla( &h_fnc, subst_NDF.adept[i] - 'a', pom, &p_chyb, &p_pokusov, &a_rezim );
strcpy( ret_f, ret_f2 );
}
// dostane oznacenie +1
subst_NDF.t_chyba[ prem - zac_subst +1 ] = subst_NDF.t_chyba[i]+1;
// ma taky index napr. e1, e2
index[1]='0'+subst_NDF.t_chyba[ prem - zac_subst +1 ];
// retazec, ktory vznikol po substitucii do NDF
strcpy( pom, subst_NDF.pSubst[ prem - zac_subst +1 ] );
// vsetky okrem mojej
substitucie( pom, subst_NDF.adept[ prem - zac_subst +1 ] );
// aby spravne zobrazoval potom !!!
for( y=0; y < strlen(pom); y++ )
if( pom[y] == subst_NDF.adept[ prem - zac_subst +1 ] )
pom[y] = subst_NDF.adept[i];
// dostane meno ako ta s ktorou sa podoba
subst_NDF.adept[ prem - zac_subst +1 ] = subst_NDF.adept[i];
// taky akoze test, ci nahodov neodpoveda vzdy 0, alebo I
jed_odpoved( pom_f );
// zlom !!! tento riadok je magicky uz sa mi o nom sniva
ret_do_NDF( pom_f, &deriv_f, TmpSubor[0] ); // uprav do prijatelneho tvaru
uloz_NDF( &deriv_f, "\n dF = ",TmpSubor[3]);
// ulozi slovnik poruch pre t0( prem), alebo t1 neg( prem )
uloz_slovnik( pom_f, podla_p, &h_fnc, TmpSubor[3], subst );
// dame do statistickych udajov
zarad_stat( "",1 );
// je Preverovaci rezim tak zobrazuj
if ( (( Rezim == VYUK ) || ( Rezim == PREV )) && ( *a_rezim != ESC ) ) {
zobraz_tmp5();
(*p_pokusov)++; // dalsi pokus
*a_rezim=prever_uziv( &deriv_f, p_chyb ); // over jeho vedomosti
zatvor_okno();
}
if ( ( Rezim == DEMO ) && ( *a_rezim != ESC ) ) { // ak je DEMO tak zobrazuj
// po zobrazeni zmaze !!!
*a_rezim=zobraz_tmp4();
}
// zobrazi NDF strukturu do NDF.TMP
uloz_NDF( &deriv_f, pom,TmpSubor[1]);
// ulozi do vystupneho suboru
if ( Vystup == TLC ) { // ak tlaciaren
anti_ascii( TmpSubor[3] , TmpSubor[5] );
sprintf( pom_f,"type %s%s > prn", temp, TmpSubor[5] );
system( pom_f );
}
if ( Vystup == SUB ) { // ak ukladat do suboru
anti_ascii( TmpSubor[3], TmpSubor[5] );
sprintf( pom_f,"if exist %s%s type %s%s >> %s", temp, TmpSubor[5], temp, TmpSubor[5], TmpSubor[4] );
system( pom_f );
}
// ak spustim znova aby neboli duplicitne vysledky
del_tmp( TmpSubor[3] );
del_tmp( TmpSubor[2] );
// vycistime pamat
znuluj(&K0,1); znuluj(&K1,1); znuluj(&K,1);
// aj toto je na stabilitu, lebo ked je cista pamat aj hlava je cista
return(0);
}
//************************************************************************//
// KONTR_SUBST kontrola ci retazec subst sa nachadza v subst_NDF //
// i:... o: 0-nenasiel som !=0 ako sa vola subst. premenna 30.10.1997 //
// toto este prepracovat !!!
//************************************************************************//
int kontr_subst( char subst[], int odkial, int pokial )
{
int x,y,i; // devky
int prem=0; // toto je premenna, ktora ma dvojca
zapis_NDF NDF1,NDF2; // nahadzem do NDF1, NDF2 porovnam
char ret_NDF1[ max_ret ], ret_NDF2[ max_ret ];
// maju aspon rovnaky pocet NDF ?
if(( NDF1.pv_NDF == NDF2.pv_NDF ) && ( NDF1.poc_NDF == NDF2.poc_NDF ))
{ // grupak, kazdy s kazdym
for( x=1; x <= NDF1.poc_NDF; x++ )
for( y=1; y <= NDF2.poc_NDF; y++ )
if(( strcmp( NDF1.pNDF[x], NDF2.pNDF[y] ) == 0 ) &&
( NDF1.t_vodic[x] == 0 ) && ( NDF2.t_vodic[y] == 0 ))
{// sedi rovnaju sa, a este som ich nezlucil
NDF1.t_vodic[x] = 1;
NDF2.t_vodic[y] = 1;
}
// tak je to ona, alebo nie ???
prem = subst_NDF.adept[i] - 'a' +1 ;
for( x=1; x <= NDF1.poc_NDF; x++ )
if( NDF1.t_vodic[x] == 0 ) prem=0; // nie je to ono
} // end if(( NDF1.pv_NDF == NDF2.pv_NDF ...
znuluj( &NDF2, 1 );
// nasiel som ideme prec
if( prem != 0 ) {
znuluj( &NDF1, 1 );
return( prem );
}
} // end for( i=0; i < subst_NDF.poc_NDF; i++ )
// nenasiel som
znuluj( &NDF1, 1 );
return(0);
}
//************************************************************************//
// Zisti ako by sa mala spravat funkcia ak je vsetko OK //
// i:vektor(00I0II) o:vstup_0 "0" vstup_1 "1" 25.10.1997 //
//************************************************************************//
char odpoved_f( char v_vektor[], zapis_NDF *h_fnc )
{
int x,y; // len tak
char j_ndf,c_ndf=0; // hodnota jednoho ndf, celej f-cie
//************************************************************************//
// NAHRAD_VETVY hlada podobne a nahrdzuje ich inym //
// napr. abc+d(abc+de)= f+d(f+de) //
// i:z akeho ret, co som substioval, slovnik substucii //
// o:ake ma cislo novo vytvoreny vodic 30.10.1997 //
//************************************************************************//
int nahrad_vetvy( char ret_f[], char subst[], zapis_NDF *subst_NDF )
{
int i,y,err; // devky
int lav_z=0,prav_z=0; // lava, prava zatvorka pre subst a+b
int ma_subst=0; // mam uz nejake subst
char vysl[ max_ret ]; // vysledok
for( y=0; y < strlen( subst ); y++ ) s_NDF[y] = subst[y];
// takto sa bude volat nova premenna
subst_NDF->adept[ subst_NDF->poc_NDF ] = 'a' + zac_subst + subst_NDF->poc_NDF - 2 ;
// takto to uz dalej nepojde mam malo pismen abecedy na vetvenia
if( subst_NDF->adept[ subst_NDF->poc_NDF ] >= 'z' )
{
chybove_okno(chyba[26] );
return(0);
}
// vyrobil som novu premennu
strchar( vysl, 'a' + zac_subst + subst_NDF->poc_NDF - 2 );
subst[0]='\0'; // bratku nazavadzaj, my uz mame ine zaujmy
ma_subst=1; // uz je to tady !!!
}
// kopirujem kam treba
if( je_znak( ret_f[i], nic ) == FALSE ) {
strcat ( vysl, subst );
strchar( vysl, ret_f[i] );
subst[0]='\0';
}
else strchar( subst, ret_f[i] );
subst[0]='\0'; // znulujeme odlozene v subst_NDF
if( ma_subst )
{
strchar( subst, 'a' + zac_subst + subst_NDF->poc_NDF - 2 );
strcpy( ret_f, vysl ); // tuto je vysledok mojho snazenia
pSubst_NDF = (char *) farmalloc( strlen( vysl ) + 1 );// sprav mu miesto
min_mem = min_mem + strlen( vysl ) + 8;
pamet(); // ukaz ako si na tom z pametou
if ( pSubst_NDF == NULL ) { // malo pamete
chybove_okno(chyba[err] );
return(0);
}
for( y=0; y <= strlen( vysl ); y++ ) pSubst_NDF[y] = vysl[y];
return( zac_subst + subst_NDF->poc_NDF - 1 ); // poslem aku premennu som vyrobil
} // pozor ak tu return nebude radikalne meni pointu
//***********************************************************************//
// teraz taka lahodka premenne budu typu "or" subst (a+b+c) = d //
//***********************************************************************//
subst[0]='\0'; vysl[0]='\0';
// po lavu zatvorku do vysl
for( i = 0; i < lav_z; i++ ) strchar( vysl, ret_f[i] );
// od lavej do pravej do subst
for( i = lav_z +1 ; i < prav_z; i++ )
strchar( subst, ret_f[i] );
strchar( vysl, 'a' + zac_subst + subst_NDF->poc_NDF -1 ); // vyrobil som novu premennu
// od pravej do vysl
for( i = prav_z +1; i < strlen( ret_f ); i++ )
strchar( vysl, ret_f[i] );
// tak ten clen tam hodim
for( y=0; y <= strlen( subst ); y++ ) s_NDF[y] = subst[y];
subst_NDF->adept[ subst_NDF->poc_NDF ] = 'a' + zac_subst + subst_NDF->poc_NDF - 2 ;
// takto to uz dalej nepojde mam malo pismen abecedy na vetvenia
if( subst_NDF->adept[ subst_NDF->poc_NDF ] >= 'z' )
{
chybove_okno(chyba[26] );
return(0);
}
subst_NDF->t_vodic[ subst_NDF->poc_NDF ] = '+';// znaci, ze je to clen OR
strcpy( ret_f, vysl ); // tuto je vysledok mojho snazenia
pSubst_NDF = (char *) farmalloc( strlen( vysl ) + 1 );// sprav mu miesto
min_mem = min_mem + strlen( vysl ) +8;
pamet(); // ukaz ako si na tom z pametou
if ( pSubst_NDF == NULL ) { // malo pamete
chybove_okno(chyba[err] );
return(0);
}
for( y=0; y <= strlen( vysl ); y++ ) pSubst_NDF[y] = vysl[y];
return( zac_subst + subst_NDF->poc_NDF -1 ); // poslem aku premennu som vyrobil
} // end if( ma_zatv( ret_f ) == 1 )
else return(0); // subtitucie uz dosli
}
//************************************************************************//
// SUBSTITUCIE nahradzuje cleny substituovane skutocnymi vstupmi //
// i:slovnik substitucii o: retazec substitucii 30.10.1997 //
//************************************************************************//
int substitucie( char subst[], char okrem )
{
int x,y; // devka
char pom[ max_ret ];
char vysl[ max_ret ];
int ma_subst=0; // neaku substituciu som nahradil
zapis_NDF pom_NDF;
vysl[0]='\0'; // no a co mam robit ???
for( x=0; x< strlen( subst ); x++ )
{// je to clen zo substituciou
if(( ( subst[x]-'a'+1 ) >= zac_subst ) && ( je_znak( subst[x],jclen ) == TRUE ) && ( subst[x] != okrem ))
{
ma_subst=1;
pom[0]='\0';
for( y=0; y < strlen(subst_NDF.pNDF[ subst[x] - 'a' - zac_subst + 2 ] ); y++ )
strchar( pom, subst_NDF.pNDF[ subst[x] - 'a' - zac_subst + 2 ][y] );
// aj rekurzivne substitucie
while ( substitucie( pom, okrem ) );
strcat( vysl, "(" ); // co ak je to substitucia (a+b)
strcat( vysl, pom );
strcat( vysl, ")" );
} // end if( subst[x] > f_fnc.pv_NDF )
else {// a co ak su negovane
if(( ( subst[x]-224+1 ) >= zac_subst ) && ( je_znak( subst[x],nclen ) == TRUE ) && ( subst[x]-224+'a' != okrem ))
{
ma_subst=1;
pom[0]='\0';
for( y=0; y < strlen(subst_NDF.pNDF[ subst[x] - 224 - zac_subst + 2 ] ); y++ )
strchar( pom, subst_NDF.pNDF[ subst[x] - 224 - zac_subst + 2 ][y] );
znuluj( &pom_NDF, 0 ); // aby to bolo OK
vytvor_formu( &pom_NDF, pom ); // ret do mojho zapisu
strcpy( pom , K_negovane( &pom_NDF ) ); // zneguj
znuluj( &pom_NDF, 1 ); // uvolni pamet
// aj rekurzivne substitucie
while ( substitucie( pom, okrem ) );
strcat( vysl, "(" ); // co ak je to substitucia (a+b)
strcat( vysl, pom );
strcat( vysl, ")" );
}
else strchar( vysl, subst[x] );
}
} // end for( x=0; x< strlen( subst ); x++ )
strcpy( subst, vysl );
return( ma_subst );
}
//************************************************************************//
// KOLKO_VETIEV zistuje na kolko premennych sa deli primarny vstup //
// i:funkcia o:pocet vetiev 22.11.1997 //
//************************************************************************//
int kolko_vetiev( char f_vstup[], int premenna )
{
int i,poc=0;