IDL Operators

As described in the previous Overview section, operators are used to combine terms and expressions. IDL supports the following types of operators:

Parentheses

Parentheses are used to group expressions and to enclose function parameter lists. Parentheses can be used to override the order of operator evaluation described above. Examples:

;Parentheses enclose function argument lists. 
SIN(ANG * PI/180.) 
 
;Parentheses specify order of operator evaluation. 
(A + 5)/B

Square Brackets

;Use brackets when assigning elements to an array. 
ARRAY = [1, 2, 3, 4, 5] 
 
;Brackets enclose subscripts. 
ARRAY[X, Y]

Mathematical Operators

Assignment

The equal sign (=) is the assignment operator. The value of the expression on the right hand side of the equal sign is stored in the variable, subscript element, or range on the left side. For example, the following assigns the value 32 to A.

Compound Assignment Operators

In addition to the standard assignment operator, there are numerous compound operators (+=, -=, etc.) that combine assignment with another operator. Compound assignment operators provide succinct syntax for expressions in which the same variable would otherwise be present on both sides of the equal sign. For example, the following statements both add 100 to the current value of the variable A:

Addition

The positive sign (+) is the addition operator. When applied to strings, the addition operator concatenates the strings. For example:

;Store the sum of 3 and 6 in B. 
B = 3 + 6 
 
;Store the string value of "John Doe" in B. 
B = 'John' + ' ' + 'Doe'

Subtraction and Negation

The negative sign (-) is the subtraction operator. Also, the minus sign is used as the unary negation operator. For example:

;Store the value of 5 subtracted from 9 in C. 
C = 9 - 5 
 
;Change the sign of C. 
C = -C

Multiplication

Division

; Store the result of 10.0 divided by 3.2 in variable D: 
D = 10.0/3.2

Exponentiation

The caret (^) is the exponentiation operator. A^B is equal to A raised to the B power.

If A is a real number and B is of integer type, repeated multiplication is applied.

If both A and B are real (non-integer), the formula A^B = e^BlnA is evaluated.

A⁰ is defined as 1.

For complex numbers, A^B is evalutated as follows. The complex number A can be represented as A = a + ib, where a is the real part, and ib is the imaginary part. In polar form, we can represent the complex number as A = reⁱ^q = r cosq + ir sinq, where r cosq is the real part, and ir sinq is the imaginary part:

If A is complex and B is real, the formula A^B = (reⁱ^q)^B = r^B (cosBq + isinBq) is evaluated.

If A is real and B is complex, the formula A^B = e^BlnA is evaluated.

If both A and B are complex, the formula A^B = e^BlnA is evaluated, and the natural logarithm is computed to be ln(A) = ln(reⁱ^q) = ln(r) + iq.

Modulo

The keyword MOD is the modulo operator. I MOD J is equal to the remainder when I is divided by J. The magnitude of the result is less than that of J, and its sign agrees with that of I. For example:

;Assign the value of 9 modulo 5 (4) to A. 
A = 9 MOD 5 
 
;Compute angle modulo 2p. 
A =(ANGLE + B) MOD (2 * !PI)

Increment/Decrement

The increment (++) and decrement (--) operators can be applied to variables (including array subscripts or structure tags) of any numeric type. The ++ operator increments the target variable by one. The -- operator decrements the target by one. When written in front of the target variable (that is, using prefix notation), the operations are known as preincrement and predecrement, respectively. When written following the target variable (using postfix notation), they are called postincrement and postdecrement.

The increment and decrement operators can be used either as standalone statements or within a larger enclosing expression. Although the two forms are very similar, the expression form has some efficiency and side-effect issues (described below) that do not apply to the statement form.

Increment/Decrement Statements

Increment and decrement operators can be used, along with a variable, as standalone statements:

A++ or ++A

A-- or --A

The increment or decrement operator may be placed either before or after the target variable. The same operation is carried out in either case. These operators are very efficient, since the variable is incremented in place and no temporary copies of the data are made.

Increment/Decrement Expressions

Increment and decrement operators can be used within expressions. When the operator follows the target expression, it is applied after the value of the target is evaluated for use in the surrounding expression. When the operator precedes the target expression, it is applied before the value of the target is evaluated for use in the surrounding expression. For example, after executing the following statements, the value of the variable A is 27, while B is 28:

In contrast, after executing the following statements, both A and B have a value of 26:

Efficiency of Prefix vs. Postfix Operations

When used as part of an expression, the prefix form of the increment and decrement operators has an efficiency advantage over the postfix form. The reason for this is that the postfix form requires IDL to make a copy of the data, while the prefix form does not. The operations carried out by IDL to execute a prefix increment or decrement operation are:

Fetch the target variable.

Increment or decrement the target variable in place (no copies are made).

Use the variable when evaluating the surrounding expression.

This is very efficient. In contrast, the postfix form requires IDL to make a copy of the variable in order to use its old value in the surrounding expression following the increment/decrement. The operations carried out by IDL to execute a postfix increment or decrement operation are:

Fetch the target variable.

Make a temporary copy of the variable.

Increment or decrement the original variable.

Use the temporary copy when evaluating the surrounding expression.

If your computation requires the postfix form, then these operations are necessary and reasonable. If not, the prefix form will use fewer resources and is the better choice. The larger the data involved, the more important this becomes. It is not a concern for small variables.

Order Of Side Effects

The way that the increment and decrement operators change the value of a variable in addition to using its value in a surrounding expression is called a side effect. In most cases, the side effects are desired, and cause no problems. Side effects can cause problems, however, if the increment or decrement operator is applied to a variable that appears more than once within a single statement or expression. Consider the following statement (taken from The C Programming Language by Brian W. Kernighan and Dennis M. Ritchie):

Which value of i is used to index A? Is it the original value of i, or the incremented value? The answer depends on the order in which the various parts of the statement are evaluated. Either answer might be considered correct, and IDL does not require one or the other. Similarly, in the statements

the value of A could be either 47 or 46, depending on which part of the expression is evaluated first.

Note that this situation falls outside the rules of operator precedence - it is the order in which the variables themselves are evalutated that affects the result. Let's examine the situation closely:

Here the "old" value of B (23) is always used for the first occurrence of B in the statement.

If the sub-statement B++ is evaluated first, the value of the second occurrence of B in the statement uses the "new" value of B (24), giving A the value 47.

If the sub-statement that contains only the variable B is evaluated first, the "old" value of B will be used for both occurrences, and A will get the value 46.

As with most languages that implement increment and decrement operators, IDL does not require any particular ordering of evaluation within an expression in which such side effects occur. Different versions or implementations of IDL may evaluate the same expression differently. As a result, you should avoid writing code that depends on a particular ordering of the side effects.

Minimum and Maximum Operators

The IDL minimum and maximum operators return the smaller or larger of their operands, as described below. Note that negated values must be enclosed in parentheses in order for IDL to interpret them correctly.

The Minimum Operator

The "less than" sign (<) is the IDL minimum operator. The value of "A < B" is equal to the smaller of A or B. For example:

;Set A equal to 3.  
A = 5 < 3 
 
;Set A equal to -6.  
A = 5 < (-6) 
 
;Syntax Error. IDL attempts to perform a subtraction operation if  
;the "-6" is not enclosed in parentheses. 
A = 5 < -6 
 
;Set all points in array ARR that are larger than 100 to 100. 
ARR = ARR < 100 
 
;Set X to the smallest of the three operands. 
X = X0 < X1 < X2

For complex numbers the absolute value (or modulus) is used to determine which value is smaller. If both values have the same magnitude then the first value is returned.

; Set A equal to 1+2i, since ABS(1+2i) is less than ABS(2-4i) 
A = COMPLEX(1,2) < COMPLEX(2,-4) 
 
; Set A equal to 1-2i, since ABS(1-2i) equals ABS(-2+i) 
A = COMPLEX(1,-2) < COMPLEX(-2,1)

The Maximum Operator

The "greater than" sign (>) is the IDL maximum operator. "A > B" is equal to the larger of A or B. For example:

;'>' is used to avoid taking the log of zero or negative numbers. 
C = ALOG(D > 1E - 6) 
 
;Plot positive points only. Negative points are plotted as zero. 
PLOT, ARR > 0

For complex numbers the absolute value (or modulus) is used to determine which value is larger. If both values have the same magnitude then the first value is returned. For example:

 
; Set A equal to 2-4i, since ABS(2-4i) is greater than ABS(1+2i) 
A = COMPLEX(1,2) > COMPLEX(2,-4) 
 
; Set A equal to 1-2i, since ABS(1-2i) equals ABS(-2+i) 
A = COMPLEX(1,-2) > COMPLEX(-2,1)

Matrix Multiplication

The # Operator

The # operator computes array elements by multiplying the columns of the first array by the rows of the second array. The second array must have the same number of columns as the first array has rows. The resulting array has the same number of columns as the first array and the same number of rows as the second array.

The ## Operator

The ## operator does what is commonly referred to as matrix multiplication. It computes array elements by multiplying the rows of the first array by the columns of the second array. The second array must have the same number of rows as the first array has columns. The resulting array has the same number of rows as the first array and the same number of columns as the second array.

For an example illustrating the difference between the two, see Multiplying Arrays.

Array Concatenation

The square brackets are used as array concatenation operators. Operands enclosed in square brackets and separated by commas are concatenated to form larger arrays. The expression [A,B] is an array formed by concatenating A and B, which can be scalars or arrays, along the first dimension.

Similarly, [A,B,C] concatenates A, B, and C. The second and third dimensions can be concatenated by nesting the bracket levels; [[1,2],[3,4]] is a 2-element by 2-element array with the first row containing 1 and 2 and the second row containing 3 and 4. Operands must have compatible dimensions; all dimensions must be equal except the dimension that is to be concatenated, e.g., [2,INTARR(2,2)] are incompatible. Examples:

;Define C as three-point vector. 
C = [-1, 1, -1] 
 
;Add 12 to the end of C. 
C = [C, 12] 
 
;Insert 12 at the beginning of C. 
C = [12, C] 
 
;Plot ARR2 appended to ARR1.    
PLOT, [ARR1, ARR2] 
 
;Define a 3x3 matrix. 
KER = [[1,2,1], [2,4,2], [1,2,1]]

Logical Operators

The logical && operator performs the logical short-circuiting "and" operation on two scalars or one-element arrays, returning 1 if both operands are true and 0 if either operand is false.

The logical || operator performs the logical short-circuiting "or" operation on two scalars or one-element arrays, returning 1 if either of the operands is true and 0 if both are false.

The logical ~ operator performs the logical "not" operation on a scalar or array operand. If the operand is a scalar, it returns scalar 1 if the operand is false or scalar 0 if the operand is true. If the operand is an array, it returns an array containing a 1 for each element of the operand array that is false, and a 0 for each element that is true.

When is an Operand True?

When evaluated by a logical operator, an expression is considered to be "true" under the following conditions:

For numerical operands, if the value is non-zero.

For string operands, if the value is non-null.

For heap variables (pointers and object references), if the value is non-null.

Short-circuiting

The && and || logical operators are short-circuiting operators. This means that IDL does not evaluate the second operand unless it is necessary in order to determine the proper overall answer. Short-circuiting behavior can be powerful, since it allows you to base the decision to compute the value of the second operand on the value of the first operand. For instance, in the expression:

IDL does not evaluate Op2 if Op1 is false, because it already knows that the result of the entire operation will be false. Similarly in the expression:

IDL does not evaluate Op2 if Op1 is true, because it already knows that the result of the entire operation will be true.

If you want to ensure that both operands are evaluated (perhaps because the operand is an expression that changes value when evaluated), use the LOGICAL_AND and LOGICAL_OR functions or the bitwise AND and OR operators.

Logical Operator Examples

Results of relational expressions can be combined into more complex expressions using the logical operators. Some examples of relational and logical expressions are as follows:

;True if A is between 25 and 50. If A is an array, then the result  
;is an array of zeros and ones. 
(A LE 50) && (A GE 25) 
 
;True if A is less than 25 or greater than 50. This is the inverse  
;of the first. 
(A GT 50) || (A LT 25)

Bitwise Operators

There are four bitwise operators in IDL: AND, NOT, OR, and XOR. For integer operands (byte, signed- and unsigned-integer, longword, and 64-bit longword data types), bitwise operators operate on each bit of the operand or operands independently.

AND

The bitwise AND operator performs the logical "and" operation on two scalar or array operands. If the operands are scalars, it returns a scalar value. If either operand is an array, it returns an array containing one value for each element of the shortest array operand. The returned values are as follows:

For integer operands, AND performs a bitwise "and" operation and returns the result. For example, the statement

5 AND 6 = 4

is represented in binary as follows:

0101 AND 0110 = 0100

For floating-point and complex operands, AND returns the second operand if the first operand is not equal to zero; otherwise, the returned value is zero.

For string operands, AND returns the second operand if the first operand is non-null; otherwise, the returned value is the null string.

The bitwise AND operator is not valid for heap variable operands.

NOT

The bitwise NOT operator returns the bitwise inverse of its scalar or array operand. If the operand is a scalar, it returns a scalar value. If the operand is an array, it returns an array containing one value for each element of the operand array. The returned values are as follows:

For integer operands, NOT returns the complement of each bit of the operand. For example, the statement

NOT 4 = -5

is represented in binary as follows:

NOT 0100 = 1011

For floating-point operands, NOT returns 1.0 if the operand is zero; otherwise, it returns zero.

The bitwise NOT operator is not valid for string, complex, or heap variable operands.

The bitwise OR operator performs the logical "inclusive or" operation on two scalar or array operands. If the operands are scalars, it returns a scalar value. If either operand is an array, it returns an array containing one value for each element of the shortest array operand. The returned values are as follows:

For integer operands, OR performs a bitwise inclusive "or" operation and returns the result. For example, the statement

3 OR 5 equals 7

is represented in binary as follows:

0011 OR 0101 = 0111

For floating-point and complex operands, OR returns the first operand if it is non-zero, or the second operand otherwise.

For string operands, OR returns the first operand if it is non-null, or the second operand otherwise.

The bitwise NOT operator is not valid for heap variable operands.

XOR

The bitwise XOR operator performs the logical "exclusive or" operation on two scalar or array operands. If the operands are scalars, it returns a scalar value. If either operand is an array, it returns an array containing one value for each element of the shortest operand array. The returned values are as follows:

For integer operands, XOR sets a bit in the result to 1 if the corresponding bits in the operands are different or to 0 if they are equal. The statement:

3 XOR 5 = 6

is represented in binary as follows:

0011 XOR 0101 = 0110

The bitwise XOR operator is not valid for other types.

Bitwise Operator Examples

; Displays the "negative" of an image contained in the array IMG. 
TV, NOT IMG 
 
; Adds the hexadecimal constant FF (255 in decimal) to the array 
; ARR. This masks the lower 8-bits and zeros the upper bits. 
ARR AND 'FF'X

Note on the NOT Operator

Due to the bitwise nature of the NOT operator, logical negation operations should always use ~ in preference to NOT, reserving NOT exclusively for bitwise computations. Consider a statement such as:

which wants to execute statement if the file specified by the variable lun has data remaining, and the variable device_ready is non-zero. When EOF returns the value 1, the expression NOT EOF(lun) yields -2, due to the bitwise nature of the NOT operator. The && operator interprets the value -2 as true, and will therefore attempt to execute statement incorrectly in many cases. The proper way to write the above statement is:

Relational Operators

The IDL relational operators can be used to test the relationship between two arguments. The six relational operators are described in the following table:

Relational operators apply a relation to two operands and return a logical value of true or false. The resulting logical value can be used as the predicate in IF, WHILE or REPEAT statements can be combined using Boolean operators with other logical values to make more complex expressions. For example: "1 EQ 1" is true, and "1 GT 3" is false.

The rules for evaluating relational expressions with operands of mixed modes are the same as those given above for arithmetic expressions. For example, in the relational expression "2 EQ 2.0", the integer 2 is converted to floating point and compared to the floating point 2.0. The result of this expression is true, as represented by a byte 1.

Operator	Description
EQ	Equal to
NE	Not equal to
GE	Greater than or equal to
GT	Greater than
LE	Less than or equal to
LT	Less than

Any odd, nonzero value for byte, integer, and longword data types

Any nonzero value for single, double-precision, and the real part of a complex number (the imaginary part is ignored)

Any non-null string

Conversely, false is represented as anything that is not true-zero or even-valued integers; zero-valued, floating-point quantities; and the null string.

The relational operators return a value of 1 for true and 0 for false. The type of the result is always byte.

EQ is the relational "equal to" operator. This operator returns true if its operands are equal; otherwise, it returns false. This operator always returns a byte value of 1 for true and a byte value of 0 for false.

For complex numbers both the real and imaginary parts must be equal. For example:

NE is the "not-equal-to" relational operator. This operator returns true whenever the operands are different. For example "sun" NE "fun" returns true.

For complex numbers both the real and imaginary parts must be equal to return a false value. For example:

GE is the "greater than or equal to" relational operator. The GE operator returns true if the operand on the left is greater than or equal to the one on the right. One use of relational operators is to mask arrays as shown in the following statement:

This command sets A equal to ARRAY whenever the corresponding element of ARRAY is greater than or equal to 100. If the element is less than 100, the corresponding element of A is set to zero.

Strings are compared using the ASCII collating sequence: " " is less than "0" is less than "9" is less than "A" is less than "Z" is less than "a" which is less than "z".

GT is the "greater than" relational operator. This operator returns true if the operand on the left is greater than the operand on the right. For example, "6 GT 5" returns true.

LE is the "less-than or equal-to" relational operator. This operator returns true if the operand on the left is less than or equal to the operand on the right. For example, "4 LE 4" returns true.

LT is the "less-than" relational operator. This operator returns true if the operand on the left is less than the operand on the right. For example, "3 LT 4" returns true.

Using Relational Operators with Arrays

Relational operators can be applied to arrays, and the resulting array of ones and zeroes can be used as an operand. For example, the expression, ARR * (ARR LE 100) is an array equal to ARR except that all points greater than 100 have been reduced to zero. The expression (ARR LE 100) is an array that contains a 1 where the corresponding element of ARR is less than or equal to 100, and zero otherwise. For example, to print the number of positive elements in the array ARR:

Using Relational Operators with Infinity and NaN Values

On Windows and Solaris x86 platforms, using relational operators with the values infinity or NaN (Not a Number) causes an "illegal operand" error. The FINITE function's INFINITY and NAN keywords can be used to perform comparisons involving infinity and NaN values. For more information, see FINITE and Special Floating-Point Values.

Conditional Expression

The conditional expression-written with the ternary operator ?:-has the lowest precedence of all the operators. It provides a way to write simple constructions of the IF...THEN...ELSE statement in expression form. In the following example, Z receives the larger of the values contained by A and B:

The expression expr1 is evaluated first. If expr1 is true, then the expression expr2 is evaluated and set as the value of the conditional expression. If expr1 is false, expr3 is evaluated and set as the value of the conditional expression. Only one of expr2 or expr3 is evaluated, based on the result of expr1. (See Definition of True and False for details on how the "truth" of an expression is determined.)