FlexView Expression Editor

The FlexView Expression Editor lets you add columns whose values are the result of executing data manipulating routines. A routine is a series of expressions separated by semicolons. The Expression Editor uses a language to create the expressions that make up these routines. These expressions are similar to expressions defined in the C programming language. It provides a series of data reference types and operators, and system (pre-defined) function calls that can be combined to create routines. Routines come in two flavors: Column Routines and Functions.

Column Routines
Column routines can access data in other columns in the table, and combine them with data from stored variables, system functions, table functions, and constants to come up with new values to be displayed in a column. Each Column Routine is associated with a single column of a FlexView table. During row processing, each column is evaluated to determine the contents of the cell associated with the table's columns. For a column that is using a column routine, the column routine is executed and the final result is displayed as the contents of the cell.

Functions
A function is a routine that is not associated with a column. Instead functions are identified by name and have parameters that must be specified for it to operate on when it is used in an expression. For example, the system function that determines a percentage (to a specified number of decimal places) is named Percent and has three parameters: portion which is the numerator, total which is the denominator, and decimal, which specifies the number of decimal places with which to express the result. Functions come in two flavors: System Functions and Table Functions. System functions are provided with Console and can be used in any FlexView table. Table Functions are functions that you create, but they can only be used within the table where they were created.

The Language of FlexView Expressions

FlexView Expressions consist of elements that are capable of referencing other columns in a FlexView Table and, using a format that is conducive to the needs of a routine, casting values into whatever data type is necessary and manipulating the data both as single values and as arrays.

Expressions

As stated earlier, a routine consists of one or more expressions, separated by semicolons. And, an expression consists of one or more values combined using operators. Every expression returns a value when it completes its processing. The value of the final expression of a routine is the value of the routine.

  • Expressions may call a system function or table function, treating it as a value. The function executes when an executing column routine calls it. The function returns a value which is used as a value in the calling expression.
  • Expressions may be assigned to variables.

These are all examples of expressions:

total = {"sent":108:#} + {"received":109:#} + {"errors":110:#};   // Add three columns and

percent = ( if total != 0 then #{sent} / total else 0 );   // Don't do the divide if total is zero 

FormatFloat( percent, 5, 2 ) + "%";   // Format percent and append a %

x = (_ b + SquareRoot( b * b + 4 * a * c ) ) / ( 2 * a );   // Equation using 3 variables: a, b & c

"Router"; // A single value is an expression 

NOTE: Expressions can be commented using double slashes (//) and all text between the double slashes and the end of a line is ignored for execution.

Values

Values are either explicit or implicit. Explicit values are entered into an expression and processed when the expression is executed. Explicit values are expressed as constants, variable references, column references, and function references. Implicit values are the result of interim calculations and references that are passed along to the next step in the expression execution. For instance, in the expression $result + "%", first the variable result is evaluated. Then it is cast to a string ($ is the string casting operator), which creates an interim value and finally, this interim value is concatenated with the string constant "%" to create a new interim value, which is the final result (value) of the expression. All values are expressed as a Data Type.

Data Types

There are four data types: float, integer, boolean, and string. The data type for a value is determined when a value is created or, in the case of variables, the variable is assigned. All operators work on one or more data types. If a value does not have the data type expected by an operator, the value is converted to the correct data type. Values can be explicitly cast (converted) to a specific data type to insure the correct processing of the data. There are casting operators that can be used at any point in a calculation to force the result of all or part of a calculation to the specific data type.

NOTE: Console implements a Float as a Java double and an Integer as a Java long. Therefore their respective ranges are the same as Java.

Casting

Casting converts one data type to another. There are four data type casting operators:

  • @ - Float
  • # - Integer
  • ? - Boolean
  • $ - String

Values can be explicitly cast to a new data type to insure the proper processing of the value. For instance $count returns the contents of the variable named count cast to a string. This does not change the data type of count. It merely passes the interim value on as a string when that element in the expression is evaluated. Values are also implicitly cast during operations. Any data type can be converted to any other data type, although this may result in data loss.

Explicit Conversions

  • Converting to an Integer
    • from a Float - If the value of the Float is outside of the range of an Integer, it will be set to the maximum or minimum value of an Integer, whichever is closer. The portion of the number to the right of the decimal point is lost.
    • from a String - The String is scanned from the beginning for decimal numbers. Scanning stops at the first non-digit character, and the portion scanned is converted. If the value is outside of the range of an Integer, it will be set to the maximum or minimum value of an Integer, whichever is closer. The remainder of the String is lost.
    • from a Boolean - True converts to one, and false to zero.
  • Converting to Float
    • from an Integer - The number is converted. Since the range of Integer is a subset of Float, there can be no data loss.
    • from a String - The String is scanned from the beginning for numbers that fit the standard notation for floating-point numbers. For example "-123.45e+17". Scanning stops at the first character that falls outside this definition, and the portion scanned is converted. If the magnitude of either the mantissa or the exponent is outside of the range of a Float, they will be set to their respective maximum or minimum values, whichever is closer. The remainder of the String is lost.
    • from a Boolean - True converts to one, and false to zero.
  • Converting to String
    • from an Integer - A series of decimal digits is put into the String with no leading zero except in the case of zero.
    • from a Float - A series of decimal digits followed by a decimal point, and optionally followed by one or more decimal digits is put into the String. No leading or trailing zeroes will be put into the string, except in the case of zero.
    • from a Boolean - TRUE or FALSE is put into the String.
  • Converting to Boolean
    • from an Integer - Zero converts to false, all others to true.
    • from a Float - Zero converts to false, all others to true.
    • from a String - T, TRUE Yes", Y, OK, (case independent) and 1 convert to true, all others to false. Comparisons are case independent.

Implicit Conversion

The following tables show implicit conversions from one data type to another.

Binary Arithmetic Conversions

This table shows the data types returned for binary arithmetic operations involving types X and Y. This applies to addition (+), subtraction (_), multiplication (*), division (/), modulo (%), and all assignment operations that perform these arithmetic operations (+=, _+, *=, /=, and %=).

The symbol indicates which operand will be converted to what data type and what the resulting data type will be. For example, X Float indicates that the X value is cast to a Float and Float will be the result of the operation.

                   y
x 		Float Integer Boolean String
Float Float Y Float Y Float X String (see Note)
Integer X Float Integer Y Integer X String (see Note)
Boolean X Float X Integer X,Y Integer X String (see Note)
String X Float X Integer X,Y Integer String

 

  NOTE: When one data type is a string and the operator is an addition (+) operator, then the non-string operand is cast to a string and the operation is a concatenation of the two strings. The resulting value is a string. If arithmetic addition is required, then the string operand must be explicitly cast to Integer or Float.
Comparison Conversions

This table shows the data types used during comparison operations involving types X and Y. The indicated conversion takes place before the comparison. A boolean is always returned. The operators this applies to are equals (= =), not equals (!=), greater than (>), greater than or equal to (>=), less than (<), and less than or equal to (<=).

The symbol indicates which operand will be converted to what data type. For example, X Float indicates that the X value is converted to a Float and a Float comparison will be performed.

                   y
x 		Float Integer Boolean String
Float Float Y Float Y Float X String
Integer X Float Integer Y Integer X String
Boolean X Float X Integer Boolean X String
String Y String Y String Y String String

Data type casting is high in the order of precedence. So, in order to cast the results of a calculation, it would need to be parenthesized. For example $(4+8) would do the addition and then cast the result as a string, returning a string of "12". The expression, $4+8 would cast the 4 to a string, then convert the integer 8 to a string and concatenate 4 and 8 and return the result as the string, "48".

Constants

Each data type has a method of entering constants:

  • Floats - are a series of decimal digits starting with a non-zero digit. Floats can have an optional decimal point and an optional exponent. For example 23.6e-12. Plus (+) and minus (–) signs are treated as a unary operators.
  • Integers - can be expressed as Decimal, Octal, or Hexadecimal. Plus (+) and minus (–) signs are treated as a unary operators.
    • Decimal integers - are a series of decimal digits starting with a non-zero digit. For example, 239.
    • Octal integers - are a series of octal digits starting with a zero. For example, 0177.
    • Hexadecimal - are a series of hexadecimal digits starting with zero-x (0x). For example, 0x3e4. Hexadecimal digits (A-F) are case independent.
  • Booleans - are either true or false. Booleans are not case-sensitive.
  • Strings - are a series of any printable ASCII characters enclosed within double quotes. Double quotes ("), used within a string constant, must be preceded by a back-slash (\). For example, "This is a string constant containing a \"quoted\" word." Likewise, when a backslash (\) appear in a string, it too must be preceded by another backslash. For example "Enter \\ to continue" will be displayed as Enter \ to continue.

Operators

Operators are used to combine values. Operators are either mathematical or logical, except when using the plus sign to concatenate strings. Operators fall into eight categories: post-unary and pre-unary arithmetic operators, binary arithmetic operators, bit-wise operators, comparison operators, logical operators, conditional operators and assignment operators.

Except for increment and decrement operators, which operate only on integers, all the other operators can work on any value: constants, interim values or variables, function or column references.

Post-unary Arithmetic Operators

There are two post-unary arithmetic operations. Both must be associated with a variable reference since they alter the contents of the value with which they are associated. They operate only on integers.

  • ++ - Increment
  • _ _ - Decrement

When these operators are executed, the variable is first converted to an integer, then a new integer value is created with the current value of the expression's variable. This is the value that is returned, because post-increment and post-decrement return the value before the operation. Then the variable's value is incremented or decremented, and the new integer value is returned to the remainder of the expression.

Pre-unary Arithmetic Operators

There are nine pre-unary arithmetic operators.

  • ++ - Increment
  • __ - Decrement
  • + - Plus or Positive
  • _ - Minus or Negative
  • ! - Not
  • @ - Float-cast
  • # - Integer cast
  • ? - Boolean cast
  • $ - String cast

Increment and Decrement must be associated with a variable reference and operate only on integers. When these operators are executed, first the variable is converted to an integer, and then the value is incremented or decremented. Finally, the new integer value is returned to the remainder of the expression.

All of the other Pre-unary operators can be associated with any value.

Plus (+) and Minus (_) operators are associated only with numeric types. If the associated value is an integer or float, the same value is returned but, in the case of negative, with the opposite sign. If the associated value is a boolean or string, a copy of the value converted to an integer is returned but, in the case of negative, with the opposite sign. The positive operator on a numeric type does nothing, but on a non-numeric type it acts the same as integer cast.

The Not operator is associated with boolean values. If the associated value is not a boolean, the value is converted to boolean before the operation is performed.

The cast operators (@, #, ?, $) return their associated values converted to the cast's data type. Every data type can be converted into every other data type as described earlier.

Binary Arithmetic Operators

There are five binary arithmetic operators:

  • + - Add
  • _ - Subtract
  • * - Multiply
  • / - Divide
  • % - Modulo

They operate only on numeric values. Non-numeric values are converted to float or integer before the operation is performed. Either float or integer is returned. For divide and modulo operations, a runtime error will occur if the second value is zero. Refer to the Binary Arithmetic Conversion table for implicit conversions during binary arithmetic operations. The only exception to this is the Add operator operating on two string values. When the operator is an add (+) operator, then the non-string operand is cast to a string and the operation is a concatenation of the two strings. The resulting value is a string. If arithmetic addition is required, then the string operand must be explicitly cast to Integer or Float.

Bit-wise Operator

There are three bit-wise operators:

  • & - AND
  • ^ -  XOR
  • | - OR

These operate only on integer values. All non-integer values are converted to integer before the operation is performed. The AND returns a binary one when the corresponding bit position in both numbers are a one. The OR returns a binary one when the corresponding bit position in either or both numbers is a one. The XOR returns a binary one for a particular bit position when the corresponding bit position in either, but not both numbers is a one,

Comparison Operators

There are six comparison operators:

  • < - Less than
  • <= - Less than or equal to
  • > - Greater than
  • >= - Greater than or equal to
  • == - Equal
  • != - Not Equal

These operate on all data types, but they can only compare the same data types to each other. Strings are lexicographically compared. For booleans, false is less than true. Refer to the implicit conversion table for binary comparison conversions.

Logical Operators

There are two logical operators:

  • && - AND
  • || - OR

Conditional Operators

The if, then, and else operators are used to test a condition and execute one of two expressions, depending on the result of the test. The if operator performs the test and, if the condition is true, the expression following the then operator is executed. If the condition is false, the expression following the else operator is executed. Any expression can follow the then and else operators. Any expression, except another if, then or else expression, can be used as the condition following the if operator. The else operator is optional. If the condition being tested is false and there is no else operator, an integer zero is returned.

Assignment Operators

There are nine assignment operators:

  • =   Assign
  • +=   Add and assign
  • _ =   Subtract and assign
  • *=   Multiply and assign
  • / =   Divide and assign
  • % =   Modulo and assign
  • & =   Bit-wise AND and assign
  • ^ =   Bit-wise XOR and assign
  • | =   Bit-wise OR and assign

The value to the left of all assignment operators must be a variable reference. The assignment operator sets the value and type of the variable reference to the value and type of the second value.

All the other assignment operators, except Assign (=), involve a calculation before the assignment. The manner these calculations are performed is the described in the sections on Arithmetic Operators and Bit-wise Operators. The result of the calculation is then assigned to the variable in the same manner as the assignment operator. The resulting value of any assign is the value assigned. In this manner chained assignments are allowed since they are processed right-to-left. For instance, index = offset = 0, the variable offset is first assigned the integer value 0. Since the result of an assignment is the value assigned, the result is 0 which is then used in the assignment of index.

Parenthetical Expressions

This formula language is hierarchical, which means that operations at a higher level are processed before operations at a lower level. For instance, in the expression 2 + 3 * 4, the multiplication is performed first, even though the addition appears first in the expression. In order to force the addition to be performed first it should appear within parentheses: (2 + 3) * 4. Any expression can appear in a pair of parentheses, even variable assignments. As many parentheses as is needed can be used; there is no limit to the depth of parentheses. The value and data type returned by the parentheses operators is determined by the result of the last calculation performed in the expression within the parentheses.

Order of Operations

The following table lists all operators by category to show their order of processing. At the top of the list, Value, is the highest order of processing. Each category takes precedence over the categories below it. For example, given the expression A == B + 7 * C, the multiplication of 7 and C is done first, then the result is added to B, then the new result is compared to A for equality.

  Category Operators
Highest Value Column, Function, Variable, Constant,
Parenthetical expression
Post unary ++, __, +, _, !, @, #, ?, $
Pre unary ++, __
Product *, /, %
Sum +, _
Relative <, >, <=, >=
Equality ==, !=
Bitwise AND &
Bitwise XOR ^
Bitwise OR |
Logical AND &&
Logical OR ||
Assignment =, +=, _=, *=, /=, %=, &=, ^=, |=
Lowest Expression if, then, else

Column References

A column reference consists of the column name and column ID for a selected column (separated by a colon), optionally followed by a colon and formatting information, all within curly braces. Formatting parameters determine the Data Type that the contents of the column will be converted to when being read out of the column and whether or not it will be in an array format, as in the case of OID, instance, OCTET STRING, IP Address, etc. Formatting also specifies a Radix when the data type is a numeric string, such as hexadecimal and whether the value is an Array, and whether to use Raw Data (the unformatted value returned as it is by the device). Radix format operators are H, O and D for hexadecimal, octal and decimal respectively. Data type format operators are @, #, ? and $ for float, integer, boolean and string respectively. To indicate that it should be an array, the data type operator should appear in square brackets. For instance [#] is an array of integer. Array elements that are assigned by a column reference are indexed by consecutive integers, from left to right, with the first integer being zero. Delimiters used to separate elements in an array can be a (the first) space, colon, hyphen or period found in the column's contents.

Some examples of column references:

Contents of "Column" Column Reference Value Created Notes
"Extreme Networks" {column:<ID>:$} Single value string $ is the default, so {column:<ID>} will produce the same result
"10.20.30.40" {column:<ID>:D[#]} Decimal text
Array of integer 		D is the default, so {column:<ID>:[#]} will produce the same result
"67-E5-9F-32-00" {column:<ID>:[#]H} Hexadecimal text
Array of integer 		Format operators are case insensitive and order independent
"system.sysUpTime.0" {column:<ID>:[$]} Array of string String is the default data type, so {column:<ID>:[]} will produce the same result

Variable References

A variable consists of a name, optionally followed by an array index in square brackets and an assigned value (of any data type). Variables can be used either as a single value or as an array of values. Variable values are assigned using any of the assignment operators (=, +=, _+, *=, /=, %=, &=, ^=, and |=). Variables are not defined as having a data type, but take on the data type of the value being assigned to it. For example, in the single value variable, var=12, var is the name of the variable, 12 is the value being assigned, and the equals sign (=) assigns the value to var. In this case the variable (var) takes the data type of 12, which is an integer. If a particular variable is assigned more than once in an expression, then the value for the variable is whatever the last assignment sets as the value.

Variables that are assigned as an array use the optional square brackets([]) to specify an array index. All elements in an array must share the same data type. However, the array index does not need to be the same data type as the array elements. An array index can be any expression and the expression can return any data type; it does not have to be an integer. If a particular variable is assigned more than once in an expression, first as an array, then is later as a single value, then the array is overwritten and the variable becomes a single-value (non-array) variable.

When assigning a value to a non-array variable using an array index, the variable becomes an array. In this case the data type of the array becomes the data type of the value being assigned. When assigning a value to an existing array, using an array index, then the newly assigned value will be converted to the data type of the existing array. This way all elements of an array will have the same data type, even though their indexes need not be of the same data type.

A variable is only an array if a value is assigned to it using an index. Variables can be referenced as any data type with the variable converting the data to the requested data type. Any variable can be assigned with a value of any data type. It can then be cast to any other data type, although the cast does not alter the contents of the variable. Any data type can be converted to any other data type, but some data loss may occur.

NOTE: When variables reference a particular array using more than one data type as an index, the array acts more like a Java Hashtable than an array.

Array elements assigned by a column reference must always be indexed by consecutive non-negative integer values, with the first being zero. Variables are accessed (read) by placing them in an expression at the point where their value is needed. If a non-array variable is referenced with an array index, the index is ignored. When a value is assigned to an array variable, the variable stores the last index used. This is used when an array variable is referenced without an index; this last index is used as the default.

Here are some examples of assigning values to variables:

count += 23 Add 23 to the variable named count. If count had a string or boolean before this, it has an integer after this.
ipAddress[0] = 10 Set the variable named ipAddress to be an array variable, and add an integer value of 10 indexed by the integer value of 0. If the variable was not an array before this it becomes an array with the data type of integer, and the 0 is stored as the first index. If ipAddress was an array before this assign, but not with a data type of integer, the integer of 10 is converted to the data type of the array and then stored.
offset = ++index This will change the values of both offset and index. They are converted to integer. offset is left with the value of index after the conversion, but before the increment.
ifTable["10.20.32.45"] = "XPedition" This will assign the string "XPedition" to the array variable ifTable. It is indexed by the string "10.20.32.45". If ifTable is already an array variable, but not of data type string, the string "XPedition" is converted to the appropriate data type. This would cause the data to be lost.

A variable created by a column routine or table function can be referenced by any other column routine or table function associated with the same table. System functions cannot reference table variables. Variables created by system functions, called system variables, can be referenced by all column routines and functions.

If a table variable has the same name as a system variable, a table function or column routine will reference the table variable, not the system variable by the same name. The table variable does not overwrite the system variable.

Function References

A function reference consists of a function name followed by a pair of parentheses. Optionally one or more parameters, separated by commas, can appear between the parentheses. Each parameter can be any value of any data type, or expression returning any data type. The functions can be a System function or a Table function.

A Table function is defined by the user, and can be called by other table functions or column routines associated with the same table A table function is created only from the Column Routine/Function panel in the FlexView Expression Editor.

System functions are pre-defined by Console. Most of the formatting will be done by these functions. Some examples are Substring(), FormatInteger(), FormatFloat(), etc. Non-formatting system functions are also available. Min() and Max() are two examples. A complete list appears in the appendix. All user-defined functions and column routines can call any system function.

Function parameters are names that appear in the function definition's parameter list. These names are substituted by values when the function is called by a function reference. These parameters act like a variable in that they hold values, and can have values assigned to them. However, function parameters are the only variables that can be referenced only by a single routine, and are the only variables to go out of existence once the routine completes. If a function parameter has the same name as another variable, the parameter will be referenced instead of the other variable by the same name. The other variable is not overwritten by the function parameter.

The following table lists the System Functions available with Console:

Category Name Arguments Description
Runtime Information DeltaTime start, end, units Returns a value that is the interval (in the specified units) between a start and end time. The format of a time value conforms to the DateAndTime TEXTUAL-CONVENTION as defined in snmpv2-TC (YYYY-MM-DD,hh:mm:ss.d,Z - year, month, day, hour, minutes, seconds, deciseconds (tenths), timezone. The units parameter is a single case-sensitive character string:
  • "Y" - Years
  • "M" -Months
  • "W" - Weeks
  • "D" - Days
  • "h" - Hours
  • "m" - Minutes
  • "s" - Seconds
  • "d" - Deciseconds (1/10ths)
  • "c" - Centiseconds (1/100ths)
  • "u" - Milliseconds (1/1,000ths)
When units is not specified, the default units is centiseconds.

When only one time is specified, it is assumed to be the start and the current local computer time is used as the end. The number of centiseconds between the two times is returned.

If the start is later than the end, a negative number is returned.

DeviceType IP Address Returns the Device Type for the IP Address as stored in the database and defined in deviceTypes.properties.
DisplayName IP Address Displays either IP Address, sysName, or NickName corresponding to this IP Address, according to the current setting for Display Name in the Options. If the device isn't currently in the database, the field will be left blank.
NickName IP Address Searches the database to find the Nickname corresponding to this IP Address and displays that value. If the device isn't currently in the database, the field will be left blank.
SystemDescription IP Address Searches the database to find the System Description corresponding to this IP Address and displays that value. If the device isn't currently in the database, the field will be left blank.
SystemName IP Address Searches the database to find the System Name corresponding to this IP Address and displays that value. If the device isn't currently in the database, the field will be left blank.
TimeTicks time Takes a time returned from the device (e.g. sysUpTime) and converts it to timeticks (1/100th of a second). This is useful for situations where you may want to know if happened within the last 10 minutes (600,000 timeticks).
Formatting BlueIcon string Adds a Blue icon (ball) before the string text.
BlueText string Colors the string text blue.
CreateInstance string Converts a text string to its numerical ASCII equivalent for use in an OID Instance.
FormatNumber number, decimals Inserts commas to the left of the decimal point in a (long) number and rounds to the number decimal places specified by decimals. The decimals parameter is the maximum number of digits to the right of the decimal point; the result may be shorter.
FormatTime number, units Takes a number and an optional units string and returns the number as a measurement of time. The units parameter is a single case-sensitive character string: "c" – Centiseconds (1/100 of seconds), "s" – Seconds, "m" – Minutes, "h" – Hours, "d" – Days,

When units is not specified, the default unit is centiseconds.

For example, using the FormatTime function to show 2,000,000 centiseconds:

FormatTime( 2.0e6 )    Returns 0 Days 5:33:20.00

and 2,000,000 seconds:

FormatTime( 2.0e6, "s" )    Returns 23 Days 3:33:20.00

GreenIcon string Adds a Green icon (ball) before the string text.
GreenText string Colors the string text green.
Magnitude number, decimals, suffix Converts to K (kilo), M (mega), or G (giga) based on the original number. The optional argument, decimals, specifies the number of decimal places in the result. The optional suffix (in quotes) lets you refine the magnitude label of your choosing (for example, adding "b", will display the value with Mb).
ParseInstance instance, start, length Converts an ASCII string in instance format to a text string. Specifying the optional value of start will start the conversion at the index specified. length defines the length of the converted string.
RedIcon string Adds a Red icon (ball) before the string text. (Note 1)
RedText string Colors the string text red. (Note 1)
YellowIcon string Adds a Yellow icon (ball) before the string text. (Note 1)
YellowText string Colors the string text yellow. (Note 1)
String
Manipulation 		Contains string, search Scans a string for search. If found, returns the position of the first character in search. If not found, returns -1.
Index string, character Returns the index of the location of the first occurrence of the specified character in the string. If the character is not found, returns -1. (Note 3)
LastIndex string, character Returns the index of the location of the last occurrence of the specified character in the string. If the character is not found, returns -1. (Note 3)
LowerCase string Converts all of the characters in the string to lower case.
StringLength string Returns the length of string as a count of the characters.
Substring string, start, end Returns a new string that is a sub-string of string. It starts at the index, start, and stops at end. For example Substring ("0123456789", 2, 7) will return "23453". This function is zero-based. If start is < 0 , > StringLength, or not specified the start parameter defaults to 0.
UpperCase string Converts all of the characters in the string to upper case.
Mathematical Max floatA, floatB Returns the larger of two values, floatA or floatB. If the values are equal, it will return that value. If either value is null or empty, it will return null.
Min floatA, floatB Returns the smaller of two values, floatA or floatB. If the values are equal, it will return that value. If either value is null or empty, it will return null.
Percent portion, total, decimals Returns the result of portion divided by total, carried out to the number of decimals and followed by a percent sign (%). The result is rounded, depending on the number of decimals defined. (Note 2)
Power base, power Returns a value of base, raised to the power of power.
Round float Returns the closest whole number to float.
SquareRoot float Returns the positive square root of float.
Array
Manipulation 		ArrayLength array Determines the length of the given array. If the variable is not an array, returns zero (0). Otherwise, it gives the length of th array, not th index of the last item.
IsArray array Determines whether the given variable (array) is an array and returns true or false.
Notes:
  1. Icon and Text attributes are produced by appending hidden code to a string and therefore, you should not perform other string functions on the results of these functions.
  2. If total= 0, Percent will return a divide by zero error.
  3. If a string is used as the character parameter, only the first character of the string is used in the search.

Related Information

For information on related windows:

For information on related concepts:

For information on related tasks: