Serialized Form
gamma
double gamma
- The gamma value controls the output of the 'compensatory and' function.
By default it is set to 0.562 which apparantly gives good (expected) results
according to a study done. Note that by setting gamma to 0 we get the
equivalent of the ProductAntecedentCombineOperator.
increment
int increment
- The increment amount by which the DoubleVector expands when it reaches
capacity and has to insert another double value. This increment value
can be set by choosing a constructor that allows you to specify it.
d
double[] d
- The array of doubles values. This array is manipulated in such a way that it
will expand as required to accomodate the addition of double values after the
DoubleVector is created.
index
int index
- The current number of double values in the array, and the index of the array
at which the next double value should be inserted.
m_globalContributionOperator
nrc.fuzzy.jess.GlobalContributionOperator m_globalContributionOperator
- Determines how global contribution is to be done when a fact
with fuzzy values is asserted. There are at least 3 options:
1. fuzzyUnion of the FuzzyValues (default)
2. fuzzySum of the FuzzyValues
3. Replace the FuzzyValues (i.e. no global contribution)
Other operator may be added by users or as part of the system.
m_currentActivation
jess.Activation m_currentActivation
m_currentActivationFuzzyRule
nrc.fuzzy.FuzzyRule m_currentActivationFuzzyRule
- Holds a FuzzyRule for current rule activation during
the time a rule is firing. It will be null when there
is no rule firing and will be set if required when an
activation is firing (ie. when there asserts during
the rule firing that have fuzzy values in the slots).
antecedents
nrc.fuzzy.FuzzyValueVector antecedents
- A vector of FuzzyValues that represent the antecedents in the rule
conclusions
nrc.fuzzy.FuzzyValueVector conclusions
- A vector of FuzzyValues that represent the conclusions in the rule
inputs
nrc.fuzzy.FuzzyValueVector inputs
- A vector of FuzzyValues that represent the inputs for the rule
executor
nrc.fuzzy.FuzzyRuleExecutor executor
- The FuzzyRuleExecutor that will be used when the rule is executed (fired)
to generate the fuzzy value output vector
antecedentCombineOperator
nrc.fuzzy.AntecedentCombineOperator antecedentCombineOperator
- The operation used to combine the match values for multiple antecedent/input
pairs in this rule (minimum or product)
antecedentsChanged
boolean antecedentsChanged
- A flag that is set to true when the antecedents set has changed between
rule firings
conclusionsChanged
boolean conclusionsChanged
- A flag that is set to true when the conclusion set has changed between
rule firings
inputsChanged
boolean inputsChanged
- A flag that is set to true when the input set has changed between
rule firings
antecedentCombineOperatorChanged
boolean antecedentCombineOperatorChanged
- A flag that is set to true when the operation (minimum or product) for
combining antecedent/input match values has changed between rule firings
set
nrc.fuzzy.SetPoint[] set
- This is the heart of the FuzzySet, an array of SetPoints which represent
the FuzzySet.
numPoints
int numPoints
- The
numPoints variable keeps track of the number of points
contained in set, the array of SetPoints.
simplified
boolean simplified
- The
simplified variable is a boolean used to indicate whether
or not the FuzzySet has been 'simplied' (revove extra points in the set -- see
the simplifiySet method)
m_theParent
nrc.fuzzy.jess.FuzzyToken m_theParent
- The Parent of this token. This attribute is added so that it
is possible to traverse the tokens associated with an activation
(these hold the facts that matched on the LHS of a rule).
m_extensionData
java.util.Vector m_extensionData
- Data needed to support Jess (Fuzzy) Extensions can be carried around
in this special Vector. In general this is added to support the
need to store 'special' information with facts as they work their
way through the rete network. When the RHS of a rule fires the
m_token associated with the activation will have a list of all of
facts that contributed to the rule's firing. The 'special' information
can be added during function calls that are made during the
tests that are performed as patterns are matched. In general this
information will be attached to the token that holds the fact as
it moves through the net to a terminal node. It is
required that the data stored be associated with one and only one
traversal of the path. Since a token, with its fact, can actually
take several paths through the net, it is sometimes necessary that
the 'special' data be added to a new token (a copy of the
current token with the extension data added to it) so that it
becomes a unique token from that point on in the traversal through
the net. This allows the system to identify that a
new token should be formed and passAlong'd down the net from that point.
The original token will be used for other paths without the special
data. This is taken care of in various places in the Jess code with
the addition of calls to the 'prepare' method. Other extensions can
then use the same hooks to record any information required as the
facts move through the net.
The KEY thing here is that in Jess the 'prepare' method must be called
after each pattern is matched AND any tests were done (in particular
for the fuzzy extension whenever the fuzzy-match function is called ...
but since this is a general mechanism prepare is called whenever any
test functions are called ... the prepare function has a single
parameter that is true when the pattern test was successful and false
when is was not. This lets the extension take action depending on
the success of the test(s). In the fuzzy extension the fuzzy-match
function puts information in the token in the m_extension slot ...
the pattern fuzzy value and the fact fuzzy value pair(s) that matched.
If the tests for the pattern were successful then the token is duplicated
and the m_extensionData slot of the original token is cleared. If it
fails then the m_extensionData slot of the original is cleared (since
the info is not needed ... the pattern match failed).
fuzzyVariable
nrc.fuzzy.FuzzyVariable fuzzyVariable
- Holds the FuzzyVariable associated with the FuzzyValue. The fuzzy variable
determines the context within which a fuzzy value has meaning. It provides
the language (the variable itself, such as temperature, as well as the
terms such as hot or cold, and the universe of discourse for the variable)
used to describe a fuzzy concept.
linguisticExpression
java.lang.String linguisticExpression
- Contains the linguistic expression, or the english phrase which linguistically
describes the FuzzyValue. For example, if the FuzzyVariable was temperature, the
linguistic term might be any of the following: cold, warm, hot,
not cold AND somewhat warm, very warm AND more_or_less hot, etc. The linguistic
term very often defines the FuzzyValue, and the FuzzySet contained within the
FuzzyValue is then created by applying the modifiers and operations in the
linguistic expression to pre-existing terms.
fuzzySet
nrc.fuzzy.FuzzySet fuzzySet
- Contains the FuzzySet, or the set of points that give the FuzzyValue
mathematical meaning.
increment
int increment
- The increment amount by which the FuzzyValueVector expands when it reaches
capacity and has to insert another FuzzyValue. This increment value
can be set by choosing a constructor that allows you to specify it.
fuzzyValues
nrc.fuzzy.FuzzyValue[] fuzzyValues
- The array of FuzzyValue values. This array is manipulated in such a way that it
will expand as required to accomodate the addition of FuzzyValues after the
FuzzyValueVector is created.
index
int index
- The current number of FuzzyValues in the array, and the index of the array
at which the next FuzzyValue should be inserted.
name
java.lang.String name
- The string name of the fuzzy variable
units
java.lang.String units
- The units (such as Degrees C) for the varible
UOD
double[] UOD
- The Universe of Discourse (x value range) for the variable
fuzzyTerms
java.util.Hashtable fuzzyTerms
- The fuzzy terms described as FuzzyValues are stored in this hash table
lowX
double lowX
openFlagLow
boolean openFlagLow
highX
double highX
openFlagHigh
boolean openFlagHigh
nf
java.text.NumberFormat nf
increment
int increment
- The increment amount by which the IntervalVector expands when it reaches
capacity and has to insert another Interval. This increment value
can be set by choosing a constructor that allows you to specify it.
intervals
nrc.fuzzy.Interval[] intervals
- The array of Interval values. This array is manipulated in such a way that it
will expand as required to accomodate the addition of Intervals after the
IntervalVector is created.
index
int index
- The current number of Intervals in the array, and the index of the array
at which the next Interval should be inserted.
message
java.lang.String message
- The message constructed to inform the user, to a greater degree, what
has gone wrong.
DOF
double DOF
defaultNumPoints
int defaultNumPoints
- This value is used to determine the number of points that will be
in the gaussian-shaped fuzzy set generated by the
generateFuzzySet(double leftX, double rightX) method,
unless it has a value of < 5, in which case the value of static (class)
variable, LeftGaussianFunctionDefaultNumPoints, will be used. This allows
each instance of the LeftGaussianFunction to determine its own value for the number
of points to be generated. Initially it is set to have the value 0 so
that the LeftGaussianFunctionDefaultNumPoints value is used.
DOF
double DOF
m_name
java.lang.String m_name
- The string name of the modifier function (as used in linguistic expressions).
For example, the modifier function "very" might be used in an expression
like "very cold".
yValue
double yValue
- The y value for which an x value could not be found
message
java.lang.String message
- The message constructed to inform the user, to a greater degree, what
has gone wrong.
defaultNumPoints
int defaultNumPoints
- This value is used to determine the number of points that will be
in the gaussian-shaped fuzzy set generated by the
generateFuzzySet(double leftX, double rightX) method,
unless it has a value of < 5, in which case the value of static (class)
variable, LeftGaussianFunctionDefaultNumPoints, will be used. This allows
each instance of the LeftGaussianFunction to determine its own value for the number
of points to be generated. Initially it is set to have the value 0 so
that the RightGaussianFunctionDefaultNumPoints value is used.
x
double x
- The x value of this SetPoint.
y
double y
- The membership value (graphically, the y value) of the point
x in a FuzzySet.
defaultNumPoints
int defaultNumPoints
- This value is used to determine the number of points that will be
in the S-shaped fuzzy set generated by the
generateFuzzySet(double leftX, double rightX) method,
unless it has a value of < 3, in which case the value of static (class)
variable, sFunctionDefaultNumPoints, will be used. This allows
each instance of the SFunction to determine its own value for the number
of points to be generated. Initially it is set to have the value 0 so
that the sFunctionDefaultNumPoints value is used. If the number
is even it will be set to the next higher odd value
(to maintain symmetry for the S curve).
s
java.lang.String[] s
index
int index
DOF
double DOF
prevValue
double prevValue
- The value previous to the x value which is out of order.
currentValue
double currentValue
- The x value which is out of order. It has been identified as the x value
that is out of order because its value is less than the x value previous
to it.
message
java.lang.String message
- The message constructed to inform the user, to a greater degree, what
has gone wrong.
yValue
double yValue
- The y value whose range is outside the strict acceptable range of
0.0 to 1.0 inclusive, or [0.0, 1.0].
message
java.lang.String message
- The message constructed to inform the user, to a greater degree, what
has gone wrong.
defaultNumPoints
int defaultNumPoints
- This value is used to determine the number of points that will be
in the Z-shaped fuzzy set generated by the
generateFuzzySet(double leftX, double rightX) method,
unless it has a value of < 3, in which case the value of static (class)
variable, zFunctionDefaultNumPoints, will be used. This allows
each instance of the ZFunction to determine its own value for the number
of points to be generated. Initially it is set to have the value 0 so
that the zFunctionDefaultNumPoints value is used. If the number
is even it will be set to the next higher odd value
(to maintain symmetry for the Z curve).