GitHub
parent
d7212ca6ad
commit
86544c219b
Binary file not shown.
@ -0,0 +1,51 @@
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#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);
|
||||
|
||||
|
||||
}
|
||||
@ -0,0 +1,364 @@
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#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;
|
||||
}
|
||||
|
||||
}*/
|
||||
@ -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
|
||||
Binary file not shown.
@ -0,0 +1,85 @@
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#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<length; i++){
|
||||
if(i==position){
|
||||
fprintf(stdout, "\n%s{",tabs);
|
||||
}
|
||||
else{
|
||||
fprintf(stdout, "\n%s",tabs);
|
||||
}
|
||||
|
||||
if( L[i]==0){
|
||||
fprintf(stdout, "T");
|
||||
|
||||
}
|
||||
|
||||
else if(L[i]==8){
|
||||
fprintf(stdout, "X");
|
||||
}
|
||||
|
||||
else if(L[i]==9){
|
||||
fprintf(stdout, "W");
|
||||
}
|
||||
|
||||
else{
|
||||
fprintf(stdout, "%d",L[i]);
|
||||
}
|
||||
|
||||
if(i==position){
|
||||
fprintf(stdout, "}\n");
|
||||
}
|
||||
else{
|
||||
fprintf(stdout, "\n");
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void print_variables(int state, int position, int symbol, int movement){
|
||||
char tabs[]="\t\t\t\t\t\t\t\0";
|
||||
fprintf(stdout,"\n%sState =%d\n",tabs,state);
|
||||
fprintf(stdout,"\n%sPosition =%d\n",tabs,position);
|
||||
fprintf(stdout,"\n%sSymbol =%d\n",tabs,symbol);
|
||||
fprintf(stdout,"\n%sMovement =%d\n\n",tabs,movement);
|
||||
}
|
||||
|
||||
void print_linea(){
|
||||
char tabs[]="\t\t\0";
|
||||
fprintf(stdout,"\n%s__________________________________________________________________________________________\n",tabs);
|
||||
}
|
||||
@ -0,0 +1,8 @@
|
||||
#ifndef __CONST_H_
|
||||
#define __CONST_H_
|
||||
|
||||
void print_lista(int*L, int length, int position);
|
||||
void print_variables(int state, int position, int symbol, int movement);
|
||||
int length(int *List);
|
||||
void print_linea();
|
||||
#endif
|
||||
Loading…
Reference in new issue