This thesis contains program coding module for generation logics test by Boolean gap
Delphi & Pascal (česká wiki)
Category: Programs in C, C++
Program: Prac_ndf.c, Booldif.zip
File exe: Booldif.exe
need: Adresar.c, Color.c, Derivac.c, Error.c, Funkcie.c, Help.c, Key.c, Line_edi.c, Main.c, Menu.c, Obsluha.c, Okno.c, Prac_ndf.c, Slovnik.c, Slov_fon.c, Statist.c, Util.c, Video.c, Vystupy.c, Adresar.h, Color.h, Define.h, Error.h, Funkcie.h, Glob.h, Key.h, Line_edi.h, Mbooldif.h, Menu.h, Okno.h, Slov_fon.h, Util.h, Video.h
Example: Example.zip, Bin_10_o.ndf, Bin_10_o.ndf, Bin_1and.ndf, Bin_2rad.ndf, Bin_3rad.ndf, Bin_4rad.ndf, Hard.ndf, I_reg_lo.ndf, Reg_jk.ndf, Scitac_s.ndf, Scp_1rad.ndf, Scp_2rad.ndf, Scp_2r_1.ndf, Scp_3rad.ndf, Scp_4r_2.ndf, Scp_6r_3.ndf, Scp_8r_4.ndf, Sc_1r_pj.ndf, Sc_1r_sj.ndf, Sc_1_aoi.ndf, Sc_2r_4.ndf, Sc_3r_6.ndf, Sc_7400n.ndf, Sc_aon.ndf, Simp3_a.ndf, Simp3_b.ndf, Simp4_a.ndf, Simp4_b.ndf, Simp4_c.ndf, Simp6_a.ndf, Test_vod.ndf, Zle.ndf
Manual: Prirucky.zip
Program: Prac_ndf.c, Booldif.zip
File exe: Booldif.exe
need: Adresar.c, Color.c, Derivac.c, Error.c, Funkcie.c, Help.c, Key.c, Line_edi.c, Main.c, Menu.c, Obsluha.c, Okno.c, Prac_ndf.c, Slovnik.c, Slov_fon.c, Statist.c, Util.c, Video.c, Vystupy.c, Adresar.h, Color.h, Define.h, Error.h, Funkcie.h, Glob.h, Key.h, Line_edi.h, Mbooldif.h, Menu.h, Okno.h, Slov_fon.h, Util.h, Video.h
Example: Example.zip, Bin_10_o.ndf, Bin_10_o.ndf, Bin_1and.ndf, Bin_2rad.ndf, Bin_3rad.ndf, Bin_4rad.ndf, Hard.ndf, I_reg_lo.ndf, Reg_jk.ndf, Scitac_s.ndf, Scp_1rad.ndf, Scp_2rad.ndf, Scp_2r_1.ndf, Scp_3rad.ndf, Scp_4r_2.ndf, Scp_6r_3.ndf, Scp_8r_4.ndf, Sc_1r_pj.ndf, Sc_1r_sj.ndf, Sc_1_aoi.ndf, Sc_2r_4.ndf, Sc_3r_6.ndf, Sc_7400n.ndf, Sc_aon.ndf, Simp3_a.ndf, Simp3_b.ndf, Simp4_a.ndf, Simp4_b.ndf, Simp4_c.ndf, Simp6_a.ndf, Test_vod.ndf, Zle.ndf
Manual: Prirucky.zip
This thesis contains program coding module for generation logics test by Boolean gap. Compile vector of fault for existent circuit, forth about all boughs herself chauffeur. Results is absolute gauge. Program application enables four modes It is implemented in the C programming language for the operating system MS-DOS, or another compatible with it. The program is suitable for an interactive way to communicate with the user, allowing a comfortable working environment are similar to Turbo Vision.
//************************************************************************// // 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--------------------------------------*/