Operations

From CometWiki

Revision as of 09:25, 31 May 2009

Operations

In addition to these operations, there are may functions that operate on string and/or numeric data. For more information, see the Procedure Division documentation.

Numeric Operations

The following types of operations may be performed on numeric data:

Addition Subtraction Multiplication Division Modulo Also see the notes about Precedence. Addition The plus sign (+) is the operator used to perform addition on numeric data.

Notes:

If the result of an addition operation exceeds the defined length of a receiving numeric variable, the value will be truncated on the left-hand side without warning.

If the precision of the result exceeds the defined precision of a receiving variable (and the variable has not been defined for automatic rounding), the result will be truncated on the right-hand side. See the ROUND statement for more information. Also see the LET statement.

Example:

  LENGTH 5.0                 ! Declare the length for A, B, C
  LOCAL A, B, C              ! Declare them as LOCAL variables
  .
  LET A = 500                ! Set the value for A
  LET B = 2000               ! Set the value for B
  LET C = A + B              ! Add A and B, giving C

Subtraction The minus sign (-) is the operator used to perform subtraction on numeric data. Notes:

If the result of a subtraction operation exceeds the defined length of a receiving numeric variable, the value will be truncated on the left-hand side without warning.

If the precision of the result exceeds the defined precision of a receiving variable (and the variable has not been defined for automatic rounding), the result will be truncated on the right-hand side. See the ROUND statement for more information. Also see the LET statement.

Example:

  LENGTH 5.0                 ! Declare the length for A, B, C
  LOCAL A, B, C              ! Declare them as LOCAL variables
  .
  LET A = 800                ! Set the value for A
  LET B = 200                ! Set the value for B
  LET C = A - B              ! Subtract B from A, giving C

Multiplication The asterisk (*) is the operator used to perform multiplication on numeric data. Notes:

If the result of a multiplication operation exceeds the defined length of a receiving numeric variable, the value will be truncated on the left-hand side without warning.

If the precision of the result exceeds the defined precision of a receiving variable (and the variable has not been defined for automatic rounding), the result will be truncated on the right-hand side. See the ROUND statement for more information. Also see the LET statement.

Example:

  LENGTH 5.0                 ! Declare the length for A, B, C
  LOCAL A, B, C              ! Declare them as LOCAL variables
  .
  LET A = 150                ! Set the value for A
  LET B = 25                 ! Set the value for B
  LET C = A * B              ! Multiply A and B, giving C

Division The backslash (/) is the operator used to perform division on numeric data. Notes:

If the result of a division operation exceeds the defined length of a receiving numeric variable, the value will be truncated on the left-hand side without warning.

If the precision of the result exceeds the defined precision of a receiving variable (and the variable has not been defined for automatic rounding), the result will be truncated on the right-hand side. See the ROUND statement for more information. Also see the LET statement.

Example:

  LENGTH 5.0                 ! Declare the length for A, B, C
  LOCAL A, B, C              ! Declare them as LOCAL variables
  .
  LET A = 150                ! Set the value for A
  LET B = 25                 ! Set the value for B
  LET C = A / B              ! Divide A by B, giving C

Modulo The MOD operator performs a modulo operation on the two numeric values (i.e., it divides the first value by the second value and returns the remainder). The MOD operator is supported in Comet 504 and greater.

The syntax is:

  numeric-value-1 MOD numeric-value-2

Example:

  10 MOD 3

This operation returns a value of 1. Explanation: 10 divided by 3 equals 3 with a remainder of 1.

Precedence In a numeric expression containing multiple operations, the multiplication and division operations are performed first (from left to right). Next, the addition and subtraction operations are performed (also from left to right). This algebraic order can be overridden with parentheses. In a numeric expression containing parentheses, operations inside the parentheses will be performed first, followed by the algebraic order previously described. Parentheses may be nested to any level in a numeric expression -- they will be performed from the inside to the outside.

Results The temporary result of a numeric operation will contain only as many digits to the right of the decimal point as the most precise operand in the expression. For example, if an expression contains operand with two digits of precision and four digits of precision, the temporary result will contain four digits of precision.

String Operations

The Internet Basic language supports the string operation of concatenation. The plus sign (+) is used to indicate concatenation (the combining of strings). For example, concatenating two string variables would look like this:

     FIRSTNAME$ + LASTNAME$

You may concatenate string constants, string variables, and string functions. Here is an example of concatenating constants with variables:

     "(" + AREACODE$ + ")" + PHONENUMBER$

Note: The maximum number of characters in any string is 254. If a concatenation operation results in more characters than have been declared for a receiving variable, characters will be truncated on the right-hand side. THIS TRUNCATION WILL OCCUR WITHOUT WARNING OF ANY KIND.

Relational Operations

The Internet Basic language supports relational operations in IF/THEN statements. The following operations are supported:

Operation                        Internet Basic syntax
Equal to                         EQ  or  =
Not equal to                     NE  or  NOT=
Greater than                     GT  or  >
Greater than or equal to         GE  or  >=
Less than                        LT  or  <
Less than or equal to            LE  or  <=
Contains                         Contains            (Strings only)
Soundslike                       Soundslike          (Strings only)

Additional information:

When comparing string values, the ASCII values for the characters are compared. For example, upper case "A" is considered to be less than lower case "a" because the ASCII value for "A" (i.e., 65) is less than the ASCII value for "a" (i.e., 97). Thus, it is possible to determine correct alphabetical order for strings using relational comparisons. See the ASCII chart.

Two strings are considered to be equal only when they are identical and have the same current length (number of characters).

The Contains operator will be true if the left hand string operand contains the right hand string operand.

The Soundslike operator will be true if the soundex key of both operands are equal.

Both the Contains and Soundslike operators are case insensitive.

Logical Operations

The Internet Basic language supports the AND and OR logical operations to be used in conjunction with relational expressions. The AND operator tests whether both relational conditions are true, while the OR operator tests for truth of either relational condition. For example:

     IF A=B AND B=C THEN...        !  Both conditions must be true

     IF A=B OR B=C THEN...         !  Either condition may be true

If AND and OR are combined in a relational expression, the AND operator takes precedence (i.e., it will be evaluated first). It is possible to override this precedence with parentheses, just like the precedence in numeric operations can be overridden. For more information on relational operations and logical operations, see the IF statement.

Beginning with Comet 2004, logical operations are also supported on binary expressions. The AND, OR, and XOR operators are available. The AND operator performs a logical conjunction on two expressions. AND compares identically positioned bits in two numeric expressions and sets the corresponding bit in the result field. A result bit will only be set to 1 if both of the corresponding bits in the expression fields are 1. Otherwise the result bit will be 0. For example: C = A AND B If A = 1010 (binary) and B = 0011 (binary), then C = 0010 (binary).

The OR operator performs a logical disjunction on two numeric expressions. OR compares identically positioned bits in two numeric expressions and sets the corresponding bit in the result field. A result bit will always be set to 1 unless the corresponding bits in both expression fields are 0. For example: C = A OR B If A = 1010 (binary) and B = 0011 (binary), then C = 1011 (binary).

The XOR operator performs a logical exclusion on two numeric expressions. XOR compares identically positioned bits in two numeric expressions and sets the corresponding bit in the result field. A result bit will only be set to 1 if exactly one of the expression fields has a 1 bit set in the corresponding position. For example: C = A XOR B If A = 1010 (binary) and B = 0011 (binary), then C = 1001 (binary).

Notes: Contains and SoundsLike operators added 5/09/08 Build 389