Difference between revisions of "Mathematical Operations"

From QB64 Wiki
Jump to navigation Jump to search
imported>Clippy
m
imported>SMcNeill
(→‎OFFSET: style guidelines)
 
(125 intermediate revisions by 4 users not shown)
Line 1: Line 1:
 +
{| align="center"
 +
  | __TOC__
 +
  |}
 +
 +
==Basic and QB64 Numerical Types==
 +
<center>'''Qbasic Number Types'''</center>
 +
 +
* [[INTEGER]] ['''%''']: 2 Byte signed whole number values from -32768 to 32767. 0 to 65535 unsigned. (not checked in QB64)
 +
* [[LONG]] ['''&''']: 4 byte signed whole number values from -2147483648 to 2147483647. 0 to 4294967295 unsigned.
 +
* [[SINGLE]] ['''!''']: 4 byte signed floating decimal point values of up to 7 decimal place accuracy. '''Cannot be unsigned.'''
 +
* [[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]] [[STRING]] character to represent values from 0 to 255 as in [[BINARY]] files.
 +
 +
 +
<center>'''QB64 Number Types'''</center>
 +
 +
* [[_BIT]] ['''`''']: 1 bit signed whole number values of 0 or -1 signed or 0 or 1 unsigned. [[_BIT]] * 8 can hold a signed or unsigned [[_BYTE|byte]] value.
 +
* [[_BYTE]] ['''%%''']: 1 byte signed whole number values from -128 to 127. Unsigned values from 0 to 255.
 +
* [[_INTEGER64]] ['''&&''']: 8 byte signed whole number values from -9223372036854775808 to 9223372036854775807
 +
* [[_FLOAT]] [##]: currently set as 10 byte signed floating decimal point values up to 1.1897E+4932. '''Cannot be unsigned.'''
 +
* [[_OFFSET]] [%&]: undefined flexable length integer offset values used in [[DECLARE DYNAMIC LIBRARY]] declarations.
 +
 +
 +
<center>'''Signed and Unsigned Integer Values'''</center>
 +
 +
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]](n) returns the value's sign as -1 if negative, 0 if zero or 1 if positive.
 +
::::* [[ABS]](n) changes negative values to the equivalent positive values.
 +
::::* '''QB64:''' [[_UNSIGNED]] in a [[DIM]], [[AS]] or [[_DEFINE]] statement for only positive [[INTEGER]] values.
 +
 +
 +
[[_UNSIGNED]] integer, byte and bit variable values can use the tilde ~ suffix before the type suffix to define the type.
 +
 +
 +
<center>[[#toc|Return to Top]]</center>
 +
 +
==Mathematical Operation Symbols==
 
Most of the BASIC math operators are ones that require no introduction. The addition, subtraction, multplication and division operators are ones commonly used as shown below:
 
Most of the BASIC math operators are ones that require no introduction. The addition, subtraction, multplication and division operators are ones commonly used as shown below:
 
  
 
{| align="center" border=1  
 
{| align="center" border=1  
 
! Symbol  
 
! Symbol  
! Name
+
! Procedure Type
! Usage Example
+
! Example Usage
 +
! Operation Order
 
|-  
 
|-  
| + || Addition || c = a + b
+
| align="center" |[[+]] ||  Addition || align="center" | c = a + b  || align="center" | Last
 
|-
 
|-
| - || Subtraction || c = a - b
+
| align="center" |[[-]] ||  Subtraction  || align="center" | c = a - b || align="center" | Last
 
|-
 
|-
| - || Negation || c = - a
+
| align="center" |[[-]] ||  Negation  || align="center" | c = - a || align="center" | Last
 
|-  
 
|-  
| * || Multiplication || c = a * b
+
| align="center" |[[*]] ||  Multiplication || align="center" | c = a * b || align="center" | Second
 
|-
 
|-
| / || Division || c = a / b
+
| align="center" |[[/]] ||  Division  || align="center" | c = a / b || align="center" | Second
 
|}
 
|}
  
  
 +
BASIC can also use two other operators for '''[[INTEGER]] division'''. Integer division returns only whole number values. [[MOD]] '''remainder division''' returns a value only if an integer division cannot divide a number exactly. Returns 0 if a value is exactly divisible.
  
BASIC can also use two other operators for [[INTEGER]] division. Integer division returns only whole number values. MOD remainder division returns a value only if an integer division cannot divide a number exactly. Returns 0 if exactly divisible.
 
  
 
{| align="center" border=1
 
{| align="center" border=1
 
!Symbol
 
!Symbol
!Name
+
!Procedure Type
!Usage Example
+
!Example Usage
 +
!Operation Order
 
|-
 
|-
| \ || Integer division || c = a \ b
+
| align="center" |[[\]] ||  Integer division || align="center" | c = a \ b || align="center" | Second
 
|-
 
|-
| [[MOD]] || Remainder division || c = a MOD b
+
| align="center" |[[MOD]] ||  Remainder division  || align="center" | c = a MOD b || align="center" | Second
 
|}
 
|}
  
It is an error to divide by zero or to take the remainder modulo zero.
 
  
 +
<center>'''''It is an [[ERROR|error]] to divide by zero or to take the remainder modulo zero.'''''</center>
  
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]] values. The [[SQR]] function can return a number's Square Root. For other roots the exponential operator can be used with fractions such as (1 / 3) designating the cube root of a number. '''''Note that the fraction should be parenthesized in order for it to be treated as a fraction rather than a division of the result of the exponentiation by the denominator.''''' 
+
 
 +
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]] values. The [[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.  
  
  
 
{| align="center" border=1
 
{| align="center" border=1
 
!Symbol
 
!Symbol
!Name
+
!Procedure
!Usage Example
+
!Example Usage  
 +
!Operation Order
 
|-
 
|-
| ^ || Exponent || c = SQR(a ^ 2 + b ^ 2)
+
| align="center" |[[^]] || Exponent || align="center" | c = a [[^]] (1 / 2) || align="center" | First
 +
|-
 +
| align="center" | [[SQR]] || Square Root || align="center" | c = [[SQR]](a [[^]] 2 + b [[^]] 2) || align="center" | 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.
 +
 +
 +
<center>[[#toc|Return to Top]]</center>
  
 
==Basic's Order of Operations==
 
==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:
 
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
 
# Negation (Note that this means that <tt>- 3 ^ 2</tt> is treated as <tt>-(3 ^ 2)</tt> and not as <tt>(-3) ^ 2</tt>.)
 
# Multiplication and Division calculations
 
# Addition and Subtraction calculations
 
  
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 around parts of the equation. BASIC will do those calculations first and the others from left to right in the operation order.
 
  
 +
:::# Exponential and exponential Root calculations including [[SQR]].
 +
:::# Negation (Note that this means that ''- 3 ^ 2'' is treated as ''-(3 ^ 2)'' and not as ''(-3) ^ 2.)''
 +
:::# Multiplication, normal Division, [[INTEGER]] Division and Remainder([[MOD]]) Division calculations
 +
:::# Addition and Subtraction calculations
 +
 +
 +
<center>'''Using Parenthesis to Define the Operation Order'''</center>
 +
 +
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]] around parts of the equation. BASIC will do the calculations inside of the [[parenthesis]] brackets  first and the others from left to right in the normal operation order.
  
===Basic's Mathematical Functions===
+
==Basic's Mathematical Functions==
  
 
{| align=center border=1
 
{| align=center border=1
Line 65: Line 118:
 
  ! Description
 
  ! Description
 
  |-
 
  |-
  | [[ABS]](n) || returns the absolute (positive) value of n (ABS(-5) = 5)
+
  | [[ABS]](n) || returns the absolute (positive) value of n: ABS(-5) = 5
 
  |-  
 
  |-  
  | [[ATN]](angle) || returns the arctangent of a radian angle (π = 4 * ATN(1))
+
  | [[ATN]](angle*) || returns the arctangent of an angle in radians: π = 4 * ATN(1)
 
  |-
 
  |-
  | [[COS]](angle) || returns the cosine of a radian angle (horizontal ratio)
+
  | [[COS]](angle*) || returns the cosine of an angle in radians. (horizontal component)
 
  |-
 
  |-
  | [[EXP]](n) || returns the exponent of n  
+
  | [[EXP]](n) || returns e<sup>x</sup>, '''(n <= 88.02969)''': e = EXP(1) ' (e = 2.718281828459045)
 
  |-
 
  |-
  | [[LOG]](n) || returns the natural logarithm of n (n > 0)
+
  | [[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)
+
  | [[SGN]](n) || returns -1 if n < 0, 0 if n = 0, 1 if n > 0: SGN(-5) = -1
 
  |-
 
  |-
  | [[SIN]](angle) || returns the sine of a radian angle (vertical ratio)
+
  | [[SIN]](angle*) || returns the sine of an angle in radians. (vertical component)
 
  |-
 
  |-
  | [[SQR]] || returns the square root of a number. It is an error to pass SQR a negative value.
+
  | [[SQR]](n) || returns the square root of a number. '''(n >= 0)'''
 
  |-
 
  |-
  | [[TAN]](angle) ||  returns the tangent of a radian angle
+
  | [[TAN]](angle*) ||  returns the tangent of an angle in radians
 
  |}
 
  |}
  
:::''Note: To convert from degrees to radians use: radians = degrees * (3.14159 / 180)''
+
<center> '''* angles measured in radians'''</center>
 +
 
 +
 
 +
{{TextStart}}                                '''Degree to Radian Conversion:'''
 +
FUNCTION Radian (degrees)
 +
Radian = degrees * (4 * {{Cb|ATN}}(1)) / 180
 +
END FUNCTION '' ''
 +
 
 +
FUNCTION Degree (radians)
 +
Degree = radians * 180 / (4 * {{Cb|ATN}}(1))
 +
END FUNCTION
 +
 
 +
                                    '''Logarithm to base n'''
 +
FUNCTION LOGN (X, n)   
 +
IF n > 0 AND n <> 1 AND X > 0 THEN LOGN = {{Cb|LOG}}(X) / {{Cb|LOG}}(n) ELSE BEEP
 +
END FUNCTION '' ''
 +
 
 +
FUNCTION LOG10 (X)    'base 10 logarithm
 +
IF X > 0 THEN LOG10 = {{Cb|LOG}}(X) / {{Cb|LOG}}(10) ELSE BEEP
 +
END FUNCTION '' ''
 +
{{TextEnd}}
 +
 
 +
 
 +
<center>'''The numerical value of n in the [[LOG]](n) evaluation must be a positive value.'''</center>
 +
 
 +
<center>'''The numerical value of n in the [[EXP]](n) evaluation must be less than or equal to 88.02969.'''</center>
 +
 
 +
<center>'''The numerical value of n in the [[SQR]](n) evaluation ''cannot'' be a negative value.'''</center>
 +
 
 +
 
 +
<center>[[#toc|Return to Top]]</center>
 +
 
 +
==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]] 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]](1) for [[SINGLE]] accuracy. Use [[ATN]](1.#) for [[DOUBLE]] accuracy.
 +
 
 +
 
 +
{{TextStart}}'' ''
 +
FUNCTION SEC (x)  'Secant
 +
IF COS(x) <> 0 THEN SEC = 1 / {{Cb|COS}}(x) ELSE BEEP
 +
END FUNCTION
 +
 
 +
FUNCTION CSC (x)  'CoSecant
 +
IF SIN(x) <> 0 THEN CSC = 1 / {{Cb|SIN}}(x) ELSE BEEP
 +
END FUNCTION
 +
 
 +
FUNCTION COT (x)  'CoTangent
 +
IF TAN(x) <> 0 THEN COT = 1 / {{Cb|TAN}}(x) ELSE BEEP
 +
END FUNCTION
 +
 
 +
FUNCTION ARCSIN (x)  'Inverse Sine         
 +
IF x < 1 THEN ARCSIN = {{Cb|ATN}}(x / {{Cb|SQR}}(1 - (x * x))) ELSE BEEP
 +
END FUNCTION
 +
 
 +
FUNCTION ARCCOS (x) ' Inverse Cosine
 +
IF x < 1 THEN ARCCOS = (2 * ATN(1)) - {{Cb|ATN}}(x / {{Cb|SQR}}(1 - x * x)) ELSE BEEP
 +
END FUNCTION
 +
 
 +
FUNCTION ARCSEC (x)  ' Inverse Secant       
 +
IF x < 1 THEN ARCSEC = {{Cb|ATN}}(x / {{Cb|SQR}}(1 - x * x)) + ({{Cb|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 * {{Cb|ATN}}(1)) - {{Cb|ATN}}(x)
 +
END FUNCTION '' ''
 +
 
 +
FUNCTION SINH (x)  ' Hyperbolic Sine
 +
IF x <= 88.02969 THEN SINH = ({{Cb|EXP}}(x) - {{Cb|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 = ({{Cb|EXP}}(2 * x) - 1) / ({{Cb|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 / ({{Cb|EXP}}(x) + {{Cb|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 / ({{Cb|EXP}}(x) - {{Cb|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 = ({{Cb|EXP}}(2 * x) + 1) / ({{Cb|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 = {{Cb|LOG}}(x + {{Cb|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 = {{Cb|LOG}}(x + {{Cb|SQR}}(x * x - 1))
 +
ELSE BEEP
 +
END IF
 +
END FUNCTION '' ''
 +
 
 +
FUNCTION ARCTANH (x)  ' Inverse Hyperbolic Tangent
 +
IF x < 1 THEN ARCTANH = {{Cb|LOG}}((1 + x) / (1 - x)) / 2 ELSE BEEP
 +
END FUNCTION
 +
 
 +
FUNCTION ARCSECH (x)  ' Inverse Hyperbolic Secant
 +
IF x > 0 AND x <= 1 THEN ARCSECH = {{Cb|LOG}}(({{Cb|SGN}}(x) * {{Cb|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 = {{Cb|LOG}}(({{Cb|SGN}}(x) * {{Cb|SQR}}(x * x + 1) + 1) / x)
 +
ELSE BEEP
 +
END IF
 +
END FUNCTION '' ''
 +
 
 +
FUNCTION ARCCOTH (x)  ' Inverse Hyperbolic CoTangent
 +
IF x > 1 THEN ARCCOTH = {{Cb|LOG}}((x + 1) / (x - 1)) / 2 ELSE BEEP
 +
END FUNCTION '' ''
 +
{{TextEnd}}
 +
{{WhiteStart}}
 +
                          '''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
 +
 
 +
{{WhiteEnd}}
  
==Signed and Unsigned Numerical Values==
+
<center>[http://support.microsoft.com/kb/28249 Microsoft's Derived BASIC Functions (KB 28249)]</center>
  
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]](n) returns the value's sign as -1, 0 or 1
+
<center>[[#toc|Return to Top]]</center>
* [[ABS]](n) changes negative values to positive ones
 
* '''QB64:''' [[_UNSIGNED]] in a [[DIM]], [[AS]] or [[_DEFINE]] statement for only positive values.
 
  
==Mathematical Logical operators==
+
==Mathematical Logical Operators==
  
: The following logical operators compare numerical values using bitwise operations. The two numbers are compared by the number's [[Binary]] bits on and the result of the operation determines the value returned in decimal form. [[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]] for more on bitwise operations.
+
The following logical operators compare numerical values using bitwise operations. The two numbers are compared by the number's [[Binary]] bits on and the result of the operation determines the value returned in decimal form. [[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]] for more on bitwise operations.
  
  
=== Truth table of the 6 BASIC Logical Operators ===
+
<center>'''Truth table of the 6 BASIC Logical Operators'''</center>
  
  
 
{{Template:LogicalTruthTable}}
 
{{Template:LogicalTruthTable}}
  
::: BASIC can accept any + or - value that is not 0 to be True when used in an evaluation.
+
<center>BASIC can accept any + or - value that is not 0 to be True when used in an evaluation.</center>
 +
 
 +
 
 +
<center>[[#toc|Return to Top]]</center>
 +
 
 +
==Relational Operators==
 +
Relational Operations are used to compare values in a Conditional [[IF...THEN]], [[SELECT CASE]], [[UNTIL]] or [[WHILE]] statement.
 +
 
 +
 
 +
{{Template:RelationalTable}}
 +
 
 +
 
 +
<center>[[#toc|Return to Top]]</center>
  
 
==Basic's Rounding Functions==
 
==Basic's Rounding Functions==
Line 127: Line 344:
 
| [[CDBL]](n) || rounds Double values to closest last decimal point value.
 
| [[CDBL]](n) || rounds Double values to closest last decimal point value.
 
|-
 
|-
| [[_ROUND]] || rounds to closest numerical value in '''QB64'''.
+
| [[_ROUND]] || rounds to closest numerical integer value in '''QB64''' only.
 
|}
 
|}
  
::: '''Note: Each of the above functions define the value's type in addition to rounding the values.'''
+
===Note===
 +
* Each of the above functions define the value's type in addition to rounding the values.
 +
 
 +
<center>[[#toc|Return to Top]]</center>
 +
 
 +
==Base Number Systems==
 +
 
 +
 
 +
{{TextStart}}
 +
                  '''Comparing the [[INTEGER]] Base Number Systems'''
 +
 
 +
  '''Decimal (base 10)    Binary (base 2)    Hexadecimal (base 16)    Octal (base 8)'''
 +
 
 +
                          '''  [[&B]]                [[&H]] [[HEX$]](n)          [[&O]] [[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$]]''' on the '''[[&H]]''' page.
 +
 +
{{TextEnd}}
 +
 
 +
 
 +
<center>'''[[VAL]] converts [[STRING|string]] numbers to Decimal values.'''</center>
 +
 
 +
* 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]] or [[&O]].
 +
 
 +
 
 +
<center>'''The [[OCT$]] [[STRING|string]] function return can be converted to a decimal value using [[VAL]]("&O" + OCT$(n)).'''</center>
 +
 
 +
<center>'''The [[HEX$]] [[STRING|string]] function return can be converted to a decimal value using [[VAL]]("&H" + HEX$(n)).'''</center>
 +
 
 +
 
 +
:[[STR$]] converts numerical values to string characters for [[PRINT]] or variable strings. It also removes the right number PRINT space.
 +
 
 +
 
 +
 
 +
<center>[[#toc|Return to Top]]</center>
 +
 
 +
==Bits and Bytes==
 +
 
 +
<center>'''[[_BIT|BITS]]'''</center>
 +
* 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.
 +
{{WhiteStart}}
 +
        '''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
 +
{{WhiteEnd}}
 +
::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.
 +
 
 +
<center>'''[[_BYTE|BYTES]]'''</center>
 +
* [[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]] or [[DOUBLE]] values.
 +
{{WhiteStart}}                                '''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
 +
{{WhiteEnd}}
 +
::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:'' Program displays the bits on for any integer value between -32768 and 32767 or &H80000 and &H7FFF.
 +
{{CodeStart}} '' ''
 +
{{Cl|DEFINT}} A-Z
 +
{{Cl|SCREEN (statement)|SCREEN}} 12
 +
{{Cl|COLOR}} 11: {{Cl|LOCATE}} 10, 2
 +
{{Cl|PRINT}} "      AH (High Register Byte Bits)          AL (Low Register Byte Bits)"
 +
{{Cl|COLOR}} 14: {{Cl|LOCATE}} 11, 2
 +
{{Cl|PRINT}} "    15  14  13  12  11  10    9  8    7  6    5  4    3    2  1    0"
 +
{{Cl|COLOR}} 13: {{Cl|LOCATE}} 14, 2
 +
{{Cl|PRINT}} " {{Cl|&H}}8000 4000 2000 1000 800 400  200 100  80  40  20  10  8    4  2  {{Cl|&H}}1"
 +
{{Cl|COLOR}} 11: {{Cl|LOCATE}} 15, 2
 +
{{Cl|PRINT}} "-32768 16384 8192 4096 2048 1024 512 256 128  64  32  16  8    4  2    1"
 +
{{Cl|FOR...NEXT|FOR}} i = 1 {{Cl|TO}} 16
 +
  {{Cl|CIRCLE}} (640 - (37 * i), 189), 8, 9 'place bit circles
 +
{{Cl|NEXT}}
 +
{{Cl|LINE}} (324, 160)-(326, 207), 11, BF 'line splits bytes
 +
{{Cl|DO}}
 +
  {{Cl|IF}} Num {{Cl|THEN}}
 +
    {{Cl|FOR...NEXT|FOR}} i = 15 {{Cl|TO}} 0 {{Cl|STEP}} -1
 +
      {{Cl|IF}} (Num {{Cl|AND}} 2 ^ i) {{Cl|THEN}}
 +
        {{Cl|PAINT}} (640 - (37 * (i + 1)), 189), 12, 9
 +
        Bin$ = Bin$ + "1"
 +
      {{Cl|ELSE}}
 +
        {{Cl|PAINT}} (640 - (37 * (i + 1)), 189), 0, 9
 +
        Bin$ = Bin$ + "0"
 +
      {{Cl|END IF}}
 +
    {{Cl|NEXT}}
 +
    {{Cl|COLOR}} 10: {{Cl|LOCATE}} 16, 50: {{Cl|PRINT}} "Binary ="; {{Cl|VAL}}(Bin$)
 +
    {{Cl|COLOR}} 9: {{Cl|LOCATE}} 16, 10: {{Cl|PRINT}} "Decimal ="; Num;: {{Cl|COLOR}} 13: {{Cl|PRINT}} "      Hex = "; Hexa$
 +
    Hexa$ = "": Bin$ = ""
 +
  {{Cl|END IF}}
 +
  {{Cl|COLOR}} 14: {{Cl|LOCATE}} 17, 15: {{Cl|INPUT}} "Enter a decimal or HEX({{Cl|&H}}) value (0 Quits): ", frst$
 +
  first = {{Cl|VAL}}(frst$) 
 +
  {{Cl|IF}} first {{Cl|THEN}}
 +
    {{Cl|LOCATE}} 17, 15: {{Cl|PRINT}} {{Cl|SPACE$}}(55)
 +
    {{Cl|COLOR}} 13: {{Cl|LOCATE}} 17, 15: {{Cl|INPUT}} "Enter a second value: ", secnd$
 +
    second = {{Cl|VAL}}(secnd$)
 +
    {{Cl|LOCATE}} 17, 10: {{Cl|PRINT}} {{Cl|SPACE$}}(69)
 +
  {{Cl|END IF}}
 +
  Num = first + second
 +
  Hexa$ = "{{Cl|&H}}" + {{Cl|HEX$}}(Num)
 +
{{Cl|LOOP}} {{Cl|UNTIL}} first = 0 {{Cl|OR (boolean)|OR}} Num > 32767 {{Cl|OR (boolean)|OR}} Num < -32767
 +
{{Cl|COLOR}} 11: {{Cl|LOCATE}} 28, 30: {{Cl|PRINT}} "Press any key to exit!";
 +
{{Cl|SLEEP}}
 +
{{Cl|SYSTEM}} '' ''
 +
{{CodeEnd}}
 +
{{small|Code by Ted Weissgerber}}
 +
 
 +
 
 +
<center>[[#toc|Return to Top]]</center>
 +
 
 +
==OFFSET==
 +
 
 +
* [[_OFFSET (function)]] returns the memory offset position as a flexible sized value for a designated variable. See [[Using _OFFSET]].
 +
 
 +
 
 +
<center>'''Warning: [[_OFFSET]] values cannot be reassigned to other variable [[TYPE|types]].'''</center>
 +
 
 +
 
 +
<center>'''[[_OFFSET]] values can only be used in conjunction with [[_MEM]]ory and [[DECLARE DYNAMIC LIBRARY]] procedures.'''</center>
 +
 
 +
==References==
 +
''See also:''
 +
* [[_OFFSET]], [[_MEM]]
 +
* [[DIM]], [[_DEFINE]]
 +
* [[TYPE]]
 +
 
 +
{{PageNavigation}}

Latest revision as of 23:28, 4 September 2017

Basic and QB64 Numerical Types

Qbasic Number Types
  • INTEGER [%]: 2 Byte signed whole number values from -32768 to 32767. 0 to 65535 unsigned. (not checked in QB64)
  • LONG [&]: 4 byte signed whole number values from -2147483648 to 2147483647. 0 to 4294967295 unsigned.
  • SINGLE [!]: 4 byte signed floating decimal point values of up to 7 decimal place accuracy. Cannot be unsigned.
  • 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 STRING character to represent values from 0 to 255 as in BINARY files.


QB64 Number Types
  • _BIT [`]: 1 bit signed whole number values of 0 or -1 signed or 0 or 1 unsigned. _BIT * 8 can hold a signed or unsigned byte value.
  • _BYTE [%%]: 1 byte signed whole number values from -128 to 127. Unsigned values from 0 to 255.
  • _INTEGER64 [&&]: 8 byte signed whole number values from -9223372036854775808 to 9223372036854775807
  • _FLOAT [##]: currently set as 10 byte signed floating decimal point values up to 1.1897E+4932. Cannot be unsigned.
  • _OFFSET [%&]: undefined flexable length integer offset values used in 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(n) returns the value's sign as -1 if negative, 0 if zero or 1 if positive.
  • ABS(n) changes negative values to the equivalent positive values.
  • QB64: _UNSIGNED in a DIM, AS or _DEFINE statement for only positive INTEGER values.


_UNSIGNED integer, byte and bit variable values can use the tilde ~ suffix before the type suffix to define the type.


Return to Top

Mathematical Operation Symbols

Most of the BASIC math operators are ones that require no introduction. The addition, subtraction, multplication 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 division. Integer division returns only whole number values. 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 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 values. The 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.


Return to Top

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:


  1. Exponential and exponential Root calculations including SQR.
  2. Negation (Note that this means that - 3 ^ 2 is treated as -(3 ^ 2) and not as (-3) ^ 2.)
  3. Multiplication, normal Division, INTEGER Division and Remainder(MOD) Division calculations
  4. 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 around parts of the equation. BASIC will do the calculations inside of the 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: π = 4 * ATN(1)
COS(angle*) returns the cosine of an angle in radians. (horizontal component)
EXP(n) returns ex, (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: 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 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(n) evaluation must be a positive value.
The numerical value of n in the EXP(n) evaluation must be less than or equal to 88.02969.
The numerical value of n in the SQR(n) evaluation cannot be a negative value.


Return to Top

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 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(1) for SINGLE accuracy. Use ATN(1.#) for DOUBLE accuracy.


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

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)


Return to Top

Mathematical Logical Operators

The following logical operators compare numerical values using bitwise operations. The two numbers are compared by the number's Binary bits on and the result of the operation determines the value returned in decimal form. 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 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:
Operands Operations
A B NOT B A AND B A OR B A XOR B A EQV B A 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 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.


Return to Top

Relational Operators

Relational Operations are used to compare values in a Conditional IF...THEN, SELECT CASE, UNTIL or WHILE statement.


Relational Operators:
Symbol Condition Example Usage
<  Less than  IF a < b THEN
>  Greater than  IF a > b THEN
=  Equal  IF a = b THEN
<=  Less than or equal  IF a <= b THEN
>=  Greater than or equal  IF a >= b THEN
<>  NOT equal  IF a <> b THEN


Return to Top

Basic's Rounding Functions

Rounding is used when the program needs a certain number value or type. There are 4 INTEGER or LONG Integer functions and one function each for closest SINGLE and closest 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 rounds to closest numerical integer value in QB64 only.

Note

  • Each of the above functions define the value's type in addition to rounding the values.
Return to Top

Base Number Systems

Comparing the INTEGER Base Number Systems Decimal (base 10) Binary (base 2) Hexadecimal (base 16) Octal (base 8) &B &H HEX$(n) &O 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$ on the &H page.


VAL converts 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 or &O.


The OCT$ string function return can be converted to a decimal value using VAL("&O" + OCT$(n)).
The HEX$ string function return can be converted to a decimal value using VAL("&H" + HEX$(n)).


STR$ converts numerical values to string characters for PRINT or variable strings. It also removes the right number PRINT space.


Return to Top

Bits and Bytes

BITS
  • 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.

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 7 down to 2 0 while the little-endian method does the opposite.
BYTES
  • 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 or DOUBLE values.

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: Program displays the bits on for any integer value between -32768 and 32767 or &H80000 and &H7FFF.

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

Code by Ted Weissgerber


Return to Top

OFFSET


Warning: _OFFSET values cannot be reassigned to other variable types.


_OFFSET values can only be used in conjunction with _MEMory and DECLARE DYNAMIC LIBRARY procedures.

References

See also:



Navigation:
Go to Keyword Reference - Alphabetical
Go to Keyword Reference - By usage
Go to Main WIKI Page