From 86544c219b10a3d2d8ecdba0e4d22a481703e2c0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Nu=C3=B1o=20Sempere?= Date: Sat, 7 Apr 2018 15:50:18 +0200 Subject: [PATCH] Add files via upload --- is_prime 1.1/main | Bin 0 -> 20040 bytes is_prime 1.1/main.c | 51 ++++++ is_prime 1.1/states.c | 364 ++++++++++++++++++++++++++++++++++++++++++ is_prime 1.1/states.h | 6 + is_prime 1.1/states.o | Bin 0 -> 2576 bytes is_prime 1.1/turing.c | 85 ++++++++++ is_prime 1.1/turing.h | 8 + 7 files changed, 514 insertions(+) create mode 100644 is_prime 1.1/main create mode 100644 is_prime 1.1/main.c create mode 100644 is_prime 1.1/states.c create mode 100644 is_prime 1.1/states.h create mode 100644 is_prime 1.1/states.o create mode 100644 is_prime 1.1/turing.c create mode 100644 is_prime 1.1/turing.h diff --git a/is_prime 1.1/main b/is_prime 1.1/main new file mode 100644 index 0000000000000000000000000000000000000000..57d01f81b7dcf14b53421fcafe92c00175615315 GIT binary patch literal 20040 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 +#include +#include "turing.h" +#include "states.h" +#include "const.h" + +#define REJECT -1 +#define ACCEPT -2 + +// gcc -g main.c turing.c states.c turing.h states.h const.h -o main + +int main(){ + + int List[] = {0,5,1,8,7,7,7,2,2,2,2,9}; + // Enough sevens that we can later add more 1s. + // We could have between (sqrt(m)-2) and (m-2) 7s + // But Nuño, if you put sqrt(m) -2 sevens, aren't you offloading the calculation to yourself instead making the machine calculate it? + // Yes, I am. + int longitud=length(List); + + fprintf(stdout,"\nEsta función acepta cuando n es primo"); + + int state=0; + int position=0; + int symbol= List[position]; + int movement =0; // undefined. + int placeholder; + + + while(state!=ACCEPT && state!=REJECT){ + + print_linea(); + print_variables(state,position,symbol, movement); + print_lista(List, longitud, position); + + fscanf(stdin,"\n%d", &placeholder); + + carry_out_step(&symbol,&state,&movement); + + List[position]=symbol; + position = position +movement; + symbol=List[position]; + + } + + print_linea(); + print_variables(state,position,symbol, movement); + print_lista(List, longitud, position); + + +} diff --git a/is_prime 1.1/states.c b/is_prime 1.1/states.c new file mode 100644 index 0000000..736e484 --- /dev/null +++ b/is_prime 1.1/states.c @@ -0,0 +1,364 @@ +#include +#include +#include "const.h" +#include "states.h" + +// States of a Turing Machine that checks whether a number DOESN'T divide another number +// NTS: Check that the first number is smaller? Actually not necessary: see state 2. + +/* +Initially, I defined a triplet, which was what the different states, which are functions returned. + +typedef struct { + + int state; // Finite list of states: initial (0), state 1, state 2, state 3, ..., state 7. + int symbol; // Finite list of symbols: 0,1,2,3,4,5,6,7,8,9 + int movement; // Left = -1, Right =1; + +} ssm; + +But I thought that modifying pointers was easier and more elegant. +*/ + +void state0(int *symbol, int *state, int *movement); +void state1(int *symbol, int *state, int *movement); +void state2(int *symbol, int *state, int *movement); +void state3(int *symbol, int *state, int *movement); +void state4(int *symbol, int *state, int *movement); +void state5(int *symbol, int *state, int *movement); +void state6(int *symbol, int *state, int *movement); +void state7(int *symbol, int *state, int *movement); +void state8(int *symbol, int *state, int *movement); +/*void state9(int *symbol, int *state, int *movement); +void state10(int *symbol, int *state, int *movement); +*/ +// This function is the delta of which Kozen speaks of in p.210 &ss in Automata and Computability. +void carry_out_step(int *symbol, int *state, int *movement){ // I could make this a bigger if/else tree, but I don't want to. +// Initially, I thought to use https://stackoverflow.com/questions/840501/how-do-function-pointers-in-c-work, but this proved unnecessary. + + if(*state==0){ + state0(symbol,state, movement); + } + else if(*state==1){ + // Nótese que los else ifs son necesarios, porque después de state0, *state es =1, pero queremos que se de cuenta en la siguiente vuelta + state1(symbol,state, movement); + } + else if(*state==2){ + state2(symbol,state, movement); + } + else if(*state==3){ + state3(symbol,state, movement); + } + else if(*state==4){ + state4(symbol,state, movement); + } + else if(*state==5){ + state5(symbol,state, movement); + } + + else if(*state==6){ + state6(symbol,state, movement); + } + + else if(*state==7){ + state7(symbol,state, movement); + } + + else if(*state==8){ + state8(symbol,state, movement); + } + /* + else if(*state==9){ + state9(symbol,state, movement); + } + else if(*state==10){ + state10(symbol,state, movement); + } +*/ +} + +void state0(int *symbol, int *state, int *movement){ + if(*symbol ==0){ + *symbol=0; // This is the left endmarker. It isn't changed. This line could be ommited. + *movement= 1; // Move to the right (0 would be to the left). + *state=1; // Change to state 1. + } + + else{ + *state = REJECT; // This is defined as a constant in const.h + // The program ends, because it has unspecified behaviour + *movement= 0; + } + +} + +void state1(int *symbol, int *state, int *movement){ + if(*symbol ==1){ + *symbol=3; // Another symbol. + *movement= 1; // Move to the right (-1 would be to the left). + *state=2; // Change to state 2. + } + + else if(*symbol ==3){ // Note that we need an else because otherwise after it changes a 1 to a 3, symbol=3 and it goes back to state1. + // Note that we have inadvertently created a function to see whether m is(n't) k modulo n; we would only have to start with n-k 3s at the beginning + *symbol=3; + *movement= 1; + *state=1; + } + + else if(*symbol ==8){ // 8 = X + *symbol=8; + *movement= 1; + *state=4; + } + + else{ + *symbol=*symbol; + *movement= 1; + *state=1; + } +} + +void state2(int *symbol, int *state, int *movement){ + + if(*symbol ==2){ + *symbol=4; + *movement= -1; + *state=3; + } + + else if(*symbol ==9){ + *symbol=9; + *movement= -1; + *state=7; + } + + else{ + *symbol=*symbol; + *movement= 1; + *state=2; + } +} + +void state3(int *symbol, int *state, int *movement){ + + if(*symbol ==0){ + *symbol=0; + *movement= 1; + *state=1; + } + + else { + *symbol=*symbol; + *movement = -1; + *state= 3; + } +} + +void state4(int *symbol, int *state, int *movement){ + + if(*symbol ==2){ + *symbol=4; + *movement=-1; + *state=5; + } + + else if(*symbol ==9){ + *symbol=9; + *movement=-1; // Only because it rejects + *state = 6; + } + + else{ + *symbol = *symbol; + *movement =1; + *state=4; + } + +} + +void state5(int *symbol, int *state, int *movement){ + // Note that after state 4, the TM is in m-territory. + if(*symbol ==3){ + *symbol=1; + *movement=-1; + *state=5; + } + + else if(*symbol ==5){ + *symbol=6; + *movement= -1; + *state = 5; + } + + else if(*symbol ==0){ + *symbol=0; + *movement= 1; + *state = 1; + } + + else{ + *symbol = *symbol; + *movement =-1; + *state=5; + } + +} + +void state6(int *symbol, int *state, int *movement){ + if(*symbol ==5){ + *symbol=5; + *movement=0; // Only because it accepts. And it accepts because the first divisor of m is m. + *state=ACCEPT; + fprintf(stdout, "\nIt accepts because the first time that n fits in m, it reaches the end of m, so n=m. \n"); + } + + else if(*symbol ==6){ + *symbol=6; + *movement= 0; // When the function ends, I want it to stay in the same place. But ultimately it doesn't matter. + *state = REJECT; + fprintf(stdout, "\nIt rejects because m is bigger than n and n | m.\n"); + } + + else if (*symbol !=6 && *symbol !=5){ + *symbol = *symbol; + *movement =-1; + *state=6; + } + +} + +void state7(int *symbol, int *state, int *movement){ + if(*symbol ==4){ + *symbol=2; + *movement=-1; + *state=7; + } + + else if(*symbol ==3){ + *symbol=1; + *movement= -1; + *state = 7; + } + else if(*symbol ==6){ + *symbol=5; + *movement= -1; + *state = 7; + } + else if(*symbol ==0){ + *symbol=0; + *movement= 1; + *state = 8; + } + else{ + *symbol=*symbol; + *movement= -1; + *state = 7; + } + +} + +void state8(int *symbol, int *state, int *movement){ + if(*symbol ==8){ + *symbol=1; + *movement=1; + *state=8; + } + + else if(*symbol ==7){ + *symbol=8; + *movement= -1; + *state = 3; + } + else if(*symbol ==2){ + *symbol=2; + *movement= 0; + *state = ACCEPT; + } + else{ + *symbol=*symbol; + *movement= 1; + *state = 8; + } + +} + +/* +void state8(int *symbol, int *state, int *movement){ + + if(*symbol ==4){ + *symbol=2; + *movement=-1; + *state=8; + } + + else if(*symbol ==3){ + *symbol=1; + *movement= -1; + *state = 8; + } + + else if(*symbol ==0){ + *symbol=0; + *movement= 1; + *state = 9; + } + + + else{ + *symbol = *symbol; + *movement =-1; + *state=8; + } + +} + +void state9(int *symbol, int *state, int *movement){ + + if(*symbol ==8){ + *symbol=1; + *movement=1; + *state=9; + } + + else if(*symbol ==5){ + *symbol=8; + *movement= 1; + *state = 10; + } + + else if(*symbol ==2){ + *symbol=2; + *movement= 0; // Only because it accepts + *state = ACCEPT; + } + + else if(*symbol ==4){ + *symbol=4; + *movement= 0; // Only because it accepts + *state = ACCEPT; + } + + else{ + *symbol = *symbol; + *movement =1; + *state=9; + } + +} + +void state10(int *symbol, int *state, int *movement){ + + if(*symbol ==0){ + *symbol=0; + *movement=1; + *state=1; + } + + else { + *symbol = *symbol; + *movement =-1; + *state=10; + } + +}*/ diff --git a/is_prime 1.1/states.h b/is_prime 1.1/states.h new file mode 100644 index 0000000..625b918 --- /dev/null +++ b/is_prime 1.1/states.h @@ -0,0 +1,6 @@ +#ifndef __STATES_H_ +#define __STATES_H_ + +void carry_out_step(int *symbol, int *state, int *movement); // This is the only function I'm going to need to use outside of states.c + +#endif diff --git a/is_prime 1.1/states.o b/is_prime 1.1/states.o new file mode 100644 index 0000000000000000000000000000000000000000..1e33186fbb83ecb042c3b8d3801d7260980bfe15 GIT binary patch literal 2576 zcmbtV&ubG=5T0$UHfgI>R0I`+TB)E*VzpRBiI%mCh)6NiTi7-mTQrGm-eUa?7KIoK zf|nk>dG)9sv?^M}gFW=ne?YLIZvtE@fA*%~bvAYIZ7b*Os++AjPg)^XUnD^x6!F zrkXW<(3-ls&8{_)w_SblbRCY*DAsdAK2kU9;Cj-Uqxq!uIgVDCw7$mUZ>(<`pG_mD zX3e3Tzgf$TWj{Y7C%ZcNm`16FBzxQ*TYF1BsaZ3&F;#4G<05|C)GTuD%WTJ~pT-!J?2d;*}ir{_SjBRk-igrD4J?ln`pyL`Dy zUr%?Lsl8_R&HzvDNu|3|U8!z5jgE_m4+0Sn&r&Kn$Yy8w2(+DNoEK ztYQ0xx)Bd=MKZU&i#;%&hrDt=Q^($-ik4G{*x*`<$>BSGb@*h!WjUwBD`Q6 z(lgIJ@0h|J5n$#W;ea_%setK~gT-LESak6sGD~IQn!P8pyJZz3f!y4oT)}gS?yori zIZ2{Fy;}GS%^*gmzsq11aP^$Vjo9e+$YA4^QCCWvN($9J#nCs!21VYX@bJyl{97^= zS#cLv0K0HOn*ZvbR+`~(I{rQ$OmR6xmpi>zii0@MD8YLEs+{1c@(;O#AKs86Xg|&G zSN>u8hywO&q8fGnHQa}jsPj9e3PPU~ogevXe~qt3ES!6UU`Y8pv|twAKdr-iC;B4= ao>C6 +#include +#include "turing.h" +#include "const.h" + +// Turing print defines functions that take a list, take a position in that list and print the list with a pointer to that position. +// It prints this vertically + +int length(int *List){ + int i =0; + + while (List[i]<9){ // Por cómo construimos nuestras listas. + i=i+1; + } + + /*Anecdóticamente, el siguiente código da error. + i=0; + while (List[i]<=9){ + i=i+1; + } + Y lo hace porque al asignar un trozo de memoria, + si la lista tiene, p.ej., longitud 6, + List[0] hasta Lista[5] son la lista de verdad, + pero Lista[6] <9, y la sigue contando. + */ + + return i+1; +} + +void print_lista(int*L, int length, int position){ + if(L==NULL || length <= position){ + fprintf(stdout, "\nError en prettyprint"); + } + else{ + int i=0; + char tabs[]="\t\t\t\t\t\t\t\0"; + for(i=0; i