Parameterizing input data

Parameter

The following contextual zone is dedicated to abstraction of code & dataset as a numerical function,

the input being all variables defined in dataset,
the function being the code applied on dataset,
the output being all readable output produced by the code.

Practically, all following steps are unordered as soon as an input file is opened.

Model and data

The first step is to select the code (including its version) in the “Model” combo box after having added a new project using

The first models in the list are supposed to accept the input file. The Help button opens the web browser on a web page dedicated to code.The second optional step is to add/delete complementary input files (like libraries for instance).

Input file editor

The last step is to edit the imported input files one-by-one (current edited file is the one selected in “Dataset” list) to defined Promethee input parameters.

The upper toolbar provides:

Edit/Cancel/Save actions (resp.):
- Edit: authorizes to modify the current file
- Cancel: restores the file before edition
- Save: definitely apply the edition changes and parse the file to search/update “Input variables” and “Output values”.
Basic search feature typing any character in text field starts a circular case-sensitive search on whole input file (forward search launched by ).
Note than green background notifies matchable search while red means “no occurrence found”.
Parameterizing syntax for:
- Variables: !(…)
```
... !(x1), !(x2), !x3, !x4, !x5, !x6, !x7, !x8 ...
```
  string is interpreted as 8 variables: x1, x2, x3, x4, x5, x6, x7, x8 ¹⁾
- Formulas: @[…]
```
... @[cos(!x1+!x2)] ...
```
  will not parse new variables, but automatically replce the string ”@[cos(!x1+!x2)]” by cos(x1+x2) numerical value, where x1 and x2 are variables.
- Functions: #@: …
```
...
#@: f <- function(x) {if (x>1) {x+1} else {cos(x)} }
... @[f(!x1)] ...
```
  will add the new function “f” in the Math. engine. It means that you can call anywhere in the dataset the function “f”. Note that the # character is the “line comment” character of the code.
- Tests: #@? f(0.5) == 1.5
```
...
#@: f <- function(x) {if (x>1) {x+1} else {cos(x)} }
#@? f(0.5) == cos(0.5)
... @[f(!x1)] ...
```
  will check that the test expression is true, instead the project will not launch. This feature is especially useful when checking that functions are well written.

Extended parameterizing syntax examples

!(x1~0.123) means that default value for “x1” variable is “0.123”
!(x1~{0.1,0.2,0.3}) will setup x1 values to 0.1,0.2 and 0.3
!(x1~:g) will setup x1 as belonging to the “g” group of variables
@[cos(!x1+!x2)|0.000E00] means that when evaluating formula, only three decimal characters will be kept, and scientific formt will be used: “0.456E-01” for instance. More information on this formt pattern: see Java DecimalFormat doc
#@: f ← function(x) {x + !x1} is a possible syntax. The variable x1 is like a “global” variable for f (in fact it is roughly replced before any call to math. engine).

Function I/O

Finally, all previous changes are displayed in the above I/O tables: “Input variable” and “Output values”:

In this case, 8 code input variables are found: “x1”, …, “x8” and one output scalar is expected: “z”.

Intermediate variables

If other variables are computed in the Math. environment:

...
#@: f <- function(x) {if (x>1) {x+1} else {cos(x)} }
#@: a <- 3.14
... @[f(!x1)+a] ...

, then these “intermediate” variables are presented in a third table between input and output ones.
Note that if the name of this intermediate variable starts with ”.”, it remains invisible for the user.

¹⁾ note that variable delimiters ”(” and ”)” are optional when unambiguity