Bottom of This Page 
Most modern computer systems (including the IBM PC) operate using binary logic. The computer represents values using two voltage levels (usually 0V for logic 0 and either +3.3 V or +5V for logic 1). With two levels we can represent exactly two different values. These could be any two different values, but by convention we use the values zero and one. These two values, coincidentally, correspond to the two digits used by the binary number system.
Since there is a correspondence between the logic levels used by the computer and the two digits used in the binary numbering system, it should come as no surprise that computers employ the binary system. The binary number system works like the decimal number system except the Binary Number System:
The weighted values for each position is determined as follows:
2^7  2^6  2^5  2^4  2^3  2^2  2^1  2^0  2^1  2^2 
128  64  32  16  8  4  2  1  .5  .25 
In the United States among other countries, every three decimal digits is separated with a comma to make larger numbers easier to read. For example, 123,456,789 is much easier to read and comprehend than 123456789. We will adopt a similar convention for binary numbers. To make binary numbers more readable, we will add a space every four digits starting from the least significant digit on the left of the decimal point. For example, the binary value 1010111110110010 will be written 1010 1111 1011 0010.
It is very easy to convert from a binary number to a decimal number. Just like the decimal system, we multiply each digit by its weighted position, and add each of the weighted values together. For example, the binary value 1100 1010 represents:
1*2^7 + 1*2^6 + 0*2^5 + 0*2^4 + 1*2^3 + 0*2^2 + 1*2^1 + 0*2^0 =
1 * 128 + 1 * 64 + 0 * 32 + 0 * 16 + 1 * 8 + 0 * 4 + 1 * 2 + 0 * 1 =
128 + 64 + 0 + 0 + 8 + 0 + 2 + 0 =
202
To convert decimal to binary is slightly more difficult. There are two methods, that may be used to convert from decimal to binary, repeated division by 2, and repeated subtraction by the weighted position value.
For this method, divide the decimal number by 2, if the remainder is 0, on the side write down a 0. If the remainder is 1, write down a 1. This process is continued by dividing the quotient by 2 and dropping the previous remainder until the quotient is 0. When performing the division, the remainders which will represent the binary equivalent of the decimal number are written beginning at the least significant digit (right) and each new digit is written to more significant digit (the left) of the previous digit. Consider the number 2671.
Division  Quotient  Remainder  Binary Number 
2671 / 2  1335  1  1 
1335 / 2  667  1  11 
667 / 2  333  1  111 
333 / 2  166  1  1111 
166 / 2  83  0  0 1111 
83 / 2  41  1  10 1111 
41 / 2  20  1  110 1111 
20 / 2  10  0  0110 1111 
10 / 2  5  0  0 0110 1111 
5 / 2  2  1  10 0110 1111 
2 / 2  1  0  010 0110 1111 
1 / 2  0  1  1010 0110 1111 
For this method, start with a weighted position value greater that the number.
This process is continued until the result is 0. When performing the subtraction, the digits which will represent the binary equivalent of the decimal number are written beginning at the most significant digit (the left) and each new digit is written to the next lesser significant digit (on the right) of the previous digit. Consider the same number, 2671, using a different method.
Weighted Value  Subtraction  Remainder  Binary Number 
2^12 = 4096  2671  0  2671  0 
2^11 = 2048  2671  2048  623  0 1 
2^10 = 1024  623  0  623  0 10 
2^9 = 512  623  512  111  0 101 
2^8 = 256  111  0  111  0 1010 
2^7 = 128  111  0  111  0 1010 0 
2^6 = 64  111  64  47  0 1010 01 
2^5 = 32  47  32  15  0 1010 011 
2^4 = 16  15  0  15  0 1010 0110 
2^3 = 8  15  8  7  0 1010 0110 1 
2^2 = 4  7  4  3  0 1010 0110 11 
2^1 = 2  3  2  1  0 1010 0110 111 
2^0 = 1  1  1  0  0 1010 0110 1111 
We typically write binary numbers as a sequence of bits (bits is short for binary digits). We have defined boundaries for these bits. These boundaries are:
Name  Size (bits)  Example 
Bit  1  1 
Nibble  4  0101 
Byte  8  0000 0101 
Word  16  0000 0000 0000 0101 
Double Word  32  0000 0000 0000 0000 0000 0000 0000 0101 
In any number base, we may add as many leading zeroes as we wish without changing its value. However, we normally add leading zeroes to adjust the binary number to a desired size boundary. For example, we can represent the number five as:
Bit  101 
Nibble  0101 
Byte  0000 0101 
Word  0000 0000 0000 0101 
We'll number each bit as follows:
Bit zero is usually referred to as the LSB (least significant bit). The leftmost bit is typically called the MSB (most significant bit). We will refer to the intermediate bits by their respective bit numbers.
The smallest "unit" of data on a binary computer is a single bit. Since a single bit is capable of representing only two different values (typically zero or one) you may get the impression that there are a very small number of items you can represent with a single bit. Not true! There are an infinite number of items you can represent with a single bit.
With a single bit, you can represent any two distinct items. Examples include zero or one, true or false, on or off, male or female, and right or wrong. However, you are not limited to representing binary data types (that is, those objects which have only two distinct values).
To confuse things even more, different bits can represent different things. For example, one bit might be used to represent the values zero and one, while an adjacent bit might be used to represent the values true and false. How can you tell by looking at the bits? The answer, of course, is that you can't. But this illustrates the whole idea behind computer data structures: data is what you define it to be.
If you use a bit to represent a boolean (true/false) value then that bit (by your definition) represents true or false. For the bit to have any true meaning, you must be consistent. That is, if you're using a bit to represent true or false at one point in your program, you shouldn't use the true/false value stored in that bit to represent red or blue later.
Since most items you will be trying to model require more than two different values, single bit values aren't the most popular data type. However, since everything else consists of groups of bits, bits will play an important role in your programs. Of course, there are several data types that require two distinct values, so it would seem that bits are important by themselves. however, you will soon see that individual bits are difficult to manipulate, so we'll often use other data types to represent boolean values.
A nibble is a collection of bits on a 4bit boundary. It wouldn't be a particularly interesting data structure except for two items: BCD (binary coded decimal) numbers and hexadecimal (base 16) numbers. It takes four bits to represent a single BCD or hexadecimal digit.
With a nibble, we can represent up to 16 distinct values. In the case of hexadecimal numbers, the values 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, and F are represented with four bits. BCD uses ten different digits (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) and requires four bits. In fact, any sixteen distinct values can be represented with a nibble, but hexadecimal and BCD digits are the primary items we can represent with a single nibble.
b3  b2  b1  b0 
Without question, the most important data structure used by the 80x86 microprocessor is the byte. This is true since the ASCII code is a 7bit nonweighted binary code that is used on the byte boundary in most computers. A byte consists of eight bits and is the smallest addressable datum (data item) in the microprocessor.
Main memory and I/O addresses in the PC are all byte addresses. This means that the smallest item that can be individually accessed by an 80x86 program is an 8bit value. To access anything smaller requires that you read the byte containing the data and mask out the unwanted bits.
The bits in a byte are numbered from bit zero (b0) through seven (b7) as follows:
b7  b6  b5  b4  b3  b2  b1  b0 
Bit 0 is the low order bit or least significant bit, bit 7 is the high order bit or most significant bit of the byte. We'll refer to all other bits by their number.
A byte also contains exactly two nibbles. Bits b0 through b3 comprise the low order nibble, and bits b4 through b7 form the high order nibble. Since a byte contains exactly two nibbles, byte values require two hexadecimal digits.
Since a byte contains eight bits, it can represent 2^8, or 256,
different values. Generally, we'll use a byte to represent:
Since the PC is a byte addressable machine, it turns out to be more efficient to manipulate a whole byte than an individual bit or nibble. For this reason, most programmers use a whole byte to represent data types that require no more than 256 items, even if fewer than eight bits would suffice. For example, we'll often represent the boolean values true and false by 00000001 and 00000000 (respectively).
Probably the most important use for a byte is holding a character code. Characters typed at the keyboard, displayed on the screen, and printed on the printer all have numeric values. To allow it to communicate with the rest of the world, the IBM PC uses a variant of the ASCII character set. There are 128 defined codes in the ASCII character set. IBM uses the remaining 128 possible values for extended character codes including European characters, graphic symbols, Greek letters, and math symbols.
NOTE:
The boundary for a Word is defined as either 16bits or the size
of the data bus for the processor, and a Double Word is Two Words.
Therefore, a Word and a Double Word is not a fixed size but varies
from system to system depending on the processor. However, for our
discussion, we will define a word as two bytes.
For the 8085 and 8086, a word is a group of 16 bits. We will number the bits in a word starting from bit zero (b0) through fifteen (b15) as follows:
b15  b14  b13  b12  b11  b10  b9  b8  b7  b6  b5  b4  b3  b2  b1  b0 
Like the byte, bit 0 is the LSB and bit 15 is the MSB. When referencing the other bits in a word use their bit position number.
Notice that a word contains exactly two bytes. Bits b0 through b7 form the low order byte, bits 8 through 15 form the high order byte. Naturally, a word may be further broken down into four nibbles. Nibble zero is the low order nibble in the word and nibble three is the high order nibble of the word. The other two nibbles are "nibble one" or "nibble two".
With 16 bits, you can represent 2^16 (65,536) different values. These
could be the unsigned numeric values in the range of 0 => 65,535,
signed numeric values in the range of 32,768 => +32,767, or any
other data type with no more than 65,536 values. The three major uses
for words are
A double word is exactly what its name implies, two words. Therefore, a double word quantity is 32 bits. Naturally, this double word can be divided into a high order word and a low order word, four bytes, or eight nibbles.
Double words can represent all kinds of different data. It may be
A logarithm is used when working with exponentiation. We all learned
that the formula X = Y^{Z}
Y
and multiply it by itself the number of times
specified by Z
. For example,
2^{3} = 8
2*2*2
).Z
is the exponential value of the equation. As
long as you know what the Y
and Z
values
are in the equation, it is easy to calculate the value of
X
. /
En logaritme bruges, når der udregnes med eksponent. Vi lærte
alle, at formlen X = Y^{Z}
Y
og multiplicer (gang) den med sig selv
antallet af gange angivet af Z
. For eksempel,
2^{3} = 8
2*2*2
).Z
er eksponentielværdien i ligningen.
Så længe man kender, hvad Y
og Z
værdierne er i ligningen, er det nemt at beregne værdien af
X
.
Unfortunately, you may not always know the value of Y
and
Z
. How do you determine Z
if you know the value
of X
and Y
? This is when you use a logarithm. A
logarithm is the exponent value that indicates the number of times the
value Y
needs to be multiplied by itself to get the value
X
. The value that is multiplied Y
)Y
og
Z
. Hvordan bestemmer man Z
, hvis man kender
værdien af X
og Y
? Det er da, man bruger
en logaritme. En logaritme er eksponentværdien, som angiver
antallet af gange værdien Y
behøver at blive
multipliceret (ganget) med sig selv for at få værdien
X
. Værdien som er multipliceret (ganget)
Y
)
There are two basic types of logarithms: common and natural.
A common logarithm uses a value 10 as the base value. Therefore,
in the basic formula for exponentiation above,
X = Y^{Z}
,Y
is 10, and Z
is the number of
times that Y
needs to be multiplied by itself
to return the value indicated by X
. /
Der er to grundlæggende typer af logaritmer:
sædvanlig og naturlig. En sædvanlig logaritme
bruger en værdi 10 som grundtal. Derfor i den
grundlæggende eksponentformel ovenfor,
X = Y^{Z}
,Y
10, og Z
er antallet af gange
som Y
behøver at blive multipliceret
(ganget) med sig selv for at returnere værdien angivet
af X
.
Natural logarithms use a base value of approximately
2.71828182845905, normally referred to as e
.
The mathematical notation e
is Euler's
constant, the base of natural algorithms, made
common by the mathematician Leonhard Euler
(Basel, Switzerland April 15, 1707 
Russia September 18, 1783).
VBScript provides two functions for working with
logarithms: Exp()
Log()
.e
. The
Log()
Exp()
e
. The
similar methods in JavaScript is called:
Math.exp()
Math.log()
.e
. Den matematiske notation e
er Eulers konstant, de naturlige algoritmers grundtal, gjort
alminding af matematikeren Leonhard Euler
(Basel, Schweiz 15. april 1707 
Rusland 18. september 1783).
VBScript har to funktioner til udregninger med
logaritmer: Exp()
Log()
.e
.
Log()
Exp()
e
. De lignende
metoder i JavaScript kaldes: Math.exp()
Math.log()
.
It is possible to use these VBScript functions or JavaScript
methods if you have a different base value by using a simple
formula. By dividing the natural log of the desired number
X
)Y
),Z
)Z = Log(X) / Log(Y)
Z = ((Math.log(X)) / (Math.log(Y)));
.X
)Y
),Z
)Z = Log(X) / Log(Y)
Z = ((Math.log(X)) / (Math.log(Y)));
.
The custom function Pow2(NumDbl)
Log2(NumDbl)
Math.pow()
Math.log()
Pow2(NumDbl)
Log2(NumDbl)
Math.pow()
Math.log()
You can see the JavaScript by using View Source. / Man kan se JavaScript'et ved at bruge Vis Kilde.
Sources: Various books, the Internet, and various encyclopedias.
Kilder: Forskellige bøger, internettet og forskellige leksikoner.
