Automata_Convertor/C_sourcecode.cpp at main · ElemenTP/Automata_Convertor · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>

int main(void)
{
    FILE *fp1 = fopen("matrix.csv", "r");
    char buf[100];
    fscanf(fp1, "%[^\n]", buf);
    fseek(fp1, 2, SEEK_CUR);
    //printf("%s\n", buf);

    const int NFA_SIZE = strlen(buf) / 2;
    const int DFA_SIZE = (int)pow(2, NFA_SIZE);
    //printf("%d\n",NFA_SIZE);

    //int **input_matrix = (int **)malloc(NFA_SIZE * sizeof(int *));
    int input_matrix[NFA_SIZE][NFA_SIZE];
    int output_matrix[DFA_SIZE][DFA_SIZE];

    //* 初始化输出矩阵
    for (int i = 0; i < DFA_SIZE; i++)
    {
        for (int j = 0; j < DFA_SIZE; j++)
        {
            output_matrix[i][j] = 0;
        }
    }

    //* 从文件读取数据
    for (int i = 0; i < NFA_SIZE; i++)
    {
        //*(input_matrix+i) = (int *)malloc(NFA_SIZE * sizeof(int));

        char buf_line[100];
        fscanf(fp1, "%[^\n]", buf_line);
        fseek(fp1, 2, SEEK_CUR);
        for (int j = 1; j <= NFA_SIZE; j++)
        {
            input_matrix[i][j - 1] = buf_line[j * 2] - '0';
        }
        //printf("%s\n", buf_line);
    }

    // * 检查输入矩阵
    for (int i = 0; i < NFA_SIZE; i++)
    {
        for (int j = 0; j < NFA_SIZE; j++)
        {
            printf("%d ", input_matrix[i][j]);
        }
        printf("\n");
    }

    // * 输出矩阵列继承
    for (int i = 0; i < NFA_SIZE; i++)
    {
        for (int j = 0; j < NFA_SIZE; j++)
        {

            int opi = pow(2, i);
            int opj = pow(2, j);
            output_matrix[opi][opj] = input_matrix[i][j];

            int tmp = output_matrix[opi][opj];
        }
    }

    // *检查继承结果
    for (int i = 0; i < DFA_SIZE; i++)
    {
        for (int j = 0; j < DFA_SIZE; j++)
        {
            printf("%d ", output_matrix[i][j]);
        }
        printf("\n");
    }

    printf("--------------------------\n");

    // *输出矩阵列拓展
    for (int i = 0; i < NFA_SIZE; i++)
    {
        for (int j = 0; j < DFA_SIZE; j++)
        {
            int j_bin = j;
            int res = 1;
            for (int k = 0; k < NFA_SIZE; k++)
            {
                int m = j_bin % 2;
                j_bin = j_bin / 2;
                int opi = (int)pow(2, i);
                int opj = (int)pow(2, k);
                int val = output_matrix[(int)pow(2, i)][(int)pow(2, k)];
                if (m == 1)
                {
                    res = res & val;
                }
            }
            output_matrix[(int)pow(2, i)][j] = res;
        }
    }

    // *检查列拓展
    for (int i = 0; i < DFA_SIZE; i++)
    {
        for (int j = 0; j < DFA_SIZE; j++)
        {
            printf("%d ", output_matrix[i][j]);
        }
        printf("\n");
    }

    // *输出矩阵行拓展
    for (int i = 0; i < DFA_SIZE; i++)
    {
        for (int j = 0; j < DFA_SIZE; j++)
        {
            int i_bin = i;
            int res = 0;
            for (int k = 0; k < NFA_SIZE && i_bin > 0; k++)
            {

                int m = i_bin % 2;
                i_bin = i_bin / 2;

                int opi = (int)pow(2, k);

                if (m == 1)
                {
                    int val = output_matrix[(int)pow(2, k)][j];
                    res = res | output_matrix[(int)pow(2, k)][j];
                }
            }
            output_matrix[i][j] = res;
            //printf("%d %d %d\n", i, j, res);
        }
    }

    printf("--------------------------\n");

    // *检查行拓展
    for (int i = 0; i < DFA_SIZE; i++)
    {
        for (int j = 0; j < DFA_SIZE; j++)
        {
            printf("%d ", output_matrix[i][j]);
        }
        printf("\n");
    }

    // *清楚多余状态
    for (int i = 0; i < DFA_SIZE; i++)
    {
        for (int j = DFA_SIZE - 1; j >= 0; j--)
        {
            if (output_matrix[i][j] == 1)
            {
                for (int k = j - 1; k > 0; k--)
                {
                    output_matrix[i][k] = 0;
                }
                break;
            }
        }
    }

    printf("-----------------------\n");

    // *检查清除结果
    for (int i = 0; i < DFA_SIZE; i++)
    {
        for (int j = 0; j < DFA_SIZE; j++)
        {
            printf("%d ", output_matrix[i][j]);
        }
        printf("\n");
    }
}