Using Variables: A Double-Word

 Introduction
 A double-word is a group of two consecutive Words. This means that a double-word combines 4 bytes or 32 bits. The bits, counted from right to left, start at 0 and end at 31. The most right bit, bit 0, is called the Low Order bit or LO bit or LOBIT. The most left bit, bit 31, is called the High Order bit or HI bit or HIBIT. The other bits are called using their positions.

The group of the first 8 bits (from bit 0 to bit 7), which is the right byte, is called the Low Order Byte, or LO Byte. It is sometimes referred to as LOBYTE. The group of the last 8 bits (from bit 24 to bit 31), which is the left byte, is called the High Order Byte, or HI Byte or HIBYTE. The other bytes are called by their positions.

The group of the right 16 bits, or the right Word, is called the Low Order Word, or LO Word, or LOWORD. The group of the left 16 bits, or the left Word, is called the High Order Word, or HI Word, or HIWORD.

The minimum binary number you can represent with a double-word is 0. The minimum decimal value of a double-word is 0. To find out the maximum decimal value of a word, you can use the base 2 formula giving a 1 value to each bit:

 2n-1 230 229 228 227 226 225 224 etc 1,073,741,824 536,870,912 268,435,456 134,217,728 67,108,864 33,554,432 16,777,216

 223 222 221 220 219 218 217 216 8,388,608 4,194,304 2,097,152 1,048,576 524,288 262,144 131,072 65,536

 215 214 213 212 211 210 29 28 32,768 16,384 8,192 4,096 2,048 1,024 512 256

 27 26 25 24 23 22 21 20 128 64 32 16 8 4 2 1

1*231+1*230+1*229 + 1*228 + 1*227 + 1*226 + 1*225 + 1*224 + 1*223 + 1*222 + 1*221 + 1*220 + 1*219 + 1*218 + 1*217 + 1*216 + 1*215 + 1*214 + 1*213 + 1*212 + 1*211 + 1*210 + 1*29 + 1*28 + 1*27 + 1*26 + 1*25 + 1*24 + 1*23 + 1*22 + 1*21 + 1*20

= 2,147,483,648 + 1,073,741,824 + 536,870,912 + 268,435,456 + 134,217,728 + 67,108,864 + 33,554,432 + 16,777,216 + 8,388,608 + 4,194,304 + 2,097,152 + 1,048,576 + 524,288 + 262,144 + 131,072 + 65,536 + 32,768 + 16,384 + 8,192 + 4,096 + 2,048 + 1,024 + 512 + 256 + 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1

= 4,286,578,708

The minimum hexadecimal value you can store in a double-word is 0x00000000000000000000000000000000 which is the same as 0x0. To find out the maximum hexadecimal number you can represent with a word, replace every group of 4-bits with an f or F:

 1111 1111 1111 1111 1111 1111 1111 1111 f f f f f f f f = 0xffffffff = 0Xffffffff = 0XFFFFFFFF = 0xFFFFFFFF

 Practical Learning: Using Unsigned Integers
1. Change the file as follows:

 ```using System; class Program { static void Main() { byte shirts; byte pants; ushort otherItems; shirts = 4; pants = 0; otherItems = 3; Console.WriteLine("-/- Georgetown Cleaning Services -/-"); Console.WriteLine("========================"); Console.WriteLine("------------------------"); Console.WriteLine("Item Type Qty"); Console.WriteLine("------------------------"); Console.Write("Shirts "); Console.WriteLine(shirts); Console.Write("Pants "); Console.WriteLine(pants); Console.Write("Other Items "); Console.WriteLine(otherItems); Console.WriteLine("========================"); Console.WriteLine(); } }```
2. Execute the program to see the result
3. Close the DOS window
 Signed Integers

A double-word is large enough to contain double the amount of data that can be stored in a word. This is equivalent to 32 bits or 4 bytes or 4,294,967,295. Therefore, a double-word is used for large numbers that would not fit in a word.

To use a variable that would hold quite large numbers, declare it using the int keyword. A variable declared as int can store values between –2,147,483,648 and 2,147,484,647 negative or positive, that can fit in 32 bits.

Here is an example:

```using System;

class NumericRepresentation
{
static void Main()
{
int CoordX;
int CoordY;

CoordX = 12;
CoordY = -8;

Console.Write("Cartesian Coordinate System: ");
Console.Write("P(");
Console.Write(CoordX);
Console.Write(", ");
Console.Write(CoordY);
Console.WriteLine(")\n");
}
}```

When executed, the program would produce:

`Cartesian Coordinate System: P(12, -8)`
 Unsigned Integers

If the variable must hold only positive natural numbers, you can declared it using the uint keyword. The uint keyword is used to identify a 32-bit positive integer whose value would range from 0 to 2,147,484,647. Here is an example:

```using System;

class NumericRepresentation
{
static void Main()
{
uint DayOfBirth;
uint MonthOfBirth;
uint YearOfBirth;

DayOfBirth   = 8;
MonthOfBirth = 11;
YearOfBirth  = 1996;

Console.WriteLine("Red Oak High School");
Console.Write("Student Date of Birth: ");
Console.Write(MonthOfBirth);
Console.Write("/");
Console.Write(DayOfBirth);
Console.Write("/");
Console.Write(YearOfBirth);
Console.WriteLine();
}
}```

This would produce:

```Red Oak High School
Student Date of Birth: 11/8/1996```
 Practical Learning: Using Unsigned Integers
1. To use unsigned variables, change the file as follows:

 ```using System; class Program { static void Main() { byte shirts; byte pants; ushort otherItems; uint orderDay; uint orderMonth; uint orderYear; shirts = 4; pants = 0; otherItems = 3; orderDay = 15; orderMonth = 7; orderYear = 2002; Console.WriteLine("-/- Georgetown Cleaning Services -/-"); Console.WriteLine("========================"); Console.Write("Order Date: "); Console.Write(orderMonth); Console.Write('/'); Console.Write(orderDay); Console.Write('/'); Console.WriteLine(orderYear); Console.WriteLine("------------------------"); Console.WriteLine("Item Type Qty"); Console.WriteLine("------------------------"); Console.Write("Shirts "); Console.WriteLine(shirts); Console.Write("Pants "); Console.WriteLine(pants); Console.Write("Other Items "); Console.WriteLine(otherItems); Console.WriteLine("========================"); Console.WriteLine(); } }```
2. Execute the program. This would produce:

 ```-/- Georgetown Cleaning Services -/- ======================== Order Date: 7/15/2002 ------------------------ Item Type Qty ------------------------ Shirts 4 Pants 0 Other Items 3 ======================== Press any key to continue . . .```
3. Close the DOS window