Delphi & Pascal (česká wiki)
//************************************************************************// // 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 // #include <dos.h> #include <dir.h> #include "mbooldif.h" #include "color.h" #include "glob.h" #include "okno.h" #include "key.h" #include "util.h" #include "video.h" #include "menu.h" #include "error.h" #include "glob.h" #include "funkcie.h" #define v_NDF h_fnc->pNDF[h_fnc->poc_NDF] #define s_NDF subst_NDF->pNDF[subst_NDF->poc_NDF] #define pSubst_NDF subst_NDF->pSubst[subst_NDF->poc_NDF] //************************************************************************// // 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; } for (x=h_fnc->poc_NDF; x>=0; x--) if (h_fnc->adept[x] == 1) { strcpy( h_fnc->pNDF[x], v_NDF ); h_fnc->adept[x] = h_fnc->adept[ h_fnc->poc_NDF ]; h_fnc->adept[ h_fnc->poc_NDF ]=0; farfree (v_NDF); v_NDF=NULL; pamet(); h_fnc->poc_NDF--; } } //************************************************************************// // 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); for (i=0; i<strlen(vstr); i++) { if( vstr[i] == '1' ) vstr[i] = vstup_1[0]; if (!( ( je_znak( vstr[i], nic ) == TRUE ) || ( vstr[i] == '+' ) || ( vstr[i] == '(' ) || ( vstr[i] == ')' ) || ( vstr[i] == vstup_0[0] ) || ( vstr[i] == vstup_1[0]) )) err=1; if (( vstr[i] == '(' ) && ( vstr[i+1] == '+' )) err=2; if (( vstr[i] == '+' ) && ( vstr[i+1] == ')' )) err=2; } if ( err==1 ) return(14); if ( err==2 ) return(15); return(0); } //************************************************************************// // Ma vobec zatvorky ??? // // o: 1-ak ma zatvorky 2.9.1997 // //************************************************************************// int ma_zatv ( char vstr[] ) { int i; for (i=0; i<=strlen(vstr); i++) if ( vstr[i] == '(' ) return(1); return(0); } //************************************************************************// // Odstrani zatvorky // // 27.8.1997 (2.9.97) // //************************************************************************// 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';vysl[0]='\0'; lava=0;b_nec=0; for (i=0; i<=strlen(vstr); i++) { if ( vstr[i] == '(') { lava++; // odteraz kopirujem do nasobitel if ( nasobitel[0] == '+') { strchar( vysl, '+' );strdel( nasobitel, 0 ); } if (( lava == 1 ) && ( strlen(nasobitel) > 0 )) b_nec=1; } if (( lava == 0 ) && ( b_nec == 1 ) && (( vstr[i] == '+' ) || ( i == strlen( vstr ) ))) { odstran_zatvorky( nasobitel, 1 ); // zavola rekurzivne, co ak nieco obsahuje ??? odstran_zatvorky( nasobenec, 1 ); // zavola rekurzivne, co ak nieco obsahuje ??? if (( vysl[ strlen( vysl )-1 ] == '+' ) && (( vstr[i] == '+' ) || ( vstr[i] == '\0' )) || (( strlen( nasobenec ) == 0 ) && ( strlen( nasobitel ) == 0 ) )) {// kedy nedavat zatvorky, alebo je to zbytocne !!! strcat( vysl, nasob_NDF( nasobitel, nasobenec, alge ) ); } else { strchar( vysl, '(' ); strcat( vysl, nasob_NDF( nasobitel, nasobenec, alge ) ); strchar( vysl, ')' ); } 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 ??? if (( vysl[ strlen( vysl )-1 ] == '+' ) && (( vstr[i] == '+' ) || ( vstr[i] == '\0' )) || (( strlen( nasobenec ) == 0 ) && ( strlen( nasobitel ) == 0 ) )) {// kedy nedavat zatvorky, alebo je to zbytocne !!! strcat( vysl, nasob_NDF( nasobitel, nasobenec, alge )); } else { strchar( vysl, '(' ); strcat( vysl, nasob_NDF( nasobitel, nasobenec, alge )); strchar( vysl, ')' ); } 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 ); if( alge == 1 ) strcpy( vstr, von_blbosti( vstr ) ); return( 0 ); } //************************************************************************// // 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) ) { ic=0; while (( nc[ pc+ic ] != '+' ) && ( (pc+ic)< strlen(nc))) { strchar( pom_v, nc[pc+ic] ); ic++; } while (( nt[ pt+it ] != '+' ) && ( (pt+it)< strlen(nt))) { strchar( pom_v, nt[pt+it] ); it++; } pt=pt+it+1;it=0; if( alge == 1 ) { von_blbosti( pom_v ); if( !(( strlen( pom_v ) == 1 ) && ( pom_v[0] == '0') )) {// toto treba co najskor odstranit dava nekorektne vysledky if( ( strlen( vysln ) + strlen( pom_v )) < ( max_ret-10 ) ) { strcat( vysln, pom_v ); strchar( vysln,'+'); } } } pom_v[0]='\0'; } // end while (pt< strlen(nt) pc=pc+ic+1;ic=0; } // end while (pc< strlen(nc) if( alge == 1 ) von_blbosti( vysln ); if( strlen( vysln ) == 0 ) strchar( vysln, '0' ); return ( vysln ); } //************************************************************************// // Prevedie retazec do NDF struktury rozne poupravuje pospekuluje // // este ze funguje, vyp_sk ak chcem vnutit iny text 2.9.1997 // //************************************************************************// void ret_do_NDF(char skus[], zapis_NDF *fnc, char subor[]) { int err; FILE *tmp,*fopen(); // da prec medzery a ine nepotrebne + kontrola zapisu operacia =2 if ( (err=filter(skus)) != 0 ) { chybove_okno(chyba[err] ); return; } // odstrani zatvorky operacia =3 if ( (err=odstran_zatvorky(skus,1)) != 0 ) { chybove_okno(chyba[err]); return; } // vytvori standart NDF s ktorym budem make-ovat operacia =1 if ( (err=vytvor_formu(fnc,skus)) !=0 ) { chybove_okno(chyba[err]); return; } tmp=fopen( strspoj( temp,subor) ,"wt" ); if ( tmp==NULL ) { chybove_okno( chyba[17] ); return; } fprintf( tmp,"\n\r f= %s",ret_f ); fclose(tmp); von_adept( fnc ); // vyhodi adeptov na vyhodenie uloz_NDF ( fnc , "\n Po odstr nenĄ z tvoriek\n f= ",subor); pohltenie( fnc ); // vyhodi cleny, ktore sa pohlcuju uloz_NDF ( fnc , "\n Odstr nen leny, ktor sŁ pohlten (Ź znaĄ pohlten leny)\n f= ",subor); von_adept( fnc ); // vyhodi adeptov na vyhodenie uloz_NDF ( fnc , "\n Vsledn funkcia pouĄvan pre al¨iu pr cu\n f= ",subor); } //************************************************************************// // Boolovska diferencia podla premennych // // i:upravena funkcia o:diferencie podla premennych 30.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) if ( strcmp(ret_f,"") == 0 ) { chybove_okno( chyba[10] ); return(0); } zx=_stlpcov/2-23; zy=_riadkov/2-3; if( view_okno(zx,zy,zx+46,zy+5,atributy[20],atributy[21],2,"")==FALSE) { chybove_okno( chyba[1] ); return(0); } 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 poda premennch "); 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 vodie "); // 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]; // 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[ prem - zac_subst +1 ] ); difer_podla( &h_fnc, subst_NDF.adept[ i ] - 'a', pom, &p_chyb, &p_pokusov, &a_rezim ); strcpy( ret_f, ret_f2 ); } // end if( prem != 0 ) } } // end if( medzi_v zatvor_okno(); // ziadne vnutorne vodice niesu if( medzi_v ) hlasky( chyba[27] ); // znuluj( &subst_NDF,1 ); if ( Rezim == PREV ) result_skusania( p_chyb, p_pokusov ); index[0]=' ';index[1]=' '; if( medzi_v == 0 ) hlasky(chyba[23]); return( 0 ); } //************************************************************************// // DIFER_PODLA vykona boolovske diferencie podla premennej // // 2.11.1997 // //************************************************************************// int difer_podla( zapis_NDF *hp_fnc, int podla_p, char subst[], int *p_chyb, int *p_pokusov, int *a_rezim ) // hp_fnc - funkcia, podla_p - podla akej premennej, subst - aky retazec substiujem // p_chyb p_pokusov - pocet chyb pokusov, a_rezim - automaticky rezim pri demo ??? { zapis_NDF K0,K1,K; // pre potreby derivacie dF/dA char pom_f[max_ret]; // pre pracu s derivaciami char pom[256]; // devka // pre potreby derivacie dF/dA znuluj(&K0,0); znuluj(&K1,0); znuluj(&K,0); // dame do statistickych udajov if( strlen( subst ) == 0 ) sprintf( pom,"dF/d%s", index ); else sprintf( pom,"dF/d%s subst(%s)", index, subst ); zarad_stat( pom,0 ); sprintf(pom," F = %s\n F(ndf) = ", ret_f ); // zobrazi NDF strukturu uloz_NDF( hp_fnc, pom, TmpSubor[3]); filter( subst ); if ( derivac_dF( hp_fnc, podla_p, &K, &K0, &K1) == FALSE ) { znuluj(&K0,1); znuluj(&K1,1); znuluj(&K,1); // uz nemam cas to inac spravit !!! // vypise pre aku premennu nemoze sparvit derivaciu chyba[28][0][14]=index[0]; if ( index[1] != ' ' ) // toto je vetviaci sa vodic chyba[28][0][15]=index[1]; chybove_okno( chyba[28] ); // priprav cleny del_tmp(TmpSubor[3]); return(1); } strcpy( pom_f, zderivuj_dF( &K, &K0, &K1) ); // vyrob so zatvorkami substitucie( pom_f, ' ' ); // substitucie spat na normalne cleny // 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(); } // podla coho derivujem ??? if( strlen( subst ) == 0 ) sprintf( pom,"\n dF/d%s = ", index ); else sprintf( pom,"\n subst(%s) = %s\n dF/d%s = ", subst, index, index ); // 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 ]; znuluj( &NDF1, 0 ); znuluj( &NDF2, 0 ); strcpy( ret_NDF1, subst ); ret_do_NDF( ret_NDF1, &NDF1, TmpSubor[5] ); // s tymto porovnavam for( i=odkial; i <= pokial; i++ ) { for( x=0; x < NDF1.poc_NDF; x++ ) NDF1.t_vodic[x] = 0; strcpy( ret_NDF2, subst_NDF.pNDF[i] ); ret_do_NDF( ret_NDF2, &NDF2, TmpSubor[5] ); // 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 for( y=1; y<= h_fnc->poc_NDF; y++ ) { j_ndf=1; for( x=0; x< h_fnc->pv_NDF; x++ ) { if (( h_fnc->pNDF[y][x] == jclen ) && ( v_vektor[x] == vstup_0[0] )) j_ndf=0; if (( h_fnc->pNDF[y][x] == nclen ) && ( v_vektor[x] == vstup_1[0] )) j_ndf=0; } c_ndf=c_ndf+j_ndf; } if ( c_ndf != 0 ) return( vstup_1[0] ); else return( vstup_0[0] ); } //************************************************************************// // 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 subst[0]='\0'; // znulujeme vysl[0]='\0'; for( i=0; i <= strlen(ret_f); i++ ) { // koncim kopirovanie if( ( je_znak( ret_f[i], nic ) == FALSE ) && ( strlen( subst ) > 1 ) && ( ma_subst == 0 ) ) { filter( subst ); // odfiltruj medzery, zatvorky if ( (err = dalsie_NDF( subst_NDF, strlen( subst ) ) ) != 0) { chybove_okno(chyba[err] ); return(0); } 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] ); // nasiel som clen ohraniceny len zatvorkami if(( vysl[ strlen(vysl) -3 ] == '(' ) && ( vysl[ strlen(vysl) -1 ] == ')' )) { vysl[ strlen(vysl) -3 ]=' '; // zatvorky nebudu bratu, (x) je zbytocne vysl[ strlen(vysl) -1 ]=' '; filter(vysl); } } 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 // //***********************************************************************// if( ma_zatv( ret_f ) == 1 ) { // hladam najpravejsiu zatvorku for( lav_z=strlen( ret_f ); lav_z>0; lav_z-- ) if( ret_f[lav_z] == ')' ) prav_z=lav_z; // k nej lavu zatvorku lav_z = prav_z; while(( lav_z>0 ) && ( ret_f[lav_z] != '(' )) lav_z--; 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] ); filter( subst ); if ( dalsie_NDF( subst_NDF, strlen( subst ) ) == 1) return(0); // 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; for( i=0; i< strlen( f_vstup ); i++ ) if(( f_vstup[i] == 'a' + premenna ) || ( f_vstup[i] == 224 + premenna )) poc++; return( poc ); } /*---------------------------------END--------------------------------------*/