Getting Started
Introduction
Sample Programs
IDEs
History
Advice
Mini-Tutorial
Tutorials
Code Snippets

Resources
Web Sites
More Tutorials
Forums
Vendors/Tools
Books
Magazines
Newsletters
NewsGroups
User Groups
Talk Shows
Blogs

Controls
Overview
Button
Check3State
Checkbox
ComboBox
Frame
Graphic
Image
ImageX
ImgButton
ImgButtonX
Label
Line
ListBox
ListView
Option
Progress Bar
Scrollbar
StatusBar
TAB
TextBox
Toolbar
TreeView

GBIC >> PowerBASIC >> Tutorials >> Arithmetic

PowerBASIC Information Center Tutorials
These tutorials were written to help you get a quick, but thorough, understanding of PowerBASIC - the scope of the language as well as it's specific capabilities.

Introduction       Projects       Language           Messages       Functions           Advanced
  • Overview
  • Examples
  • IDE
  • Compilation
  • Distribution
  • Project Files
  • DDT Windows
  • Controls
  • Menus
  • Dialogs  
  • Help Files
  • Resources  
  • Templates  
  • Project Shell  
  • Syntax
  • Operators
  • Data Types
  • Variables
  • Scope
  • Declarations  
  • Procedures
  • Flow Control
  • Windows
  • Messages
  • Callbacks
  • Mouse
  • Keyboard
  • Dialogs
  • Controls
  • Subclassing
  • Arithmetic
  • Trig  
  • Strings
  • Arrays
  • Date/Time
  • Printing
  • Files
  • Folders
  • Keyboard
  • Mouse
  • Sound
  • System
  • Error Traps
  • Debugging
  • Objects
  • Graphics
  • Databases
  • API
  • DLLs
  • ASM
  • Threads
  • Arithmetic Functions Summary
    PowerBASIC provides a reasonably complete set of arithmetic functions, which can be broken into the following categories. As you can see from the examples below, use of the functions is very simple and mostly self-explanatory.

      • Assignment
       let, reset 
      • Powers
       exp, exp2, exp10, sqr 
      • Logarithms
       log, log2, log10 
      • Base Conversions
       bin$, hex$, oct$ 
      • Random
       rnd, randomize 
      • Modify
       incr, decr 
      • Properties
       len, sizeof
      • Integer Result
       int, ceil, fix
      • Decimal Place Control  
       round
      • Multiple Variables
       min, max, swap 
      • Sign Operation
       abs, sgn 
      • Fraction/Remainder
       frac, mod 
      • Value Conversions
       val, variant#
      • Pointer
       varptr 

    E Notation
    PowerBASIC allows number to be written using E notation for powers of 10. "E", "e", "D", or "d" may be used at the separator between the coefficient number and the exponent of ten. The E/e refers to raising the coefficient to the power of 10, not the mathematical constant e.

    The use of E was popularized by the need for an easy way to express large and small numbers on calculators and computers, where 2.4E2 is easier to write than 2.4 x 10^2.

    Numeric Conversion Between Types
    In assignments and when passing parameter, PowerBASIC automatically converts a numeric values to the numeric type required, as in the following example.

        i% = a!     'single precision a! is converted to integer
        c& = f@     'currency type is converted to long integer
    

    However, PowerBASIC also provides a series of functions which can explicitly make these conversions. These are rarely used since PowerBASIC makes the conversions automatically. The conversion functions are:

        CBYT    CDBL    CINT    CSNG
        CCUR    CDWB    CLNG    CWRD
        CCUX    CEXT    CQUD
    
        i% = CINT(a!)  'same result as  i%=a!
    

    These functions should be self-explanatory as to the data type each returns. However, note that with the CINT/CLNG functions, when the fractional part of the number is exactly 0.5, the number is rounded to the nearest even number. This means a number ending in .5 may round up or down - not always up!

        CINT(0.5)    'returns 0, not 1  (nearest EVEN number)
        CINT(1.5)    'returns 2 (nearest EVEN number)
        CINT(2.5)    'returns 2, not 3
        CLNG(-4.7)   'returns -5
        CLNG(7.7)    'returns 7
    

    Note that while PowerBASIC will automatically convert between numeric data types, it will not automatically convert numeric values to strings. This has to be explicitly done by the program code.

    Clarification of Integer Functions
    The PowerBASIC functions dealing with integer - CINT, INT, FIX, CEIL, ROUND, CVI, and MKI$ - may seem obvious in their usage, but there are some nuances. Here are comparisons on how these functions round various numbers, including negative numbers. See specific examples further down this page.

      CINT - convert to integer (rounds fractional part to nearest even number)
    • INT - convert to integer (rounds down)
    • FIX - truncate number to an integer (drops fractional part)
    • CEIL - first integer greater than or equal to a value (rounds up)
    • ROUND - round numeric value (>=0.5 rounds up, <0.5 rounds down)
    • CVI - convert string to integer
    • MK$ - convert numeric value to string

    BIN$ / HEX$ / OCT$ Functions
    PowerBASIC can work with numbers in other than base 10. In particular, it supports base 2, 8, and 16. Numbers in bases other than 10 are written with one of the following prefixes. Numbers in base 10 are referred to a decimal values. Here's the notation to use for describing numbers of other bases. Note that PowerBASIC supports 3 ways to represent octal notation.

        &B  - binary
        &O  - octal (that's letter O, not number zero 0)
        &Q  - octal  &Q7
        &   - octal  &7
        &H  - hexadecimal
    
        A = &H0F    'hex value of "0F" (decimal 15)
        B = &Q7     'octal value of "7" (decimal 7)
        C = &B11    'binary value of "11" (decimal 3)
    

    To convert numeric values to strings, PowerBASIC supplies the BIN$, OCT$, and HEX$ functions. These three functions take a numeric value and return the binary (base 2), octagonal (base 8), or hexadecimal (base 16) value as a string.

    To convert base 2/8/16 strings to numeric (base 10) numbers, use the VAL function. It recognizes the following base number string prefixes.

    Arithmetic Functions Listing
    Here are one-line descriptions of all the arithmetic functions.

    • ABS - absolute value of numeric expression
    • BIN$ - return binary (base 2) representation of a numeric value
    • CEIL - first integer greater than or equal to a value
    • DECR - subtract one from a variable (decrement)
    • EXP - raise e to a power
    • EXP2 - raise 2 to a power
    • EXP10 - raise 10 to a power
    • FIX - truncate fractional part of a number
    • FRAC - fractional part of a floating-point number
    • HEX$ - hexadecimal (base 16) string representation of a number
    • INCR - add one to a variable (increment)
    • INT - convert to integer
    • LEN - logical length
    • LET - assign a value (or object reference with variants)
    • LOG - natural logarithm (base e)
    • LOG2 - logarithm (base 2)
    • LOG10 - logarithm (base 10)
    • MAX - return largest number from list
    • MIN - return smallest number from list
    • MOD - remainder of the division between two numbers
    • OCT$ - return octal (base 8) representation of a numeric value
    • RANDOMIZE - seed random number generator
    • RESET - set variable to zero (also applies to arrays, UDT, and variants)
    • RND - random number 0<= x < 1
    • ROUND - round numeric value to specified number of decimal places
    • SGN - sign of a numeric expression (-1, 0, +1)
    • SQR - square root
    • SWAP - exchange values two variables, pointers, or pointer targets
    • VAL - Return the numeric equivalent of a string argument
    • VARIANT# - Return the numeric value contained in a Variant variable
    • VARPTR - Returns address of a variable
    Arithmetic Functions Examples
    Here are examples for each of the arithmetic functions. The functions are listed in alphabetical order.

    • abs - absolute value
          result = abs (-5)         ' result = 5
           

    • bin$ - binary representation of a numeric value
          result$ = bin$(6)         ' result$ = "110"
          

    • ceil - first integer greater than or equal to a value
          result = ceil(5.2)        ' result = 6
          

    • decr - subtract one from a variable (decrement)
          result = 5
          DECR result               ' result = 4
          

    • exp - raise e to a power
          result = exp(5)           ' result = e^5 = 148.4132
          

    • exp2 - raise 2 to a power
          result = exp2(5)          ' result = 2^5 = 32
          

    • exp10 - raise 10 to a power
          result = exp10(5)         ' result = 10^5 = 10,000
          

    • fix - truncate fractional part of a number
          result = fix (2.63)       ' result = 2
          

    • frac - fractional part of a floating-point number
          result = frac(2.3)        ' result = 0.3
          result = frac(2.9)        ' result = 0.9
          

    • hex$ - returns hexadecimal string representation of a number
          result$ = hex$ (79)        # result$ = "4F"
          
      Note: expression values are rounded to integers before converting

    • incr - add one from a variable (decrement)
          result = 5
          INCR result               ' result = 6
          

    • int - returns largest integer less than or equal to expression
          result = int (79.8)       ' returns 79
          result = int (-1.5)       ' returns -2
          

      Note that INT rounds downward, hence -1.7 rounds down to -2.

    • len - for numeric values is number of bytes to store data type
          a = 5
          result = len(a)           ' result = 4   (4 bytes)
          result = len("dog")       ' result = 3   (3 characters)
          

      The data type determines what Len will return.

          numeric literal   - not allowed
          string literal    - length of string
          numeric variable  - bytes required to hold that data type
          string variable   - length of string
          fix-length string - buffer length
          ASCIIZ string     - length of data stored (SizeOf gets max size)
          UDT               - bytes required to hold that data type
          

    • let - assign value to a variable
          let result = 5            ' result = 5
          result = 5                ' "let" is optional
          

    • log - log to base e of a number
          result = log 5            ' result = 1.60944
          

    • log2 - log to base 2 of a number
          result = log2 5           ' result = 2.321928
          

    • log10 - log to base 10 of a number
          result = log10 5          ' result = 0.69897
          

    • max - return largest number from list
          result = max(1,2,3,2)     ' result = 3
          

    • min - return smallest number from list
          result = min(1,2,3,2)     ' result = 1
          

    • mod - returns remainder of a division
          result =  5 MOD 2         ' result = 1
          result =  5.8 MOD 2.8     ' result = 0.2000003
          
      For integers MOD works intuitively, but for floating point values the exact calculation is not so obvious. MOD truncates the division result and multiplies that by the divisor (number on bottom) before subtracting that product from the dividend (number on top). The second example above shows such a result.

    • oct$ - returns octal string representation of a number
          result$ = oct$ (49)       ' result$ = "61"
          result$ = oct$ (47.8)     ' result$ = "61"
          
      Expression values are ROUNDed to integers before converting.

    • randomize - initializes random number generator
          randomize 5               ' seed is always the same value
          randomize TIMER           ' seed is current time
          randomize                 ' default seed is TIMER
          

    • reset - set variable to zero (also applies to arrays, UDT, and variants)
          reset a!                  ' a! is set to zero
          reset a!(5)               ' element 5 of array is set to zero
          reset a()                 ' all elements are set to zero
          

    • rnd - return random number 0<= x < 1
          result = rnd              ' 0<= result < 1
          result = rnd (0)          ' argument 0   - repeats last result
          result = rnd (-5)         ' argument < 0 - reseeds 
          result = rnd (2)          ' argument > 0 - next random number
          result = rnd (5,7)        ' random long integer from 5 to 7
          

    • round - rounds numeric value to n decimal places (>=0.5 rounds up, <0.5 rounds down)
          result = round(5.23,0)    ' result = 5
          result = round(5.23,1)    ' result = 5.2
          result = round(5.40,0)    ' result = 5
          result = round(5.50,0)    ' result = 6
          result = round(5.73,0)    ' result = 6
          

    • sgn - returns sign of expression, or 0 if expression = 0
          result = sgn (-5)         ' result = -1
          result = sgn (75)         ' result = +1
          result = sgn (0)          ' result =  0
          

    • sqr - returns square root of a numeric-expression
          result = sqr (25)         ' result = 5
          result = sqr (2)          ' result = 1.414
          

    • swap - exchange values of two variables (must be of same type)
          a = 5 : b = 2             ' set test values
          swap a, b                 ' a = 2 and b = 5
          

    • val - return the numeric equivalent of a string argument
          result = "52AR"           ' result = 52
          result = "1.0G4T"         ' result = 1.04
          result = "A22"            ' result = 0
          result = "2e2"            ' result = 200
          result$ = "&H2"           ' result = 2
          result$ = "&HB"           ' result = 11
          

      Notes: Leading white spaces are ignored. +/- symbols are allowed. "e" or "d" may be used as powers of 10. Binary (&B) and octal (&O, &Q, &) strings are also recognized. Trailing type-specifiers are ignored.

    • variant# - returns numeric value from a variant
          Dim varVariant As Variant
          varVariant = 10
          result = variant#(varVariant)   ' result = 10
          

    • varptr - returns address of a variable
          Dim result as DWORD
          Dim b as single
          b = 5
          result = varptr(b)        ' result = memory address of variable b
          

    If you have any suggestions or corrections, please let me know.