Cellular Automata - Rule 90 and Rule 110

A cellular automaton is a model used in computer science and mathematics. The idea is to model a dynamic system by using a number of cells. Each cell has one of several possible states. With each "turn" or iteration the state of the current cell is determined by two things: its current state, and the states of the neighbouring cells.

My program (coded in freepascal).

Source WIKIPEDIA.

Rule 90:

current pattern	111	110	101	100	011	010	001	000
new state for center cell	0	1	0	1	1	0	1	0

Output generated by my freepascal program of rule 90:

Rule 110:

current pattern	111	110	101	100	011	010	001	000
new state for center cell	0	1	1	0	1	1	1	0

Output generated by my freepascal program of rule 110:

RGB Convert- Bitshift - SHR

If you want to convert an hexadecimal into its RGB components using a very fast technique then you should try Logical Shift. A logical shift is a bitwise operation that shifts all the bits of its operand. The two base variants are the logical left shift (SHL) and the logical right shift (SHR). They come from the good old days of Assembler.

So, how does it work? In our example, we will obtain the components or channels of the following hexadecimal value.

#ff0cf0 base 16

We want to get from 16714992 base 10 to:

red=255 ;  green=12 ; blue=240.

Note: To simplify we will just use 16 bytes and not RGBA of 24 bytes that includes the alpha (transparency) component. 

<Sample code in Freepascal:>

Program Convert;

var

  r,g,b: longint;

procedure RGB_Convert(RGB:longint; var r,g,b:longint); 

{Byvalue reference (var r,g,b). That means that we pass variables to the functions no values.}

begin

   R := (RGB shr 16);

   G := (RGB shr 8) and 255;

   B := (RGB) and 255;

end;

Begin

  RGB_Convert($ff0cf0,r,g,b);

End.

A Simple Scroll Function

Imagine you want to display a long list of items but you have a limited area to show them on screen. In that case, you have to resort to using scroll.  Let me explain in pseudo-code one way of doing it.

Length is a function that gives the number of items contained in an array of items.

In our example DisplayLength will tell us how many items will be shown on screen. Here, we have set its value to two.

DisplayLength = 2;

Index will be the variable that holds the pointer of the current item on the list. At the beginning, it will point to the first item on the list. Hence index=0;

(Note: Computer scientists always like to start counting at 0)

Index = 0; 

Scroll_Limit will tell us how far we can keep scrolling. When Index = Scroll-Limit that means that we have reached the end of our scroll capabilities and that all items have been displayed to the user.

This is how to calculate it.

Scroll_Limit = Length (List A) - DisplayLength

In our example. Scroll_Limit = (6 - 2) = 4.

Here is our list: 

LIST A   (6 items)                DISPLAY (2 items)

aaaaa 0  -> index points to first item;

bbbbb 1

ccccc 2    

ddddd 3  

eeeee 4    

fffff 5

Imagine that you want to go forward in your list by pressing the arrow down button  (while index <= scroll_Limit). Remember that in this example, Scroll_Limit=4. This would be the result.

CODE: IMPLEMENTATION OF A LIST WITH SCROLL IN C
 

Now to go back, say, with the press of the up arrow key. You just have to decrease the value of index.

index-=1; Remember to set the limit at 0. Allow the key to be processed only if index>0;

Output: