This actor compares the inputs against the value specified by the
correctValues parameter. That parameter is an ArrayToken,
where each element of the array is of the same type as the input.
On each firing where the input is present, the value of the input
is compared against the next token in the correctValues
parameter. If it matches, the firing succeeds. If it doesn't
match, then an exception is thrown. After matching each of
the value in the correctValues parameter, subsequent iterations
always succeed, so the actor can be used as a "power-up" test for a model,
checking the first few iterations against some known results.

Unlike the Test actor, NonStrictTest does not support a multiport
input, only single port inputs are supported. This also differs
from Test in that it ignores absent inputs, and it checks the inputs
in the postfire() method rather than the fire() method.

This actor accepts any type of data on its input port, therefore it
doesn't declare a type, but lets the type resolution algorithm find
the least fixed point. If backward type inference is enabled, and
no input type has been declared, the input is constrained to be
equal to BaseType.GENERAL. This will result in upstream
ports resolving to the most general type rather than the most specific.

If the input is a DoubleToken or ComplexToken, then the comparison
passes if the value is close to what it should be, within the
specified tolerance (which defaults to 10-9).
During training, if a correct value is
greater than 10 orders of magnitude than the tolerance, then the
tolerance is changed to a value 9 orders of magnitude less than
the correct value. This helps avoid comparisons beyond the
precision of a Java double.

If the parameter trainingMode is true, then instead
of performing the test, this actor collects the inputs into the
correctValues parameter. Thus, to use this actor, you can
place it in a model, set trainingMode to true to
collect the reference data, then set trainingMode to
false. Any subsequent run of the actor will throw an
exception if the input data does not match the training data.
The value of the reference token is set in the wrapup() method.
The trainingMode parameter is a shared parameter,
meaning that if you change it for any one instance of this
actor in the model, then it will be changed for all instances.

Field Detail

correctValues

tolerance

A double specifying how close the input has to be to the value
given by correctValues. This is a DoubleToken, with default
value 10-9. During training, if a correct value is
greater than 10 orders of magnitude than the tolerance, then the
tolerance is changed to a value 9 orders of magnitude less than
the correct value. This helps avoid comparisons beyond the
precision of a Java double.

requireAllCorrectValues

If true, and the number of tokens seen in wrapup() is not
equal to or greater than the number of elements in the
correctValues array, then throw an exception. The
default value is true. This parameter is a shared parameter,
meaning that changing it for any one instance in a model will
change it for all instances in the model.

trainingMode

If true, then do not check inputs, but rather collect them into
the correctValues array. This parameter is a boolean,
and it defaults to false. It is a shared parameter, meaning
that changing it for any one instance in a model will change
it for all instances in the model.

TRAINING_MODE_ERROR_MESSAGE

public static final java.lang.String TRAINING_MODE_ERROR_MESSAGE

Exception message that is used if we are running under
the nightly build and the trainingMode parameter is true.

postfire

Read one token from each input channel and compare against
the value specified in correctValues. If the token count
is larger than the length of correctValues, then return
immediately, indicating that the inputs correctly matched
the values in correctValues and that the test succeeded.

_checkRangeOfTolerance

Check that the difference in exponents between the
input and the tolerance is not greater than the precision
of a Double. If the exponent of newValue parameter is
different by from the exponent of the tolerance
parameter by more than 10, then adjust the tolerance
parameter. This is useful for training large modesl
that have many PublisherTests.

Parameters:

newValue - The token to be tested. DoubleTokens
are tested, other tokens are ignored.

_isCloseToIfNilArrayElement

Test whether the value of this token is close to the first argument,
where "close" means that the distance between them is less than
or equal to the second argument. This method only makes sense
for tokens where the distance between them is reasonably
represented as a double. It is assumed that the argument is
an ArrayToken, and the isCloseTo() method of the array elements
is used.
This method differs from
ArrayToken._isCloseTo(Token, double)
in that if corresponding elements are both nil tokens, then
those two elements are considered "close", see
Token.NIL.

Parameters:

token1 - The first array token to compare.

token2 - The second array token to compare.

epsilon - The value that we use to determine whether two
tokens are close.

Returns:

True if the first argument is close
to this token. False if the arguments are not ArrayTokens

_isCloseToIfNilRecordElement

Test whether the value of this token is close to the first argument,
where "close" means that the distance between them is less than
or equal to the second argument. This method only makes sense
for tokens where the distance between them is reasonably
represented as a double. It is assumed that the argument is
a Record, and the isCloseTo() method of the record elements
is used.
This method differs from
RecordToken._isCloseTo(Token, double)
in that if corresponding elements are both nil tokens, then
those two elements are considered "close", see
Token.NIL.

Parameters:

token1 - The first array token to compare.

token2 - The second array token to compare.

epsilon - The value that we use to determine whether two
tokens are close.

Returns:

True if the first argument is close
to this token. False if the arguments are not ArrayTokens