Lab46 Wiki

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
======DTR0======

=====REPOSITORY STEPS=====

=====BUILD THE CODE=====

=====RUN THE PROGRAM=====

=====BACKGROUND=====

====INTEGER VALUES====
An integer is a number that has no fractional component, so 2, 6, -15, and 17356 are all considered integers, while 13½, -1/12, π, and 5.2 are not.
For our use, we split integers into 2 categories, signed and unsigned. A signed integer is any whole number, negative or positive, while an unsigned integer is a strictly positive whole number (and zero).

In this project we are looking at 10 different types of data values, that are all variations of integers with different byte sizes:
<code>signed long long int --- 8 bytes
unsigned long long int --- 8 bytes
signed long int --- 8 bytes
unsigned long int --- 8 bytes
signed int --- 4 bytes
unsigned int --- 4 bytes
signed half int --- 2 bytes
unsigned half int --- 2 bytes
signed char --- 1 byte
unsigned char --- 1 byte</code>





====REPRESENTATION: BASE 2 (BINARY)====
Each of the data value types has an associated size, ranging from 1 byte (8 bits) to 32 byte (256 bits), so the length of the number in binary will be given based on the type.
For example:
<code>unsigned int:
4 bytes
0000000000000000000000000000000

unsigned half int:
2 bytes
0000000000000000</code>
Whether or not the data type is signed changes how the first bit of the number interacts with the rest, in a signed number the first bit acts as a positive or negative sign
For example:
<code>signed half half int
1 Byte
Binary: 10000000
Decimal: -128
Binary: 00000000
Decimal: 0
 </code> 
For further information on how negative act in binary try looking here: 

https://en.wikipedia.org/wiki/Two%27s_complement

Each place value in binary is worth double the previous
<code>Ex:      1 1 1 1
Is worth 8 4 2 1</code>
To convert a binary number to decimal, just add each place value
Ex:
<code>11010010
(1*128)+(1*64)+(0*32)+(1*16)+(0*8)+(0*4)+(1*2)+(0*1)
=210</code>
====REPRESENTATION: BASE 16 (HEXADECIMAL)====
 
Hexadecimal Table:

''0 1 2 3 4 5 6 7 8 9 A B C D E F ''
<code>
Hex     |Binary     |Decimal
0        0000        0
1        0001        1
2        0010        2
3        0011        3
4        0100        4
5        0101        5
6        0110        6
7        0111        7
8        1000        8
9        1001        9
A        1010        10
B        1011        11
C        1100        12
D        1101        13
E        1110        14
F        1111        15
-----------------------
10       00010000    16
20       00100000    32
30       00110000    48
40       01000000    64
50       01010000    80
60       01100000    96
70       01110000    112 
80       10000000    128
90       10010000    144
A0       10100000    160
B0       10110000    176
C0       11000000    192
D0       11010000    208
E0       11100000    224
F0       11110000    240
-------------------------
11       00010001    17
12       00010010    18
13       00010011    19
14       00010100    20
15       00010101    21
16       00010110    22
17       00010111    23
18       00011000    24
-------------------------
FF       11111111    255
100     100000000    256
</code>        

-//Single digit//- 
<code>
  5 + A =
  (5) + (10)
  Decimal = 15
  Hexadecimal = F
  
  MAX SINGLE = F or 15 or 1111
</code>

-//Double Digit//-
<code>
  1F + AB
  ((16*1)+15) + ((16*10)+11)
  Decimal = 31 + 171 = 202
  Hexadecimal = CA
  
  MAX DOUBLE DIGIT = FF or 255 or 11111111
</code>

====STORAGE: BITS AND BYTES====

====BITWISE LOGIC: AND====

__An AND logic gate has 2 inputs/conditions and they both need to be met to activate.__ 

**EXAMPLE** - To login you need both a valid email and password; 
<code>
  (Valid email)-------
                     |
                     |--[AND]--(No login)
                     |
  (Invalid password)--     

Binary view of previous;
  ( 1 ) --------------
                     |
                     |--[AND]--( 0 )
                     |
  ( 0 ) --------------                 
</code>


-AND gate turned on-
<code>
( 1 ) --------------
                   |
                   |--[AND]--( 1 )
                   |
( 1 ) --------------     
</code>

//List of all AND gate Interactions//
  - 0 & 0 = 0
  - 0 & 1 = 0
  - 1 & 1 = 1
  - 1 & 0 = 0


====BITWISE LOGIC: OR====

__An OR logic gate has 2 input/conditions, that when one or both is met, the gate activates__

EXAMPLE - You can have a free ice cream cone
<code>
(1scoopOfVanilla)---
                   |
                   |--[OR]--( free ice cream )
                   |
(0scoopsOfChocolate)

(1scoopOfVanilla)---
                   |
                   |--[OR]--( free ice cream )
                   |
(1scoopsOfChocolate)

(0scoopOfVanilla)---
                   |
                   |--[OR]--(No free ice cream )
                   |
(0scoopsOfChocolate)


</code>  

//List of all OR gate Interactions//
  - 0 & 0 = 0
  - 0 & 1 = 1
  - **1 & 1 = 1**
  - 1 & 0 = 1
====BITWISE LOGIC: XOR====

__An XOR logic gate has 2 input/conditions, that when one is met, the gate activates, cant be both__

EXAMPLE - You can have a free ice cream cone, but you can only have one scoop of vanilla or chocolate 
<code>
(1scoopOfVanilla)---
                   |
                   |--[XOR]--( free ice cream )
                   |
(0scoopsOfChocolate)

(0scoopOfVanilla)---
                   |
                   |--[XOR]--( free ice cream )
                   |
(1scoopsOfChocolate)

(0scoopOfVanilla)---
                   |
                   |--[XOR]--(No free ice cream )
                   |
(0scoopsOfChocolate)

(1scoopOfVanilla)---
                   |
                   |--[XOR]--(no free ice cream )
                   |
(1scoopsOfChocolate)

</code>  

//List of all XOR gate Interactions//
  - 0 & 0 = 0
  - 0 & 1 = 1
  - **1 & 1 = 0**
  - 1 & 0 = 1
====BITWISE LOGIC: NOT====

A NOT gate inverts the input. It only has a single input.

EXAMPLE - Its opposite day
<code>

( YES )------|[NOT]>-----( NO )

( 1 )--------|[NOT]>-----( 0 )
 
</code>

//List of possible NOT gate interactions//
  - 1 = 0
  - 0 = 1
Lab46 Wiki

User Tools

Site Tools

Page Tools
