DEV Community: Martin Corona

Matrix neighbors

Martin Corona — Sat, 16 May 2020 16:37:25 +0000

In this blog I will explain the functionality of this program, the purpose of this program is to iterate all the matrix adding the neighbor numbers, dividing it by the number of neighbors and put the result in the second matrix where the operation took place in the first matrix.

First of all, we’ll start in the Figure 1,As we can see the algorithm take place in the first matrix’s cell in color red, we can see that the matrix in the left side, upper left corner, and upper left side in color yellow doesn’t have neighbors, so the algorithm will take the opposite side, that is to say the cell in color green. The algorithm will save the result in the second matrix in the same position in color red.

In the Figure 2, As we mention before, the algorithm will iterate through all the cells, in this case we can see that the algorithm had iterated through the cell [0,3],but we can see that the matrix doesn’t have the upper side neighbors in color yellow, therefore the algorithm will take the lower sides in color green, and the result will be adding in the second matrix in the same position in color red.

In the Figure 3, The algorithm takes the right upper corner in color red, but the matrix doesn’t have the neighbors in color yellow, Therefore, the algorithm takes the cells in color green, and the result will be adding in the second matrix in the same position in color red.

In the Figure 4,The algorithm had iterated until cell [1,0], but the matrix doesn’t have the neighbors in the left side in color yellow, Therefore, the algorithm will take the opposite side in color green, and the result will be adding in the second matrix in the same position in color red.

In the Figure 5, we can see that the algorithm takes the cell [1,1], and the matrix knows all its neighbors, which there’s no problem to do the operation.

In the Figure 6, We can see that the algorithm had iterated through cell [1,4], but the matrix doesn’t have the neighbors in the right side in color yellow, whereby the algorithm will take the opposite sides in color green, and the result will be adding in the second matrix in the same position in color red.

In the Figure 7, We can observe that in the cell in color red, it’s on the lower left corner and the matrix doesn’t have the neighbors in color yellow, whereby the algorithm will take the opposite sides in color green, and the result will be adding in the second matrix in the same position in color red.

In the Figure 8, We can observe that the algorithm had iterated through the cell [4,1], but the matrix doesn’t have the neighbors in the lower side in color yellow, whereby the algorithm will take the opposite sides in color green, and the result will be adding in the second matrix in the same position in color red.

In the Figure 9,We can appreciate that the algorithm had reached to the last cell of the matrix in color red, but the matrix doesn’t have the neighbors in color yellow, whereby the algorithm will take the opposite sides in color green, and the result will be adding in the second matrix in the same position in color red.

Therefore, every figure is a technique and it will get in operation when the matrix doesn’t know its neighbors.

The code:
https://github.com/martincorona007/Graphics/tree/master/Program%202%20Matrix%20Circular

Full Adder

Martin Corona — Sat, 18 Jan 2020 04:14:43 +0000

A full adder Figure 1 is a digital circuit that adds three one-bit numbers: two operands named X and Y and a carried bit named CIN. The circuit produces a two-bit output: an output carry bit named COUT and the result bit S.

In this practice is about compute the Turing Machine that emulates an 8-bits iterative adder, as an example in the Figure 2.

Using the picture from the figure 1 will be something like the figure 3.

In the next figure 4 it shows of the adder works.

Figure 4 Full adder 8 bits.

For the development of this practice, as a first step we must design a model for to know the functionality of the process, The symbol — means that it will decreasing, The symbol + means that it will increasing to do the movements through the process, The model is show in the Figure 5.

                        Figure 5 The Adder’s Model.

In this table will be explained a explanation about how the model works, on the left side of the table it will show the movements in the tape, the cell with the color gray will be the header.

B=Blank, R=right, L=left,the cell in gray will the header.

Conclusion

At the beginning it was difficult to understand, because I didn’t know where I should start, So I wonder, How this works? And there’s where I can figure out and make it possible. One of the things that I noticed, It’s that if you move the The Adder’s Model in the Figure 5 to the Right its a heart ❤

the code https://github.com/martincorona007/Adder

Lexical Analysis

Martin Corona — Sun, 12 Jan 2020 17:10:13 +0000

The first phase of a compiler design is called Lexical Analysis or scanner. The Lexical Analysis read the Stream of characters that make up the source of file and group the significative sequences, known as a lexeme.

                          <token class, attribute value>

For example
int doc=8;

In the next table will be the lexemes classes used in the development of the practice.

In the next Figure 1, it shows the first Automata called A1 which recognize identifiers:

The next Figure 2, it shows the Automata A2 which recognize Octal numbers, Hexadecimal number and Real number:

The next Figure 3, it shows the Automata A3 which recognize Delimitation characters, Arithmetic operators, Punctuation marks and Assignment Operator:

The next Figure 4, it shows the Automata A4 comments:

In this automata the number 10 represents New Line in ASCII code.

Conclusions:

As a conclusion, it was difficult to understand and solve the EOF, Blacks and comments. Because when I was using fgetc() function whit a char variable, the char variable was changing it for another number and never reach to EOF. So that was freaking me out but finally I solve it. Sometimes when the lexical analysis read a black it was doing a loop infinite but it was solved. Also, I consider that this practice was a huge challenge, but I made it.

The code: https://github.com/martincorona007/Lexical_analysis

Insert Before Double Linked List

Martin Corona — Sat, 14 Dec 2019 06:09:14 +0000

In this Algorithm the way it works is by adding a node before the node is selected, Therefore, I'll explain the parts of this Algorithm:

{x is going to be the node to select, data is the information to add}

{Q, T and R are pointers}

{Info is the content of the node, linkft is the pointer to the left, linker is the pointer to the right}

First of all, We'll need a list done,then we select the node to add before, which in this case is 66 and the node we'll add is 24 as show in the Figure 1.

Figure 1 The list.

After that, We going to make that the node Q point to the head, as show in the Figure 2.

Figure 2 node Q point to the first node.

So, for to check through all of the list we going to use a loop, for look up the node we select and different to NULL, as show in the Figure 3 and Figure 3.1.

Figure 3.

Figure 3.1 This loop will check node by node, which we selected.

Once, the Algorithm found the node which we selected, then we create the new node,as show in the Figure 4.

Figure 4 Create new node 24 which is the pointer T.

So, we start by doing that the node T point to the right side of the node Q, as show in the Figure 5.

Figure 5 node T point to node Q.

After that, The node R will point to the left node of the node Q, as show in the Figure 6.

Figure 6 node R point to the left side of the node Q.

In the next line, the node Q will point to the left side of the node T,as show in the Figure 7.

Figure 7 node Q point to the left side of the node T.

In the next Figure 8, the Algorithm check if the node Q is the head of the List, if the case is true, then the head will point to node T and T link left will going to be NULL, but as we see in this case, node Q is not at the beginning, pass to the next case.

Figure 8 Check if node Q is the beginning of the list.

Therefore, the node R will point to the right side of the node T, as show in the Figure 9.

Figure 9 node R point to the right side of node T.

As last step, the node T will point to the left side of R, as show in the Figure 10.

Figure 10 node T point to the left side of node R.

Finally,

the node T have been added to the list, as show in the Figure 11.

Figure 11 node T added to the list.

Regular Processing

Martin Corona — Sat, 14 Dec 2019 05:29:33 +0000

In this practice is about compute an automaton and generate the synthetize for the regexp in Figure 1.

Figure 1.

After have a deterministic version of the automaton corresponding the regeexp on figure 1, the automaton will implement with the following design, the system states will be coded as non-negative integers, the sequence of events will be presented as a standard string, the indefiniteness of a state will be coded as -1.

The synthesis of the regexp