Purpose

The module PartiallyEvaluateLinearFunction partially evaluates a piecewise multi-linear function.

That means that values are inserted for some of the variables and the result is a function of the remaining variables.

Tips

Partially evaluating a function certainly reduces the number of variables. Since, by convention, the variables are always numbered consecutively and start with 0, the remaining variables (after the evaluation) are likely to change their numbers.

However, their order is never changed. That is, in the above mentioned example, if the polynomial has dimension 7, the remaining variables (which are 0, 1, 4, and 6) are renumbered to be 0, 1, 2, and 3 (in this order).

Windows

Default Panel

../../../Modules/ML/MLStochasticCollocation/mhelp/Images/Screenshots/PartiallyEvaluateLinearFunction._default.png

Input Fields

inputFunction

name: inputFunction, type: MLBase

Output Fields

outputFunction

name: outputFunction, type: MLBase

Parameter Fields

Field Index

Apply: Trigger
Auto apply: Bool
Evaluate unscaled: Bool
Evaluation Mode: Enum
Keep all nodes: Bool
List of Values: String
List of Variables: String

Visible Fields

List of Variables

name: variableList, type: String

Sets a comma-separated list of variable numbers with respect to which the polynomial has to be evaluated.

The numbering starts with 0. Do not use the same number several times.

List of Values

name: valueList, type: String

Sets a comma-separated list of values that shall be inserted into the polynomial.

The way these values correspond to the variable numbers depends on the field Evaluation Mode.

Evaluation Mode

name: evalMode, type: Enum, default: Values for Selected Variables Only

Defines the evaluation mode and thus how the fields List of Values and List of Variables are interpreted.

Values:

Title Name Description
Values for Selected Variables Only Values for Selected Variables Only In this case, you should supply the same number of entries to both lists. The values and variables correspond to each other by the order in which they are given. E.g., if you say 3,5,2 for the List of Variables and 33.0,55.7,2.345 for the List of Values, then 2.345 is inserted for variable number 2; 33.0 is inserted for variable number 3, and 55.7 is inserted for variable number 5. Changing the order of both lists in the same way will not alter the result.
Values for All Variables Values for All Variables In this case, you should supply as many entries to List of Values as the dimension of the polynomial indicates. The first value corresponds to the first variable and so on, no matter which variables actually occur in the List of Variables To get the same result as above, you could e.g. enter 3,5,2 as List of Variables and 0,9999,2.345,33.0,-42,55.7,2000 as List of Values. The values 0, 9999, -42, and 2000 will in this case be ignored. Changing the order of the List of Variables will not alter the result, but changing the order of the List of Values will.
Evalulate Non-Selected Variables Evalulate Non-Selected Variables This is very much like Values for All Variables except that you are supposed to enter the numbers of those variables with respect to which you want the polynomial to be not evaluated. To get the same result as above, you could e.g. enter 6,1,0,4 as List of Variables (if the dimension of your polynomial is 7) and 0,9999,2.345,33.0,-42,55.7,2000 as List of Values The values 0, 9999, -42, and 2000 will be ignored. Changing the order of the List of Variables not alter the result, but changing the order of the List of Values will.

Keep all nodes

name: keepAllNodes, type: Bool, default: FALSE

This influences the internal representation of the result in that, if enabled, nodes that do not have an influence on the result are still kept (with weight 0 then). This does not change any values of the function. Actually, the cases where the internal is changed are also very rare. You should not enable this unless you have a very special reason to do so.

Evaluate unscaled

name: evalUnscaled, type: Bool, default: FALSE

If checked, the evaluation point will be interpreted as a point in the box [-1,1]n rather than the function's actual bounding box.

Note that this is the way the function is internally stored, i.e. checking this box actually disables the scaling of the point from the function's bounding box to [-1,1]n.

Auto apply

name: autoApply, type: Bool, default: FALSE

If checked, the module computes anew on any parameter or input change.

Apply

name: apply, type: Trigger

If pressed, the module computes anew.