void lsmatch(char *cp) { char *save = smalloc(LBSIZE); register char *sp = save; register char *scurs = cursor; wcursor = cp; lcpy(sp, linebuf, LBSIZE); *wcursor = 0; strcpy(cursor, genbuf); cursor = strend(linebuf) - 1; if (lmatchp(dot - vcline)) { register int i = insmode; register int c = outcol; register int l = outline; if (!MI) endim(); vgoto(splitw ? WECHO : LINE(wdot - llimit), column(wcursor) - 1); flush(); sleep(1); vgoto(l, c); if (i) goim(); } else { strcLIN(sp); strcpy(scurs, genbuf); if (!lmatchp((line *) 0)) beep(); } strcLIN(sp); wdot = 0; wcursor = 0; cursor = scurs; free(save); }
int main() { int k = 1, err = 10, iter = 0; float ratio = 0; int A[4][5] = { { 1, 1, 1, 1, 1}, { 1, 0, 0, 0, 1}, { 1, 1, 1, 1, 1}, { 1, 0, 0, 0, 1} }; int C[4][5] = { { 1, 1, 1, 1, 1}, { 1, 0, 0, 0, 0}, { 1, 0, 0, 0, 0}, { 1, 1, 1, 1, 1} }; int L[4][5]; int last_used_matrix[4][5] = { { -1, -1, -1, -1, -1}, { -1, -1, -1, -1, -1}, { -1, -1, -1, -1, -1}, { -1, -1, -1, -1, -1} }; t_neuron d_neuron = { .potential = 0, .threshold = 0.5, .output = 0 }; t_synapse synapses[20]; // Création du réseau for (int i = 0; i < 20; i++) { synapses[i].source = create_sensor(); synapses[i].target = &d_neuron; synapses[i].weight = 0; } // Phase d'apprentissage do { feed_neural_network(&synapses, A); learning_phase(&synapses, EPSILON, 1, 0); feed_neural_network(&synapses, C); learning_phase(&synapses, EPSILON, 0, 1); feed_neural_network(&synapses, A); calculate_potential(&synapses, &d_neuron); if (d_neuron.output != 1) err++; feed_neural_network(&synapses, C); calculate_potential(&synapses, &d_neuron); if (d_neuron.output != 0) err++; iter++; ratio = (float) iter / (float) err; //printf("iter: %d && err: %d\n", iter, err); //printf("ratio:%f\n", ratio); } while ( ratio < 0.8); // Phase de test pour A while (k < 20) { int i = 0; int success = 0; while (i < 100000) { while (true) { // Generer copie d'une lettre lcpy(&L, &A); // Generer du bruit sur cette copie generate_noise(&L, k); //print_letter(L); //printf("\n"); if (!matrices_are_equal(L, last_used_matrix)) { lcpy(&last_used_matrix, &L); break; } } feed_neural_network(&synapses, L); calculate_potential(&synapses, &d_neuron); if (d_neuron.output == 1) success++; i++; } success /= 1000; printf("%d%% de succes sur %d essais avec %d%% de bruit.\n", success, i, k*5); k++; } // Phase de test pour C k = 1; while (k < 20) { int i = 0; int success = 0; while (i < 100000) { while (true) { // Generer copie d'une lettre lcpy(&L, &C); // Generer du bruit sur cette copie generate_noise(&L, k); if (!matrices_are_equal(L, last_used_matrix)) { lcpy(&last_used_matrix, &L); break; } } feed_neural_network(&synapses, L); calculate_potential(&synapses, &d_neuron); if (d_neuron.output == 0) success++; i++; } success /= 1000; printf("%d%% de succes sur %d essais avec %d%% de bruit.\n", success, i, k*5); k++; } }
void setterm(char *type) { register int unknown; char ltcbuf[TCBUFSIZE]; if (type[0] == 0) type = "xx"; unknown = 0; putpad(TE); if (tgetent(ltcbuf, type) != 1) { unknown++; lcpy(ltcbuf, "xx|dumb:", sizeof ltcbuf); } gettmode(); /* must call gettmode() before setsize(). GR */ setsize(); aoftspace = tspace; zap(); /* * Initialize keypad arrow keys. */ addmac1(KU, "k", "up", arrows, 1); addmac1(KD, "j", "down", arrows, 1); addmac1(KL, "h", "left", arrows, 1); addmac1(KR, "l", "right", arrows, 1); addmac1(KH, "H", "home", arrows, 1); /* * Handle funny termcap capabilities */ if (xCS && SC && RC) { if (AL==NULL) AL=""; if (DL==NULL) DL=""; } if (AL_PARM && AL==NULL) AL=""; if (DL_PARM && DL==NULL) DL=""; if (IC && IM==NULL) IM=""; if (IC && EI==NULL) EI=""; if (!GT) BT=NULL; /* If we can't tab, we can't backtab either */ #ifdef TIOCLGET #define HAS_JOB_CONTROL #endif #ifdef _SC_JOB_CONTROL #define HAS_JOB_CONTROL #endif #ifdef HAS_JOB_CONTROL /* * Now map users susp char to ^Z, being careful that the susp * overrides any arrow key, but only for hackers (=new tty driver). */ { static char sc[2]; int i /* , fnd */; if (sysconf(_SC_JOB_CONTROL) != -1) { /* * If a system supports job control but no job * control shell is used, only one method of * detection remains: Our session id equals our * process group id. Any job control shell would * have created at least one new process group. * But as the VSUSP key may be active, we have * to override arrow keys either. */ #ifndef _CRAY /* getsid() is a bad syscall on UNICOS */ if (getsid(0) != getpgid(0)) #endif /* !_CRAY */ ldisc = 2; /* value of NTTYDISC */ sc[0] = tty.c_cc[VSUSP]; sc[1] = 0; if (tty.c_cc[VSUSP] == CTRL('z')) { for (i=0; i<=4; i++) if (arrows[i].cap && arrows[i].cap[0] == CTRL('z')) addmac(sc, NULL, NULL, arrows); } else if (sc[0] #ifdef _PC_VDISABLE && sc[0] != fpathconf(1, _PC_VDISABLE) #endif ) addmac(sc, "\32", "susp", arrows); } } #endif /* HAS_JOB_CONTROL */ if (CM != 0) { if (tgoto(CM, 2, 2)[0] == 'O') /* OOPS */ CA = 0, CM = 0; else CA = 1, costCM = cost(tgoto(CM, 8, 10)); } else { CA = 0, CM = 0; } costSR = cost(SR); costAL = cost(AL); costDP = cost(tgoto(DOWN_PARM, 10, 10)); costLP = cost(tgoto(LEFT_PARM, 10, 10)); costRP = cost(tgoto(RIGHT_PARM, 10, 10)); PC = xPC ? xPC[0] : 0; aoftspace = tspace; safecp(ttylongname, gettlongname(ltcbuf, type), sizeof ttylongname, "Terminal name too long"); /* proper strings to change tty type */ termreset(); gettmode(); value(REDRAW) = AL && DL; value(OPTIMIZE) = !CA && !GT; if (ospeed == B1200 && !value(REDRAW)) value(SLOWOPEN) = 1; /* see also gettmode above */ if (unknown) serror(catgets(catd, 1, 191, "%s: Unknown terminal type"), type); }
/* * Find over structure, repeated count times. * Don't go past line limit. F is the operation to * be performed eventually. If pastatom then the user said {} * rather than (), implying past atoms in a list (or a paragraph * rather than a sentence. */ int llfind(bool pastatom, int cnt, void (*f)(int), line *limit) { #ifdef LISPCODE register int c; #endif register int rc = 0; char *save = smalloc(LBSIZE); /* * Initialize, saving the current line buffer state * and computing the limit; a 0 argument means * directional end of file. */ wasend = 0; lf = f; lcpy(save, linebuf, LBSIZE); if (limit == 0) limit = dir < 0 ? one : dol; llimit = limit; wdot = dot; wcursor = cursor; if (pastatom >= 2) { while (cnt > 0 && word(f, cnt)) cnt--; if (pastatom == 3) eend(f); if (dot == wdot) { wdot = 0; if (cursor == wcursor) rc = -1; } } #ifdef LISPCODE else if (!value(LISP)) { #else else { #endif char *icurs; line *idot; if (linebuf[0] == 0) { do if (!lnext()) goto ret; while (linebuf[0] == 0); if (dir > 0) { wdot--; linebuf[0] = 0; wcursor = linebuf; /* * If looking for sentence, next line * starts one. */ if (!pastatom) { icurs = wcursor; idot = wdot; goto begin; } } } icurs = wcursor; idot = wdot; /* * Advance so as to not find same thing again. */ if (dir > 0) { if (!lnext()) { rc = -1; goto ret; } } else ignore(lskipa1("")); /* * Count times find end of sentence/paragraph. */ begin: for (;;) { while (!endsent(pastatom)) if (!lnext()) goto ret; if (!pastatom || (wcursor == linebuf && endPS())) if (--cnt <= 0) break; if (linebuf[0] == 0) { do if (!lnext()) goto ret; while (linebuf[0] == 0); } else if (!lnext()) goto ret; } /* * If going backwards, and didn't hit the end of the buffer, * then reverse direction. */ if (dir < 0 && (wdot != llimit || wcursor != linebuf)) { dir = 1; llimit = dot; /* * Empty line needs special treatement. * If moved to it from other than begining of next line, * then a sentence starts on next line. */ if (linebuf[0] == 0 && !pastatom && (wdot != dot - 1 || cursor != linebuf)) { lnext(); goto ret; } } /* * If we are not at a section/paragraph division, * advance to next. */ if ((wcursor == icurs && wdot == idot) || wcursor != linebuf || !endPS()) ignore(lskipa1("")); } #ifdef LISPCODE else { c = *wcursor; /* * Startup by skipping if at a ( going left or a ) going * right to keep from getting stuck immediately. */ if ((dir < 0 && c == '(') || (dir > 0 && c == ')')) { if (!lnext()) { rc = -1; goto ret; } } /* * Now chew up repitition count. Each time around * if at the beginning of an s-exp (going forwards) * or the end of an s-exp (going backwards) * skip the s-exp. If not at beg/end resp, then stop * if we hit a higher level paren, else skip an atom, * counting it unless pastatom. */ while (cnt > 0) { c = *wcursor; if ((dir < 0 && c == ')') || (dir > 0 && c == '(')) { if (!lskipbal("()")) goto ret; /* * Unless this is the last time going * backwards, skip past the matching paren * so we don't think it is a higher level paren. */ if (dir < 0 && cnt == 1) goto ret; if (!lnext() || !ltosolid()) goto ret; --cnt; } else if ((dir < 0 && c == '(') || (dir > 0 && c == ')')) /* Found a higher level paren */ goto ret; else { if (!lskipatom()) goto ret; if (!pastatom) --cnt; } } } #endif ret: strcLIN(save); free(save); return (rc); }