ADONIX calculated expressions

Presentation

In a certain number of screens in the parameterization, there is the possibility to enter calculation formulas, still called adonix expressions (the execution engine for the software using X3 technologies is in fact called adonix). These expressions are expressed in an algebraic format and form part of a general language. Below is given a general description of the functions that can be used in Adonix expressions.

Numerous aides exist during the entry of a formula, both to provide information on the available variables and functions but also to explain the significance of the formula. These aides are accessible by means of the formula editor.

It is possible to test an expression (in which only the accessible constants and variables for the context are available) using a calculator.

ADONIX expression type

An ADONIX expression can be of the alphanumeric, numeric or date type. According to where the parameterization is carried out, it is possible to need on or other of these types (even if all the types can be used in a formula, the functions of a given type can call the arguments of another type). It should be noted that the type function is used to test the type of a variable.

How to set up an ADONIX expression

An expression is made up of constants, operators, variables and functions.

Constants

The constants can be:

    alphanumeric : expressed either between apostrophes(') or inverted commas ("). Here are two examples of valid strings:

	"It's certain"
	'a specific "string" '

    numeric  : expressed with a decimal point if required. Here are two examples of valid numeric constants:

	-2.5
	123000

    date : expressed in the form [ day / month /year ]. It should be noted that it is mandatory to express the year on 4 figures. Here are two examples of valid date constants:

	[15/3/2002]
	[21/05/1819]

    logic type : these are bound up with the numeric constants: 1 (and by extension all non zero values) equivalent to True, 0 equivalent to False.

Operators

The following are the valid operators:

	+	addition of two numbers, a date and a number of days, or the concatenation of two character strings.
	-	subtraction of two numbers, a date and a number of days, or the concatenation of two character strings by inserting a space between the two strings.
	*	multiplication of two numbers
	/	division of two numbers
	^	increase to the power of
	< <= > >= <>	comparison operators
	and or xor not	logical operators, that can also be abbreviated as & | ? !

In addition, there is available the possibility to use brackets with an unlimited level of overlapping.

Variables

A variable is expressed in general fashion in the form of:

[ class ] nomvar ( index )

For example, it is possible to define the following variables:

	[F:BPC]BPCNAME
	MA_VARIABLE
	ELEMENT(33)

The name of the nomvar variable is expressed in the form of letters and/or numbers, the first character always being a letter and the underline character can also be used. The significant length of a variable name is limited to 12 characters. All the names are authorised, with the exception of certain reserved key-words (File, Until, or Commit are examples of some of these key-words). When a variable name is entered using lower case letters, it is automatically transformed to uppercase letters, except if it is a key-word.

Certain variables can be dimensioned, that is to say they corresponds to the element tables (dimensions 1 to 4 are possible) In this case, one or more indexes is given in the form of numeric expressions, separated by commas (if there are more than one), between brackets (for example M_TB(1,2,8) is a valid syntax).

A class corresponds to a group of variables linked to a context. The most used classes are the following:

    [V] : global variable class. A variable of this type is linked to the ADONIX session. Once created, it remains accessible whilst it is not destroyed, or whilst the ADONIX session is not stopped. Its declaration is made with the help of dedicated instructions (according to its type, the Integer, Decimal, Char, Date, Label, Shortint, Float, Double instructions are used).

    [L] : Local variable class. It is linked to an overlapping of a sub-programmed (each Call instruction creates a new class of local variables which mask the previous class). The declaration of variables of this type is carried out in the same way as the previous variable type, but the declaration is preceded with the key-word Local.

    [C] : Sequence number type variables class. These are the variables common to all the levels of a folder. Their creation is made by a dedicated development function.

    [F:abv] or [abv] : this is the class of variables linked to a table declared by the File instruction. Within these are found the values of the current record.

    [M:abv] or [abv] : this is the class of variables linked to an entry screen declared with the Mask instruction. Found here are the values that have been entered or likely to be displayed (each tab in a screen is considered as a mask).

The class is not mandatory, because the rules make it possible to know the class by default.

There exist a number of system variables directly managed by Adonix. Whilst the other variables are transformed, during entry to uppercase, these variables that make up a part of the language key-words, are displayed in lower case. Here are a few of the system variables that can be used (not an exhaustive list):

Name	Type	Definition
nomap	string	current folder name
datesyst	date	modifiable system date
adxdir	string	Adonix root directory
nolign	numeric	current line number
fstat	numeric	return status after the read or posting to a table

Functions defined in the engine

A function expressed in the function form (list of arguments). A large number of functions exist: processing of character strings, date calculations, classic numeric functions, truncation and rounding functions, statistical functions....

A list of the principal functions that can be used in ADONIX is given below. In the functions grid, the write conventions are as follows:

    v is an argument for any type (the same for v1,v2,v3...)

    c is an argument for the character string type

    x is an argument for the numeric type

    n, p, q... are arguments for the integer type

    V is a variable

    list is a list of variables or expressions. In this list type, a TABLO variable of the grid type can be used in the form of TABLO(I) (only one index is used), TABLO (all the indexes are used) or TABLO(I..J) (the indexes I to J inclusive are used).

Syntaxes	Type	Definition
date$	date	current date
sin(x), cos(x), tan(x)	numeric	trigonometric functions
asin(x),acos(x)...	numeric	inverse trigonometric functions
log(x),exp(x),ln(x)	numeric	logarithmic functions
abs(x), sgn(x)	numeric	absolute value, sign
ar2(x), arr(x,y)	numeric	round to 2 decimals, round to x - y
int(x), mod(x,y)	numeric	integer part, modulo
len(c)	numeric	length of a string
day(d),month(d),year(d)	numeric	extraction of day, month, year for a date
dayn(d),week(d)	numeric	day number in the week, week number
num$(x)	string	convert a number to a string (decimal representation)
space$(n), chr$(n)	string	string composed of n spaces, with 1 character with the internal code n
string$(n,c), string$(n,x)	string	string made of of n characters with the code c (or n character with the code x)
day$(d), month$(d)	string	day name, month name
addmonth(d,n)	date	the date d where a month n has been added
eomonth(d)	date	the last day of the month corresponding to the date d
left$(c,n), right$(c,n)	string	right/left section of a string made up of n characters
mid$(c,n,p), seg$(c,n,p)	string	extraction of sub-strings for a given string
gdat$(n,p,q)	date	construction of a date (n=day, p=month, q=year)
pat(c1,c2)	numeric	verify the conformity of a string c1 to a template c2 (1 if it conforms, 0 if not). The template can include the wild-card characters * (any number of any characters), ? (any character), # (any number).
min(list), max(list)	all types	minimum or maximum for a group of variables or values
sum(list), prd(list)	numeric	sum, product of a group of variables or values
avg(list), var(list)	numeric	average, variance for a group of variables or values
sum(list)	string	concatenation of a group of string variables or values
uni(list)	numeric	verification of uniqueness for a group of variables or values
find(v,list)	numeric	search for a value of any type in a list
evalue(c)	all types	evaluation of a character string containing an expression
format$(c,v)	string	formatting of a value with a given format c.
toupper(c),tolower(c)	string	transformation in lower case, upper case
sigma(V=v1,v2,v3)	numeric	sum (V variant V1 to V2), of the v3 expression of the function of V

Functions defined by the developers

There also exist functions defined by developers and these can be used in calculation expressions, using the following syntax:

func TRAIT.FUNCT(list of arguments)

PROC being the name of the process and FUNCT being the name of the function concerned. It should be noted that the functions that can be used are documented in the sub-programme table.