mirror of
https://github.com/QB64Official/qb64.git
synced 2024-09-28 11:17:47 +00:00
474 lines
21 KiB
Markdown
474 lines
21 KiB
Markdown
## Basic and QB64 Numerical Types
|
||
|
||
**QBasic Number Types**
|
||
|
||
* [INTEGER](INTEGER) [**%**]: 2 Byte signed whole number values from -32768 to 32767. 0 to 65535 unsigned. (not checked in QB64)
|
||
* [LONG](LONG) [**&**]: 4 byte signed whole number values from -2147483648 to 2147483647. 0 to 4294967295 unsigned.
|
||
* [SINGLE](SINGLE) [**!**]: 4 byte signed floating decimal point values of up to 7 decimal place accuracy. **Cannot be unsigned.**
|
||
* [DOUBLE](DOUBLE) [#]: 8 byte signed floating decimal point values of up to 15 decimal place accuracy. **Cannot be unsigned.**
|
||
* To get **one byte** values, can use an [ASCII](ASCII) [STRING](STRING) character to represent values from 0 to 255 as in [BINARY](BINARY) files.
|
||
|
||
**QB64 Number Types**
|
||
|
||
* [_BIT](_BIT) [**\`**]: 1 bit signed whole number values of 0 or -1 signed or 0 or 1 unsigned. [_BIT](_BIT) * 8 can hold a signed or unsigned [_BYTE](_BYTE) value.
|
||
* [_BYTE](_BYTE) [**%%**]: 1 byte signed whole number values from -128 to 127. Unsigned values from 0 to 255.
|
||
* [_INTEGER64](_INTEGER64) [**&&**]: 8 byte signed whole number values from -9223372036854775808 to 9223372036854775807
|
||
* [_FLOAT](_FLOAT) [##]: currently set as 10 byte signed floating decimal point values up to 1.1897E+4932. **Cannot be unsigned.**
|
||
* [_OFFSET](_OFFSET) [%&]: undefined flexible length integer offset values used in [DECLARE DYNAMIC LIBRARY](DECLARE-DYNAMIC-LIBRARY) declarations.
|
||
|
||
**Signed and Unsigned Integer Values**
|
||
|
||
Negative (signed) numerical values can affect calculations when using any of the BASIC operators. SQR cannot use negative values! There may be times that a calculation error is made using those negative values. The SGN function returns the sign of a value as -1 for negative, 0 for zero and 1 for unsigned positive values. ABS always returns an unsigned value.
|
||
|
||
> * [SGN](SGN)(n) returns the value's sign as -1 if negative, 0 if zero or 1 if positive.
|
||
> * [ABS](ABS)(n) changes negative values to the equivalent positive values.
|
||
> * **QB64:** [_UNSIGNED](_UNSIGNED) in a [DIM](DIM), [AS](AS) or [_DEFINE](_DEFINE) statement for only positive [INTEGER](INTEGER) values.
|
||
|
||
[_UNSIGNED](_UNSIGNED) integer, byte and bit variable values can use the tilde ~ suffix before the type suffix to define the type.
|
||
|
||
## Mathematical Operation Symbols
|
||
|
||
Most of the BASIC math operators are ones that require no introduction. The addition, subtraction, multiplication and division operators are ones commonly used as shown below:
|
||
|
||
| Symbol | Procedure Type | Example Usage | Operation Order |
|
||
| -- | -- | -- | -- |
|
||
| + | Addition | c = a + b | Last |
|
||
| - | Subtraction | c = a - b | Last |
|
||
| - | Negation | c = -a | Last |
|
||
| * | Multiplication | c = a * b | Second |
|
||
| / | Division | c = a / b | Second |
|
||
|
||
BASIC can also use two other operators for **[INTEGER](INTEGER) division**. Integer division returns only whole number values. [MOD](MOD) **remainder division** returns a value only if an integer division cannot divide a number exactly. Returns 0 if a value is exactly divisible.
|
||
|
||
| Symbol | Procedure Type | Example Usage | Operation Order |
|
||
| -- | -- | -- | -- |
|
||
| \ | Integer division | c = a \ b | Second |
|
||
| MOD | Remainder division | c = a MOD b | Second |
|
||
|
||
***It is an [ERROR](ERROR) to divide by zero or to take the remainder modulo zero.***
|
||
|
||
There is also an operator for **exponential** calculations. The exponential operator is used to raise a number's value to a designated exponent of itself. In QB the exponential return values are [DOUBLE](DOUBLE) values. The [SQR](SQR) function can return a number's Square Root. For other **exponential roots** the operator can be used with fractions such as (1 / 3) designating the cube root of a number.
|
||
|
||
| Symbol | Procedure | Example Usage | Operation Order |
|
||
| -- | -- | -- | -- |
|
||
| ^ | Exponent | c = a ^ (1 / 2) | First |
|
||
| SQR | Square Root | c = SQR(a ^ 2 + b ^ 2) | First |
|
||
|
||
### Notes
|
||
|
||
* Exponent fractions should be enclosed in () brackets in order to be treated as a root rather than as division.
|
||
* Negative exponential values must be enclosed in () brackets in QB64.
|
||
|
||
## Basic's Order of Operations
|
||
|
||
When a normal calculation is made, BASIC works from left to right, but it does certain calculations in the following order:
|
||
|
||
* Exponential and exponential Root calculations including [SQR](SQR).
|
||
* Negation (Note that this means that *- 3 ^ 2* is treated as *-(3 ^ 2)* and not as *(-3) ^ 2.)*
|
||
* Multiplication, normal Division, [INTEGER](INTEGER) Division and Remainder([MOD](MOD)) Division calculations
|
||
* Addition and Subtraction calculations
|
||
|
||
**Using Parenthesis to Define the Operation Order**
|
||
|
||
Sometimes a calculation may need BASIC to do them in another order or the calculation will return bad results. BASIC allows the programmer to decide the order of operations by using [parenthesis](parenthesis) around parts of the equation. BASIC will do the calculations inside of the [parenthesis](parenthesis) brackets first and the others from left to right in the normal operation order.
|
||
|
||
## Basic's Mathematical Functions
|
||
|
||
| Function | Description |
|
||
| -- | -- |
|
||
| ABS(n) | returns the absolute (positive) value of n: ABS(-5) = 5 |
|
||
| ATN(angle*) | returns the arctangent of an angle in radians: pi = 4 * ATN(1) |
|
||
| COS(angle*) | returns the cosine of an angle in radians. (horizontal component) |
|
||
| EXP(n) | returns e ^ x, (n <= 88.02969): e = EXP(1) ' (e = 2.718281828459045) |
|
||
| LOG(n) | returns the base e natural logarithm of n. (n > 0) |
|
||
| SGN(n) | returns -1 if n < 0, 0 if n = 0, 1 if n > 0: SGN(-5) = -1 |
|
||
| SIN(angle*) | returns the sine of an angle in radians. (vertical component) |
|
||
| SQR(n) | returns the square root of a number. (n >= 0) |
|
||
| TAN(angle*) | returns the tangent of an angle in radians |
|
||
|
||
*** angles measured in radians**
|
||
|
||
Degree to Radian Conversion.
|
||
|
||
```vb
|
||
|
||
FUNCTION Radian (degrees)
|
||
Radian = degrees * (4 * ATN(1)) / 180
|
||
END FUNCTION
|
||
|
||
FUNCTION Degree (radians)
|
||
Degree = radians * 180 / (4 * ATN(1))
|
||
END FUNCTION
|
||
|
||
```
|
||
|
||
Logarithm to base n.
|
||
|
||
```vb
|
||
|
||
FUNCTION LOGN (X, n)
|
||
IF n > 0 AND n <> 1 AND X > 0 THEN LOGN = LOG(X) / LOG(n) ELSE BEEP
|
||
END FUNCTION
|
||
|
||
FUNCTION LOG10 (X) 'base 10 logarithm
|
||
IF X > 0 THEN LOG10 = LOG(X) / LOG(10) ELSE BEEP
|
||
END FUNCTION
|
||
|
||
```
|
||
|
||
**The numerical value of n in the [LOG](LOG)(n) evaluation must be a positive value.**
|
||
|
||
**The numerical value of n in the [EXP](EXP)(n) evaluation must be less than or equal to 88.02969.**
|
||
|
||
**The numerical value of n in the [SQR](SQR)(n) evaluation *cannot* be a negative value.**
|
||
|
||
## Derived Mathematical Functions
|
||
|
||
The following Trigonometric functions can be derived from the **BASIC Mathematical Functions** listed above. Each function checks that certain values can be used without error or a [BEEP](BEEP) will notify the user that a value could not be returned. An error handling routine can be substituted if desired. **Note:** Functions requiring **π** use 4 * [ATN](ATN)(1) for [SINGLE](SINGLE) accuracy. Use [ATN](ATN)(1.#) for [DOUBLE](DOUBLE) accuracy.
|
||
|
||
```vb
|
||
|
||
FUNCTION SEC (x) 'Secant
|
||
IF COS(x) <> 0 THEN SEC = 1 / COS(x) ELSE BEEP
|
||
END FUNCTION
|
||
|
||
FUNCTION CSC (x) 'CoSecant
|
||
IF SIN(x) <> 0 THEN CSC = 1 / SIN(x) ELSE BEEP
|
||
END FUNCTION
|
||
|
||
FUNCTION COT (x) 'CoTangent
|
||
IF TAN(x) <> 0 THEN COT = 1 / TAN(x) ELSE BEEP
|
||
END FUNCTION
|
||
|
||
FUNCTION ARCSIN (x) 'Inverse Sine
|
||
IF x < 1 THEN ARCSIN = ATN(x / SQR(1 - (x * x))) ELSE BEEP
|
||
END FUNCTION
|
||
|
||
FUNCTION ARCCOS (x) ' Inverse Cosine
|
||
IF x < 1 THEN ARCCOS = (2 * ATN(1)) - ATN(x / SQR(1 - x * x)) ELSE BEEP
|
||
END FUNCTION
|
||
|
||
FUNCTION ARCSEC (x) ' Inverse Secant
|
||
IF x < 1 THEN ARCSEC = ATN(x / SQR(1 - x * x)) + (SGN(x) - 1) * (2 * ATN(1)) ELSE BEEP
|
||
END FUNCTION
|
||
|
||
FUNCTION ARCCSC (x) ' Inverse CoSecant
|
||
IF x < 1 THEN ARCCSC = ATN(1 / SQR(1 - x * x)) + (SGN(x)-1) * (2 * ATN(1)) ELSE BEEP
|
||
END FUNCTION
|
||
|
||
FUNCTION ARCCOT (x) ' Inverse CoTangent
|
||
ARCCOT = (2 * ATN(1)) - ATN(x)
|
||
END FUNCTION
|
||
|
||
FUNCTION SINH (x) ' Hyperbolic Sine
|
||
IF x <= 88.02969 THEN SINH = (EXP(x) - EXP(-x)) / 2 ELSE BEEP
|
||
END FUNCTION
|
||
|
||
FUNCTION COSH (x) ' Hyperbolic CoSine
|
||
IF x <= 88.02969 THEN COSH = (EXP(x) + EXP(-x)) / 2 ELSE BEEP
|
||
END FUNCTION
|
||
|
||
FUNCTION TANH (x) ' Hyperbolic Tangent or SINH(x) / COSH(x)
|
||
IF 2 * x <= 88.02969 AND EXP(2 * x) + 1 <> 0 THEN
|
||
TANH = (EXP(2 * x) - 1) / (EXP(2 * x) + 1)
|
||
ELSE
|
||
BEEP
|
||
END IF
|
||
END FUNCTION
|
||
|
||
FUNCTION SECH (x) ' Hyperbolic Secant or (COSH(x)) ^ -1
|
||
IF x <= 88.02969 AND (EXP(x) + EXP(-x)) <> 0 THEN SECH = 2 / (EXP(x) + EXP(-x)) ELSE BEEP
|
||
END FUNCTION
|
||
|
||
FUNCTION CSCH (x) ' Hyperbolic CoSecant or (SINH(x)) ^ -1
|
||
IF x <= 88.02969 AND (EXP(x) - EXP(-x)) <> 0 THEN CSCH = 2 / (EXP(x) - EXP(-x)) ELSE BEEP
|
||
END FUNCTION
|
||
|
||
FUNCTION COTH (x) ' Hyperbolic CoTangent or COSH(x) / SINH(x)
|
||
IF 2 * x <= 88.02969 AND EXP(2 * x) - 1 <> 0 THEN
|
||
COTH = (EXP(2 * x) + 1) / (EXP(2 * x) - 1)
|
||
ELSE
|
||
BEEP
|
||
END IF
|
||
END FUNCTION
|
||
|
||
FUNCTION ARCSINH (x) ' Inverse Hyperbolic Sine
|
||
IF (x * x) + 1 >= 0 AND x + SQR((x * x) + 1) > 0 THEN
|
||
ARCSINH = LOG(x + SQR(x * x + 1))
|
||
ELSE
|
||
BEEP
|
||
END IF
|
||
END FUNCTION
|
||
|
||
FUNCTION ARCCOSH (x) ' Inverse Hyperbolic CoSine
|
||
IF x >= 1 AND x * x - 1 >= 0 AND x + SQR(x * x - 1) > 0 THEN
|
||
ARCCOSH = LOG(x + SQR(x * x - 1))
|
||
ELSE
|
||
BEEP
|
||
END IF
|
||
END FUNCTION
|
||
|
||
FUNCTION ARCTANH (x) ' Inverse Hyperbolic Tangent
|
||
IF x < 1 THEN ARCTANH = LOG((1 + x) / (1 - x)) / 2 ELSE BEEP
|
||
END FUNCTION
|
||
|
||
FUNCTION ARCSECH (x) ' Inverse Hyperbolic Secant
|
||
IF x > 0 AND x <= 1 THEN ARCSECH = LOG((SGN(x) * SQR(1 - x * x) + 1) / x) ELSE BEEP
|
||
END FUNCTION
|
||
|
||
FUNCTION ARCCSCH (x) ' Inverse Hyperbolic CoSecant
|
||
IF x <> 0 AND x * x + 1 >= 0 AND (SGN(x) * SQR(x * x + 1) + 1) / x > 0 THEN
|
||
ARCCSCH = LOG((SGN(x) * SQR(x * x + 1) + 1) / x)
|
||
ELSE
|
||
BEEP
|
||
END IF
|
||
END FUNCTION
|
||
|
||
FUNCTION ARCCOTH (x) ' Inverse Hyperbolic CoTangent
|
||
IF x > 1 THEN ARCCOTH = LOG((x + 1) / (x - 1)) / 2 ELSE BEEP
|
||
END FUNCTION
|
||
|
||
```
|
||
|
||
```text
|
||
|
||
**Hyperbolic Function Relationships:**
|
||
|
||
COSH(-x) = COSH(x)
|
||
SINH(-x) = -SINH(x)
|
||
|
||
SECH(-x) = SECH(x)
|
||
CSCH(-x) = -CSCH(x)
|
||
TANH(-x) = -TANH(x)
|
||
COTH(-x) = -COTH(x)
|
||
|
||
**Inverse Hyperbolic Function Relatonships:**
|
||
|
||
ARSECH(x) = ARCOSH(x) ^ -1
|
||
ARCSCH(x) = ARSINH(x) ^ -1
|
||
ARCOTH(x) = ARTANH(x) ^ -1
|
||
|
||
**Hyperbolic sine and cosine satisfy the Pythagorean trig. identity:**
|
||
|
||
(COSH(x) ^ 2) - (SINH(x) ^ 2) = 1
|
||
|
||
```
|
||
|
||
[Microsoft's Derived BASIC Functions (KB 28249)](http://support.microsoft.com/kb/28249)
|
||
|
||
## Mathematical Logical Operators
|
||
|
||
The following logical operators compare numerical values using bitwise operations. The two numbers are compared by the number's [Binary](Binary) bits on and the result of the operation determines the value returned in decimal form. [NOT](NOT) checks one value and returns the opposite. It returns 0 if a value is not 0 and -1 if it is 0. See [Binary](Binary) for more on bitwise operations.
|
||
|
||
**Truth table of the 6 BASIC Logical Operators**
|
||
|
||
The results of the bitwise logical operations, where *A* and *B* are operands, and *T* and *F* indicate that a bit is set or not set:
|
||
|
||
| A | B | | [NOT](NOT) B | A [AND](AND) B | A [OR](OR) B | A [XOR](XOR) B | A [EQV](EQV) B | A [IMP](IMP) B |
|
||
| - | - | - | - | - | - | - | - | - |
|
||
| T | T | | F | T | T | F | T | T |
|
||
| T | F | | T | F | T | T | F | F |
|
||
| F | T | | F | F | T | T | F | T |
|
||
| F | F | | T | F | F | F | T | T |
|
||
|
||
**[Relational Operations](Relational-Operations) return negative one (-1, all bits set) and zero (0, no bits set) for *true* and *false*, respectively.**
|
||
|
||
This allows relational tests to be inverted and combined using the bitwise logical operations.
|
||
|
||
BASIC can accept any + or - value that is not 0 to be True when used in an evaluation.
|
||
|
||
## Relational Operators
|
||
|
||
Relational Operations are used to compare values in a Conditional [IF...THEN](IF...THEN), [SELECT CASE](SELECT-CASE), [UNTIL](UNTIL) or [WHILE](WHILE) statement.
|
||
|
||
**Relational Operators:**
|
||
|
||
| Symbol | Condition | Example Usage |
|
||
| -- | -- | -- |
|
||
| = | Equal | IF a = b THEN |
|
||
| <> | NOT equal | IF a <> b THEN |
|
||
| < | Less than | IF a < b THEN |
|
||
| > | Greater than | IF a > b THEN |
|
||
| <= | Less than or equal | IF a <= b THEN |
|
||
| >= | Greater than or equal | IF a >= b THEN |
|
||
|
||
## Basic's Rounding Functions
|
||
|
||
> Rounding is used when the program needs a certain number value or type. There are 4 [INTEGER](INTEGER) or [LONG](LONG) Integer functions and one function each for closest [SINGLE](SINGLE) and closest [DOUBLE](DOUBLE) numerical types. Closest functions use "bankers" rounding which rounds up if the decimal point value is over one half. Variable types should match the return value.
|
||
|
||
| Name | Description |
|
||
| -- | -- |
|
||
| INT(n) | rounds down to lower Integer value whether positive or negative |
|
||
| FIX(n) | rounds positive values lower and negative to a less negative Integer value |
|
||
| CINT(n) | rounds to closest Integer. Rounds up for decimal point values over one half. |
|
||
| CLNG(n) | rounds Integer or Long values to closest value like CINT.(values over 32767) |
|
||
| CSNG(n) | rounds Single values to closest last decimal point value. |
|
||
| CDBL(n) | rounds Double values to closest last decimal point value. |
|
||
| _ROUND(n) | rounds to closest numerical integer value. |
|
||
|
||
### Note
|
||
|
||
* Each of the above functions define the value's type in addition to rounding the values.
|
||
|
||
## Base Number Systems
|
||
|
||
```text
|
||
|
||
**Comparing the [INTEGER](INTEGER) Base Number Systems**
|
||
|
||
**Decimal (base 10) Binary (base 2) Hexadecimal (base 16) Octal (base 8)**
|
||
|
||
** [&B](&B) [&H](&H) [HEX$](HEX$)(n) [&O](&O) [OCT$](OCT$)(n)**
|
||
|
||
0 0000 0 0
|
||
1 0001 1 1
|
||
2 0010 2 2
|
||
3 0011 3 3
|
||
4 0100 4 4
|
||
5 0101 5 5
|
||
6 0110 6 6
|
||
7 0111 7 7 -- maxed
|
||
8 1000 8 10
|
||
maxed-- 9 1001 9 11
|
||
10 1010 A 12
|
||
11 1011 B 13
|
||
12 1100 C 14
|
||
13 1101 D 15
|
||
14 1110 E 16
|
||
15 ------------- 1111 <--- Match ---> F ---------------- 17 -- max 2
|
||
16 10000 10 20
|
||
|
||
When the Decimal value is 15, the other 2 base systems are all maxed out!
|
||
The Binary values can be compared to all of the HEX value digit values so
|
||
it is possible to convert between the two quite easily. To convert a HEX
|
||
value to Binary just add the 4 binary digits for each HEX digit place so:
|
||
|
||
F A C E
|
||
&HFACE = 1111 + 1010 + 1100 + 1101 = &B1111101011001101
|
||
|
||
To convert a Binary value to HEX you just need to divide the number into
|
||
sections of four digits starting from the right(LSB) end. If one has less
|
||
than 4 digits on the left end you could add the leading zeros like below:
|
||
|
||
&B101011100010001001 = 0010 1011 1000 1000 1001
|
||
hexadecimal = 2 + B + 8 + 8 + 9 = &H2B889
|
||
|
||
See the Decimal to Binary conversion function that uses **[HEX$](HEX$)** on the **[&H](&H)** page.
|
||
|
||
|
||
```
|
||
|
||
**[VAL](VAL) converts [STRING](STRING) numbers to Decimal values.**
|
||
|
||
* VAL reads the string from left to right and converts numerical string values, - and . to decimal values until it finds a character other than those 3 characters. Commas are not read.
|
||
* HEXadecimal and OCTal base values can be read with [&H](&H) or [&O](&O).
|
||
|
||
**The [OCT$](OCT$) [STRING](STRING) function return can be converted to a decimal value using [VAL](VAL)("&O" + OCT$(n)).**
|
||
|
||
**The [HEX$](HEX$) [STRING](STRING) function return can be converted to a decimal value using [VAL](VAL)("&H" + HEX$(n)).**
|
||
|
||
> [STR$](STR$) converts numerical values to string characters for [PRINT](PRINT) or variable strings. It also removes the right number PRINT space.
|
||
|
||
## Bits and Bytes
|
||
|
||
**[_BIT](_BIT)**
|
||
|
||
The **MSB** is the most significant(largest) bit value and **LSB** is the least significant bit of a binary or register memory address value. The order in which the bits are read determines the binary or decimal byte value. There are two common ways to read a byte:
|
||
|
||
* **"Big-endian"**: MSB is the first bit encountered, decreasing to the LSB as the last bit by position, memory address or time.
|
||
* **"Little-endian"**: LSB is the first bit encountered, increasing to the MSB as the last bit by position, memory address or time.
|
||
|
||
```text
|
||
|
||
**Offset or Position: 0 1 2 3 4 5 6 7 Example: 11110000**
|
||
---------------------------------- --------
|
||
**Big-Endian Bit On Value:** 128 64 32 16 8 4 2 1 240
|
||
**Little-Endian Bit On Value:** 1 2 4 8 16 32 64 128 15
|
||
|
||
```
|
||
|
||
> The big-endian method compares exponents of 2<sup>7</sup> down to 2<sup>0</sup> while the little-endian method does the opposite.
|
||
|
||
**[_BYTE](_BYTE)**
|
||
|
||
[INTEGER](INTEGER) values consist of 2 bytes called the **HI** and **LO** bytes. Anytime that the number of binary digits is a multiple of 16 (2bytes, 4 bytes, etc.) and the HI byte's MSB is on(1), the value returned will be negative, even with [SINGLE](SINGLE) or [DOUBLE](DOUBLE) values.
|
||
|
||
```text
|
||
|
||
**16 BIT INTEGER OR REGISTER**
|
||
**AH (High Byte Bits) AL (Low Byte Bits)**
|
||
BIT: 15 14 13 12 11 10 9 8 | 7 6 5 4 3 2 1 0
|
||
---------------------------------------|--------------------------------------
|
||
HEX: 8000 4000 2000 1000 800 400 200 100 | 80 40 20 10 8 4 2 1
|
||
|
|
||
DEC: -32768 16384 8192 4096 2048 1024 512 256 | 128 64 32 16 8 4 2 1
|
||
|
||
```
|
||
|
||
> The HI byte's **MSB** is often called the **sign** bit! When the highest bit is on, the signed value returned will be negative.
|
||
|
||
## Example(s)
|
||
|
||
Program displays the bits on for any integer value between -32768 and 32767 or &H80000 and &H7FFF.
|
||
|
||
```vb
|
||
|
||
DEFINT A-Z
|
||
SCREEN 12
|
||
COLOR 11: LOCATE 10, 2
|
||
PRINT " AH (High Register Byte Bits) AL (Low Register Byte Bits)"
|
||
COLOR 14: LOCATE 11, 2
|
||
PRINT " 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0"
|
||
COLOR 13: LOCATE 14, 2
|
||
PRINT " &H8000 4000 2000 1000 800 400 200 100 80 40 20 10 8 4 2 &H1"
|
||
COLOR 11: LOCATE 15, 2
|
||
PRINT "-32768 16384 8192 4096 2048 1024 512 256 128 64 32 16 8 4 2 1"
|
||
FOR i = 1 TO 16
|
||
CIRCLE (640 - (37 * i), 189), 8, 9 'place bit circles
|
||
NEXT
|
||
LINE (324, 160)-(326, 207), 11, BF 'line splits bytes
|
||
DO
|
||
IF Num THEN
|
||
FOR i = 15 TO 0 STEP -1
|
||
IF (Num AND 2 ^ i) THEN
|
||
PAINT (640 - (37 * (i + 1)), 189), 12, 9
|
||
Bin$ = Bin$ + "1"
|
||
ELSE
|
||
PAINT (640 - (37 * (i + 1)), 189), 0, 9
|
||
Bin$ = Bin$ + "0"
|
||
END IF
|
||
NEXT
|
||
COLOR 10: LOCATE 16, 50: PRINT "Binary ="; VAL(Bin$)
|
||
COLOR 9: LOCATE 16, 10: PRINT "Decimal ="; Num;: COLOR 13: PRINT " Hex = "; Hexa$
|
||
Hexa$ = "": Bin$ = ""
|
||
END IF
|
||
COLOR 14: LOCATE 17, 15: INPUT "Enter a decimal or HEX(&H) value (0 Quits): ", frst$
|
||
first = VAL(frst$)
|
||
IF first THEN
|
||
LOCATE 17, 15: PRINT SPACE$(55)
|
||
COLOR 13: LOCATE 17, 15: INPUT "Enter a second value: ", secnd$
|
||
second = VAL(secnd$)
|
||
LOCATE 17, 10: PRINT SPACE$(69)
|
||
END IF
|
||
Num = first + second
|
||
Hexa$ = "&H" + HEX$(Num)
|
||
LOOP UNTIL first = 0 OR Num > 32767 OR Num < -32767
|
||
COLOR 11: LOCATE 28, 30: PRINT "Press any key to exit!";
|
||
SLEEP
|
||
SYSTEM
|
||
|
||
```
|
||
|
||
## OFFSET
|
||
|
||
* [_OFFSET (function)](_OFFSET-(function)) returns the memory offset position as a flexible sized value for a designated variable. See [Using _OFFSET](Using--OFFSET).
|
||
|
||
**Warning: [_OFFSET](_OFFSET) values cannot be reassigned to other variable [TYPE](TYPE).**
|
||
|
||
**[_OFFSET](_OFFSET) values can only be used in conjunction with [_MEM](_MEM)ory and [DECLARE DYNAMIC LIBRARY](DECLARE-DYNAMIC-LIBRARY) procedures.**
|
||
|
||
## See Also
|
||
|
||
* [_OFFSET](_OFFSET), [_MEM](_MEM)
|
||
* [DIM](DIM), [_DEFINE](_DEFINE)
|
||
* [TYPE](TYPE)
|