|
AddActivation(TActivation)
|
Adds the rule activation to the CurrentModule's Agenda. If Rule has AutoFocus on, we need to set the context to the rule's module
|
|
AddDefaultFuzzyTerms(IFuzzyVariable)
|
Represents method AddDefaultFuzzyTerms(IFuzzyVariable).
|
|
AddDefaultPackages
|
Represents method AddDefaultPackages.
|
|
AddDefinedType(IIEDefinedType)
|
Represents method AddDefinedType(IIEDefinedType).
|
|
AddFactTemplate(IFactTemplate)
|
Represents method AddFactTemplate(IFactTemplate).
|
|
AddFactToModule(IFact,IModule)
|
Asserts the fact ONLY into the specified module. Even if the fact is a shared fact, it is not inserted into other modules
|
|
AddFunction(IUserFunction)
|
Represents method AddFunction(IUserFunction).
|
|
AddModule(IModule)
|
Adds the Module to the inference engine's Modules property. The module is initialized and all imports are performed at this time.
If the module is the MAIN module, the module is added at the front of the Modules list. Otherwise it is added at the end.
|
|
AddPendingFact(IFact,Boolean)
|
Adds the specified fact to the FactsPending list as either an assertion or retraction. The FactsPending list is processed after rule execution to assure all facts are updated
|
|
AddRule(TRule)
|
Represents method AddRule(TRule).
|
|
AddUserFunction(IUserFunction)
|
Adds a function to the expert system. The function returns true if the user function was successfully added. If the name of the function equals a function already in the function base, the old function will be deleted. After functions have been added, you may access them by using the UserFunctions property
|
|
Assert(IFact,Boolean)
|
Overloaded. Asserts a fact into the fact base. For non-fuzzy facts (facts with no fuzzy slots), the assert method searches the fact base. If the fact is already in the fact base, the method returns -1. If this is a new fact, the fact is asserted and the new fact id is returned. The new fact is matched against the rules within the expert system and may cause some rules to be activated.
For fuzzy facts, the assert method also searches the fact base. If the fact is found, the old fact and the new fact are combined. The inference engine calculates the union of the two facts based on the FuzzyInferenceMethod property, this is called a conditional assertion.
If Unconditional is true, the assertion calculates the intersection of the two facts as the new fact.
|
|
Assert(IFact,TFuzzyInferenceMethod,Boolean)
|
Overloaded. Asserts a fact into the fact base. For non-fuzzy facts (facts with no fuzzy slots), the assert method searches the fact base. If the fact is already in the fact base, the method returns -1. If this is a new fact, the fact is asserted and the new fact id is returned. The new fact is matched against the rules within the expert system and may cause some rules to be activated.
For fuzzy facts, the assert method also searches the fact base. If the fact is found, the old fact and the new fact are combined. The inference engine calculates the union of the two facts based on the FuzzyInference parameter, this is called a conditional assertion. If Unconditional is true, the assertion calculates the intersection of the two facts as the new fact.
|
|
Assert(String)
|
Overloaded. Asserts a fact into the fact base. For non-fuzzy facts (facts with no fuzzy slots), the assert method searches the fact base. If the fact is already in the fact base, the method returns -1. If this is a new fact, the fact is asserted and the new fact id is returned. The new fact is matched against the rules within the expert system and may cause some rules to be activated. For fuzzy facts, the assert method also searches the fact base. If the fact is found, the old fact and the new fact are combined. The inference engine calculates the union of the two facts based on the FuzzyInferenceMethod property, this is called a conditional assertion.
|
|
Assert(TFact)
|
Overloaded. Asserts a fact into the fact base. For non-fuzzy facts (facts with no fuzzy slots), the assert method searches the fact base. If the fact is already in the fact base, the method returns -1. If this is a new fact, the fact is asserted and the new fact id is returned. The new fact is matched against the rules within the expert system and may cause some rules to be activated.
For fuzzy facts, the assert method also searches the fact base. If the fact is found, the old fact and the new fact are combined. The inference engine calculates the union of the two facts based on the FuzzyInference parameter, this is called a conditional assertion.
|
|
Assign(TPersistent)
|
Represents method Assign(TPersistent).
|
|
Batch(TFilename,TEncoding)
|
Overloaded. Performs batch processing of expert systems. It redirects calls for standard input within the expert system to the contents of the file specified by filename. Everytime the inference engine receives a request for input, it reads from the file instead. The Batch method provides automated execution of your expert system. If the batch processing was successful, this method returns True
|
|
Batch(TStream,TEncoding)
|
Overloaded. Performs batch processing of expert systems. It redirects calls for standard input within the expert system to the contents of the stream. Everytime the inference engine receives a request for input, it reads from the stream instead. The Batch method provides automated execution of your expert system. If the batch processing was successful, this method returns True
|
|
BeginFactModify(IFact)
|
Informs the inference engine that you are modifying the fact. Use the BeginFactModify and EndFactModify methods to safely modify facts in the fact base (Facts property). BeginFactModify retracts the fact before you begin modifying it so that the Rete network will not be compromised by your modifications. EndFactModify re-asserts the fact into the fact base
|
|
BeginInference
|
Represents method BeginInference.
|
|
Clear
|
Overloaded. Clears the entire engine: all modules are deleted, all rules, all facts, fact templates. defined types and fact sets are deleted, and all interpreted functions (IInterpretedFunction interface) are deleted
|
|
Clear(IModule)
|
Overloaded. Clears the structures for the given module: all rules, all facts, fact templates. defined types and fact sets are deleted
|
|
ClearDefinedTypes
|
Represents method ClearDefinedTypes.
|
|
ClearFacts(IModule)
|
Clear the facts from the module
|
|
ClearFactTemplates
|
Represents method ClearFactTemplates.
|
|
ClearModules
|
Represents method ClearModules.
|
|
ClearRules
|
Represents method ClearRules.
|
|
ContainsUserFunction(TIEName)
|
Overloaded. Returns whether the inference engine contains a function with the given name
|
|
ContainsUserFunction(TIEName,IUserFunction)
|
Overloaded. Determines if a user function of the specified Name is available in the inference engine. If it is, the function returns TRUE and sets UserFunction to that function
|
|
CreateFactTemplate(TIEName)
|
Create a fact template (deftemplate in CLIPS terminology) in the expert system with the given name. The fact template is returned which can then be modified to add slots or a comment
|
|
CreateIEObject(TIEObjectType,IModule)
|
Creates the specified inference engine construct class. The module parameter specifies the owner of the inference engine construct class
|
|
DefineProperties(TFiler)
|
Represents method DefineProperties(TFiler).
|
|
DoChangeCurrentModule
|
Represents method DoChangeCurrentModule.
|
|
EndFactModify(IFact)
|
Informs the inference engine that you are finished modifying the fact and it should be re-asserted into the fact base. Use the BeginFactModify and EndFactModify methods to safely modify facts in the fact base (Facts property). BeginFactModify retracts the fact before you begin modifying it so that the Rete network will not be compromised by your modifications. EndFactModify re-asserts the fact into the fact base
|
|
EndInference
|
Represents method EndInference.
|
|
EvalFuzzyExpression(IFuzzyVariable,IIEValue,TIEContext)
|
Overloaded. Turns the Term value into a valid fuzzy set of the variable. If the term is an integer or float, the method returns a fuzzy scalar value. If the term is a string, the method tries to parse a fuzzy expression
|
|
EvalFuzzyExpression(IFuzzyVariable,IValueVector,TIEContext)
|
Overloaded. Accepts a post-fix Expression vector of terms and converts the terms into a fuzzy set
|
|
EvalFuzzyExpression(IFuzzyVariable,String)
|
Overloaded. Parses the Expression string for a valid fuzzy expression of the variable, e.g., 'very warm or [not hot]'. The method first converts the Expression into a post-fix vector of tokens and then calls the overloaded EvalFuzzyExpression method, which converts the expression into a fuzzy set
|
|
EvalFuzzyExpression(IFuzzyVariable,String,IFuzzySet)
|
Overloaded. Parses the Expression string for a valid fuzzy expression of the variable, e.g., 'very warm or [not hot]'. The method first converts the Expression into a post-fix vector of tokens and then calls the overloaded EvalFuzzyExpression method, which converts the expression into a fuzzy set. The function returns the defuzzified value of the fuzzy set
|
|
EvalFuzzyExpression(IFuzzyVariable,String,TIEContext)
|
Overloaded. Parses the Expression string for a valid fuzzy expression of the variable, e.g., 'very warm or [not hot]'. The method first converts the Expression into a post-fix vector of tokens and then calls the overloaded EvalFuzzyExpression method, which converts the expression into a fuzzy set
|
|
FindFactTemplate(TIEName)
|
Returns the fact template with the given name or nil if it the table is empty or the template doesn't exist. The function only searches the current module's fact templates
|
|
FuzzyCorrelation(IFact,Single)
|
Modifies the Fact's fuzzy slots by the strength of the activation, represented by the Correlation parameter. This method applies the fuzzy correlation based on the FuzzyCorrelationMethod property and its value: Minimum and Product. Fuzzy correlation controls how the truth level (where 0 is completely FALSE and 1 is completely TRUE) of a rule's premise (IF portion) modifies the truth of the rule's consequents, whether fuzzy sets are truncated at the truth level (creating a plateau) or multiplied by the truth level (preserving the shape of the fuzzy set but shrinking it
|
|
FuzzyInference(IFact,IFact)
|
Calculates the union of two fuzzy facts. Fact1 is modified. This method performs the union operation based on the FuzzyInferenceMethod property
|
|
FuzzyIntersection(IIEValue,IIEValue,TFuzzyOperation)
|
Creates the fuzzy intersection of Value1 and Value1 based on the Operation parameter. If the two values are not fuzzy values (or lists of fuzzy values), nothing happens
|
|
FuzzyOperation(IFact,IFact,Boolean)
|
Represents method FuzzyOperation(IFact,IFact,Boolean).
|
|
FuzzyUnion(IIEValue,IIEValue,TFuzzyOperation)
|
Creates the fuzzy union of Value1 and Value1 based on the Operation parameter. If the two values are not fuzzy values (or lists of fuzzy values), nothing happens
|
|
GenerateSymbol(TIEName)
|
Returns a unique symbol, or string, based on a concatenation of the prefix and a monotonically increasing index
|
|
GetCurrentModule
|
Returns the current module that is active
|
|
GetExpertSystem
|
Overloaded. Represents method GetExpertSystem.
|
|
GetExpertSystem(Boolean)
|
Overloaded. Represents method GetExpertSystem(Boolean).
|
|
GetFacts(Boolean)
|
Returns ALL facts in every module. If Duplicates is true, facts can appear more than once
|
|
GetUserFunction(TIEName)
|
Returns the user function with the specified name
|
|
GetUserFunctions
|
Returns an iterator for UserFunction names
|
|
IsDependent(IFunCall,IFactTemplate)
|
Overloaded. Represents method IsDependent(IFunCall,IFactTemplate).
|
|
IsDependent(IIEValue,IFactTemplate)
|
Overloaded. Represents method IsDependent(IIEValue,IFactTemplate).
|
|
IsDependent(TRule,IFactTemplate)
|
Overloaded. Represents method IsDependent(TRule,IFactTemplate).
|
|
LoadDefinedTypes(String,TEncoding)
|
Overloaded. Loads a set of defined types from a file into the CurrentModule, usually saved by SaveDefinedTypes. All current rules, fact templates, and facts that depend on the current defined types (including those shared in other modules) are deleted from the inference engine
|
|
LoadDefinedTypes(TStream,TEncoding)
|
Overloaded. Loads a set of defined types from a stream into the CurrentModule, usually saved by SaveDefinedTypes. All current rules, fact templates, and facts that depend on the current defined types (including those shared in other modules) are deleted from the inference engine
|
|
Loaded
|
Represents method Loaded.
|
|
LoadFacts(String,TEncoding)
|
Overloaded. Loads a set of facts from a file and asserts them into the expert system
|
|
LoadFacts(TStream,TEncoding)
|
Overloaded. Loads a set of facts from a stream and asserts them into the expert system
|
|
LoadFactSetsProperty(TReader)
|
Represents method LoadFactSetsProperty(TReader).
|
|
LoadFactsProperty(TReader)
|
Represents method LoadFactsProperty(TReader).
|
|
LoadFactTemplates(String,TEncoding)
|
Overloaded. Loads a set of fact templates from a file into the CurrentModule, usually saved by SaveFactTemplates. The current rules, fact templates, and facts for the module are deleted from the inference engine (i.e., the FactTemplates.Clear method is called)
|
|
LoadFactTemplates(TStream,TEncoding)
|
Overloaded. Loads a set of fact templates from a stream into the CurrentModule, usually saved by SaveFactTemplates. The current rules, fact templates, and facts for the module are deleted from the inference engine (i.e., the FactTemplates.Clear method is called)
|
|
LoadFromFile(String,TEncoding)
|
Loads an expert system file (such as CLIPS) into the inference engine, this includes modules, defined types, fact templates, rules, facts and fact sets. The expert system is parsed by the inference engine using the current parser.
|
|
LoadFromStream(TStream,TEncoding)
|
Loads an expert system from a stream (such as CLIPS) into the inference engine, this includes modules, defined types, fact templates, rules, facts and fact sets. The expert system is parsed by the inference engine using the current parser.
|
|
LoadModules(String,TEncoding)
|
Overloaded. Loads a set of modules and their import/export parameters into the inference engine from a file. The current expert system is deleted, including its modules, defined types, fact templates, facts, rules, and fact sets.
|
|
LoadModules(TStream,TEncoding)
|
Overloaded. Loads a set of modules and their import/export parameters into the inference engine from a stream. The current expert system is deleted, including its modules, defined types, fact templates, facts, rules, and fact sets.
|
|
LoadModuleTextProperty(TReader)
|
Represents method LoadModuleTextProperty(TReader).
|
|
LoadRules(String,TEncoding)
|
Overloaded. Loads a set of rules from a file, usually saved by SaveRules, into the CurrentModule. The current rules are deleted from the inference engine
|
|
LoadRules(TStream,TEncoding)
|
Overloaded. Loads a set of rules from a stream, usually saved by SaveRules, into the CurrentModule. The current rules are deleted from the inference engine
|
|
Lock
|
Requests control of the TInferenceEngine component for the current thread. The Lock method will block other threads from locking the inference engine until the current thread releases the lock with the Unlock method.
|
|
NewFactId
|
Returns a new fact id
|
|
NewParser(TStream)
|
Represents method NewParser(TStream).
|
|
NewRuleId
|
Returns a new unique rule id
|
|
NewTokenizer(String,Word)
|
Overloaded. Creates a new tokenizer for the file using the TokenizerType
|
|
NewTokenizer(TStream,TEncoding)
|
Overloaded. Represents method NewTokenizer(TStream,TEncoding).
|
|
Notification(TComponent,TOperation)
|
Represents method Notification(TComponent,TOperation).
|
|
Parse(String,Boolean,TEncoding)
|
Overloaded. Parse the input string for an expert system construct (based on the IE tokenizer, currently CLIPS)
|
|
Parse(String,TIEType,TEncoding)
|
Overloaded. parse the input string for a given value type. The string may be any valid value, from a primitive type like an integer or float to a function call
|
|
ParseConstructType(String,TEncoding)
|
Parses the string and returns the construct type detected. The function returns ptNone for an unknown type. With a CLIPS parser, this function will return ptFunCall for unrecognized keywords following a parentheses, e.g., "(SomeName)"
|
|
ParseDefinedType(String,TEncoding)
|
Parse the string for a defined type and returns the defined type. The defined type is not added to the inference engine.
|
|
ParseFact(String,TEncoding)
|
Parses the string for a fact and returns the fact. The fact is not asserted or in anyway added to the inference engine
|
|
ParseFactSet(String,TEncoding)
|
Parses the string for a fact set and returns the fact set. The fact set is not added to the inference engine
|
|
ParseFactSlot(IFact,String,TEncoding)
|
Parses the string for a fact slot, adds the slot to the fact, and returns the name of the new slot
|
|
ParseFactTemplate(String,TEncoding)
|
Parses the string for a fact template and returns the fact template. The fact template is not added to the inference engine
|
|
ParseFactTemplateSlot(String,TEncoding)
|
Parses the string for a fact template slot and returns an IFactSlot interface. The fact slot is NOT added to a fact template, call the IFactTemplate.AddSlot method to add it instead
|
|
ParseFullName(String,String,TEncoding)
|
Parses the string for a fully qualified name (e.g., in CLIPS: [MODULE::]NAME). The function returns the name as the result. The Module name is returned in the Module parameter; if no module name is detected, Module will equal an empty string
|
|
ParseFunCall(String,TEncoding)
|
Parses the string for a function call and returns the call. The function call is not executed (resolved) or added to the inference engine
|
|
ParseFunction(String,TEncoding)
|
Parses the string for a user function and returns the function. The function is not added to the inference engine
|
|
ParseFuzzyExpression(IFuzzyVariable,String,TEncoding)
|
Parses the string for a fuzzy expression (an expression that defines the shape of a fuzzy set in the Fuzzy Variable) of the Variable and returns the fuzzy set
|
|
ParseFuzzySet(IFuzzyVariable,String,TEncoding)
|
Parses the string for a fuzzy set definition and returns the fuzzy set. The new fuzzy set is added to the fuzzy variable
|
|
ParseFuzzyVariable(String,TEncoding)
|
Parses the string for a fuzzy variable definition and returns the fuzzy variable
|
|
ParseGlobalVariables(String,TEncoding)
|
Parses the string for global variables and adds them to the inference engine
|
|
ParseList(String,TEncoding)
|
Parses the string for a list of values
|
|
ParseModule(String,TEncoding)
|
Parses the string for a module and returns the module. The module is not added to the inference engine
|
|
ParseNExecuteFunCall(String,TEncoding)
|
Parses the string for a function call and executes the function call. The result of the function call is returned
|
|
ParseRule(String,TEncoding)
|
Parses the string for a rule and returns the rule. The rule is not added to the inference engine
|
|
ParseRuleActions(TRule,TIEParserVariables,String,TEncoding)
|
Parses the string for rule actions (THEN portion), adds the actions to the Rule parameter, and returns the rule
|
|
ParseRulePatterns(TRule,TIEParserVariables,String,TEncoding)
|
Parses the string for rule patterns (IF portion), adds the patterns to the Rule parameter, and returns the rule
|
|
ParseSingletons(String,TEncoding)
|
Parses the string for a singletons vector (XY value pairs that define a 2D plot, or fuzzy expression ) and returns the singletons vector
|
|
ParseValue(String,IFactSlot,TEncoding)
|
Overloaded. Parses the string for a value and returns the value. The FactSlot parameter tells the parser what type should be expected for the string
|
|
ParseValue(String,TEncoding)
|
Overloaded. Parses the string for a value and returns the value. The value is not resolved
|
|
ParseValue(String,TIETypes,IIEDefinedType,TEncoding)
|
Overloaded. Parses the string for a value and returns the value. The SlotType and OptionalTypeInfo parameters tell the parser what type should be expected for the string
|
|
ParseVariable(String,String,TEncoding)
|
Parses the string for a variable definition. The name of the variable is returned in the Name parameter, the result of the function contains the variable value. The variable is not added to the inference engine
|
|
PeekFocus
|
Returns the module at the Top of the FocusStack. This is also the CurrentFocus module - the module currently focused during inference
|
|
PlotFuzzySet(String,IIEValue,TFzyFloat,TFzyFloat,String)
|
Overloaded. Creates an ASCII-based 2D plot for the specified FuzzySet and writes it to the output stream (see IOStreams property) identified by the OutID parameter (the default OnPrintOut event stream is the empty string). The Low and High parameters specify the minimum and maximum X range for the plot. The PlotChars parameter specifies the character to use for each fuzzy set plotted, by default an *.
|
|
PlotFuzzySet(String,IValueVector,TFzyFloat,TFzyFloat,String)
|
Overloaded. Creates an ASCII-based 2D plot for the ALL of the FuzzySets and writes it to the output stream (see IOStreams property) identified by the OutID parameter (the default OnPrintOut event stream is the empty string). The Low and High parameters specify the minimum and maximum X range for the plot. The PlotChars parameter specifies the character to use for each fuzzy set plotted, by default an *.
|
|
PopFocus
|
Retrieves the module from the top of the FocusStack and makes it the currently focused module (CurrentFocus). The currently focused module is the module that is executing during Run.
|
|
PrettyPrint(IFact)
|
Overloaded. Returns a "pretty print" of a fact, it takes a fact interface to an object and returns a string representation of it based on the current TIEParser
|
|
PrettyPrint(IFact,String)
|
Overloaded. Returns a "pretty print" of a fact slot, it takes a fact interface to an object and returns a string representation of it based on the current TIEParser
|
|
PrettyPrint(IFact,String,IIEValue)
|
Overloaded. Returns a "pretty print" of a fact slot, it takes a fact interface to an object and returns a string representation of it based on the current TIEParser
|
|
PrettyPrint(IFact,String,String)
|
Overloaded. Returns a "pretty print" of a fact slot, it takes a fact interface to an object and returns a string representation of it based on the current TIEParser
|
|
PrettyPrint(IFactSlot)
|
Overloaded. Returns a "pretty print" of a fact slot, it takes a fact interface to an object and returns a string representation of it based on the current TIEParser
|
|
PrettyPrint(IFactTemplate)
|
Overloaded. Returns a "pretty print" of a fact template, it takes a fact template interface and returns a string representation of it based on the current TIEParser
|
|
PrettyPrint(IFunCall)
|
Overloaded. Returns a "pretty print" of a function call, it takes a function call interface and returns a string representation of it based on the current TIEParser
|
|
PrettyPrint(IFuzzySet,Boolean)
|
Overloaded. Returns a "pretty print" of a fuzzy set, either as a fuzzy expression or as a Type Definition, it takes a fuzzy set interface to an object and returns a string representation of it based on the current TIEParser
|
|
PrettyPrint(IFuzzyVariable)
|
Overloaded. Returns a "pretty print" of a fuzzy variable, it takes a fuzzy variable interface to an object and returns a string representation of it based on the current TIEParser
|
|
PrettyPrint(IIEDefinedType)
|
Overloaded. Returns a "pretty print" of a defined type, it takes a defined type interface to an object and returns a string representation of it based on the current TIEParser
|
|
PrettyPrint(IInterpretedFunction)
|
Overloaded. Returns a "pretty print" of an interpreted user function, it takes the user function and returns a string representation of it based on the current TIEParser
|
|
PrettyPrint(IModule)
|
Overloaded. Returns a "pretty print" of a module definition. The method accepts a module interface to an object and returns a string representation of it based on the current TIEParser. The module definition only includes the module and its imports/exports. The string does not contain construct definitions (e.g., fact templates, rules, etc).
|
|
PrettyPrint(ISingletonsVector)
|
Overloaded. Returns a "pretty print" of a singletons vector, it takes a singletons vector interface to an object and returns a string representation of it based on the current TIEParser
|
|
PrettyPrint(IUserFunction)
|
Overloaded. Returns a "pretty print" of a user function, it takes the user function and returns a string representation of it based on the current TIEParser
|
|
PrettyPrint(String,IIEValue)
|
Overloaded. Returns a "pretty print" of a variable defintion, it takes a variable name and value and returns a string representation of it based on the current TIEParser
|
|
PrettyPrint(TFactSet)
|
Overloaded. Returns a "pretty print" of a fact set, it takes a fact set object and returns a string representation of it based on the current TIEParser
|
|
PrettyPrint(TIEPattern)
|
Overloaded. Returns a "pretty print" of a pattern (a pattern is what matches a fact with a condition in a rule), it takes a pattern object and returns a string representation of it based on the current TIEParser
|
|
PrettyPrint(TRule)
|
Overloaded. Returns a "pretty print" of a rule, it takes a rule object and returns a string representation of it based on the current TIEParser
|
|
PrettyPrint(TRule,TRuleConstruct)
|
Overloaded. Returns a "pretty print" of part of a rule, either its patterns or actions (based on Constructs parameter), it takes a rule object and returns a string representation of it based on the current TIEParser
|
|
PrettyPrintGlobalVariables
|
Returns a "pretty print" of all the global variables in the inference engine, the function returns a string representation based on the current TIEParser
|
|
PrintOut(String)
|
Overloaded. Calls the OnPrintOut event handler or does nothing if no handler is assigned
|
|
PrintOut(String,String)
|
Overloaded. Prints out the Text to the IOStreams identified by OutId. If OutId equals 't' or is blank, the printout routine calls the OnPrintOut event handler or does nothing if no handler is assigned
|
|
ProcessPendingFacts
|
Processes the pending facts and adds or deletes them from the fact base, which may cause new rule activations
|
|
PushFocus(IModule)
|
Overloaded. Pushes the specified module to the top of the FocusStack. The inference engine manages a focus stack which lists the order of modules to obtain focus during execution (Run)
|
|
PushFocus(String)
|
Overloaded. Pushes the specified module to the top of the FocusStack. The inference engine manages a focus stack which lists the order of modules to obtain focus during execution (Run)
|
|
ReadLine(String)
|
Reads a string from the stream (IOStreams) identified by the InId. Then the OnReadLine event is called. If the InId is blank or equal to 't', the ReadLine function calls the OnReadLine event only
|
|
ReadToken(String)
|
Reads a token from the stream (IOStreams) identified by the InId. Then the OnReadToken event is called. If the InId is blank or equal to 't', the ReadToken function calls the OnReadToken event only
|
|
Reload(TComponent)
|
Call this method to inform the inference engine to reload a TComponent in its loaded method. This method allows objects, such as rules, to inform the inference engine to reload them later (necessary for the rule to fix itself)
|
|
RemoveActivation(Integer)
|
Overloaded. Represents method RemoveActivation(Integer).
|
|
RemoveActivation(TActivation)
|
Overloaded. Removes the rule activation from the Agenda
|
|
RemoveDefinedType(IIEDefinedType)
|
Represents method RemoveDefinedType(IIEDefinedType).
|
|
RemoveDependencies
|
Overloaded. Represents method RemoveDependencies.
|
|
RemoveDependencies(IFactTemplate)
|
Overloaded. Represents method RemoveDependencies(IFactTemplate).
|
|
RemoveDependencies(IFactTemplate,TIStringList)
|
Overloaded. Represents method RemoveDependencies(IFactTemplate,TIStringList).
|
|
RemoveDependencies(IIEDefinedType)
|
Overloaded. Represents method RemoveDependencies(IIEDefinedType).
|
|
RemoveDependencies(IModule,IFactTemplate)
|
Overloaded. Represents method RemoveDependencies(IModule,IFactTemplate).
|
|
RemoveDependencies(IModule,IIEDefinedType)
|
Overloaded. Represents method RemoveDependencies(IModule,IIEDefinedType).
|
|
RemoveFactFromModule(Integer,IFact,IModule)
|
Represents method RemoveFactFromModule(Integer,IFact,IModule).
|
|
RemoveFactTemplate(IFactTemplate)
|
Represents method RemoveFactTemplate(IFactTemplate).
|
|
RemoveFunction(IUserFunction)
|
Represents method RemoveFunction(IUserFunction).
|
|
RemoveModule(IModule)
|
Removes the specified defmodule from the expert system. The module is cleared and all of its resources are released.
|
|
RemoveRule(TRule)
|
Represents method RemoveRule(TRule).
|
|
RemoveTypeDependencies
|
Represents method RemoveTypeDependencies.
|
|
RemoveUserFunction(IUserFunction)
|
Removes a user function from the expert system. The user function will no longer be available from the rules or fact base. Be careful removing functions as even basic functions like assert and retract may be removed.
|
|
RenameDefinedType(IIEDefinedType,TIEName,TIEName)
|
Renames a defined type. This method is called when a deftype's name is changed in order to update the inference engine to match. There is no reason to call this method directly.
|
|
RenameFactTemplate(IFactTemplate,TIEName,TIEName)
|
Renames a fact template. This method is called when a deftemplate's name is changed in order to update the inference engine to match. There is no reason to call this method directly.
|
|
RenameModule(TIEName,TIEName)
|
Renames a module. This method is called when a module's name is changed in order to update the inference engine to match and ensure the new name is unique. There is no reason to call this method directly.
|
|
RenameRule(TIEName,TIEName)
|
Renames a rule. This method is called when a rule's name is changed in order to update the inference engine to match. There is no reason to call this method directly.
|
|
ReplaceDefinedType(IIEDefinedType,IIEDefinedType)
|
Represents method ReplaceDefinedType(IIEDefinedType,IIEDefinedType).
|
|
ReplaceTemplate(IFactTemplate,IFactTemplate)
|
Represents method ReplaceTemplate(IFactTemplate,IFactTemplate).
|
|
ReplaceTypesInFactTemplates(IIEDefinedType,IIEDefinedType)
|
Represents method ReplaceTypesInFactTemplates(IIEDefinedType,IIEDefinedType).
|
|
Reset
|
Overloaded. Resets the expert system. First, the agenda is cleared, all facts are deleted, and all global variables are removed. If the ResetGlobals property is true, the global variables are reset to their initial values. Any Fact sets available have their facts asserted. Finally, the initial fact is asserted to start the whole inference process over again
|
|
Reset(IModule)
|
Overloaded. Resets the specified module. The agenda is cleared, and all facts are deleted. Any Fact sets available have their facts asserted.
|
|
ResetGlobalVariable(String,IIEValue)
|
Represents method ResetGlobalVariable(String,IIEValue).
|
|
Retract(IFact)
|
Overloaded. Removes a fact that equals the specified fact from the fact base (Facts property). It also triggers a match search for any rule which looks for the "not" of a fact (such as if there is NOT this fact THEN do something). If there are no facts like the specified fact in the fact base, nothing happens
|
|
Retract(Integer)
|
Overloaded. Removes a fact that equals the specified fact id from the fact base (Facts property). It also triggers a match search for any rule which looks for the "not" of a fact (such as if there is NOT this fact THEN do something). If there are no facts like the specified fact in the fact base, nothing happens
|
|
Retract(String)
|
Overloaded. Removes a fact that equals the specified fact string from the fact base (Facts property). It also triggers a match search for any rule which looks for the "not" of a fact (such as if there is NOT this fact THEN do something). If there are no facts like the specified fact in the fact base, nothing happens
|
|
RetractFact(IFact)
|
Overloaded. Removes the fact from the CurrentModule's fact base (Facts property). It also triggers a match search for any rule which looks for the "not" of a fact (such as if there is NOT this fact THEN do something). If there are no facts like the specified fact in the fact base, nothing happens
|
|
RetractFact(Integer)
|
Overloaded. Represents method RetractFact(Integer).
|
|
RetractFacts
|
Represents method RetractFacts.
|
|
RuleChange(TRule)
|
Call the RuleChange method when the patterns of a rule have been modified. This method directs the inference engine to recreate its pattern matching for the rule in the rete network
|
|
RuleFired(TActivation)
|
Represents method RuleFired(TActivation).
|
|
Run
|
Overloaded. Executes the inference engine. The function executes until no more activations are on the agenda. The function returns the actual number of activations that occured. If there are no activations on the agenda, no rules will be fired
|
|
Run(Integer)
|
Overloaded. Executes the inference engine. MaxNumber details the maximum number of rule activations to fire before returning. The function returns the actual number of activations that occured. If there are no activations on the agenda, no rules will be fire. To step through the expert system seeing exactly what occurs, use Run( 1 ) in a loop
|
|
SaveDefinedTypes(String,TEncoding)
|
Overloaded. Saves all of the CurrentModule's defined types (DefinedTypes property) to a file
|
|
SaveDefinedTypes(TStream,TEncoding)
|
Overloaded. Saves all of the CurrentModule's defined types (DefinedTypes property) to a stream
|
|
SaveFacts(String,String,TEncoding)
|
Overloaded. Saves all the facts in the current fact base (Facts property) that use the specified fact template name to a file
|
|
SaveFacts(String,TEncoding)
|
Overloaded. Saves the CurrentModule's fact base (Facts property) to a file
|
|
SaveFacts(TStream,String,TEncoding)
|
Overloaded. Saves all the facts in the current fact base (Facts property) that use the specified fact template name to a stream
|
|
SaveFacts(TStream,TEncoding)
|
Overloaded. Saves the CurrentModule's fact base (Facts property) to a stream
|
|
SaveFactTemplates(String,TEncoding)
|
Overloaded. Saves all of the CurrentModule's fact templates (FactTemplates property) to a file
|
|
SaveFactTemplates(TStream,TEncoding)
|
Overloaded. Saves all of the CurrentModule's fact templates (FactTemplates property) to a stream
|
|
SaveModules(String,TEncoding)
|
Overloaded. Saves the modules of the expert system to a file. The method saves the module definitions, which include the module name, comment, and imports/exports. The constructs (defined types, fact templates, etc) are not saved.
|
|
SaveModules(TStream,TEncoding)
|
Overloaded. Saves the modules of the expert system to a stream. The method saves the module definitions, which include the module name, comment, and imports/exports. The constructs (defined types, fact templates, etc) are not saved.
|
|
SaveRules(String,TEncoding)
|
Overloaded. Saves the CurrentModule's rule base (Rules property) to a file.
|
|
SaveRules(TStream,TEncoding)
|
Overloaded. Saves the CurrentModule's rule base (Rules property) to a stream.
|
|
SaveToFile(String,TEncoding)
|
Overloaded. Saves the current expert system to a file in a text format. The text is saved in a parsable format (such as CLIPS). The method saves the inference engine's modules, defined types, fact templates, rules, facts and fact sets
|
|
SaveToStream(TStream,TEncoding)
|
Overloaded. Saves the current expert system to a stream in a text format. The text is saved in a parsable format (such as CLIPS). The method saves the inference engine's modules, defined types, fact templates, rules, facts and fact sets
|
|
SearchSalience(Integer)
|
Represents method SearchSalience(Integer).
|
|
SetActivation(Integer,TActivation)
|
Represents method SetActivation(Integer,TActivation).
|
|
SetExpertSystem(String)
|
Represents method SetExpertSystem(String).
|
|
SetStrategy(TSearchStrategy)
|
Represents method SetStrategy(TSearchStrategy).
|
|
SetUpdatingHT(Boolean)
|
Represents method SetUpdatingHT(Boolean).
|
|
SetUserFunction(TIEName,IUserFunction)
|
Associates the user function with the specified name
|
|
StartCapture(TFilename,TEncoding)
|
Overloaded. Starts capturing your expert system's output to the specified file. This method commands the inference engine to redirect any calls to standard output within the expert system (TPrintOutFunction user function and PrintOut method) to the file specified by filename. The contents of the file if it exists will be overwritten. All calls to the PrintOut method will go to the file until the StopCapture method is called
|
|
StartCapture(TStream,TEncoding)
|
Overloaded. Starts capturing your expert system's output to the specified stream. This method commands the inference engine to redirect any calls to standard output within the expert system (TPrintOutFunction user function and PrintOut method) to the stream. All calls to the PrintOut method will go to the stream until the StopCapture method is called
|
|
StopCapture
|
Stops the capturing of the inference engine's standard output started by the StartCapture method
|
|
StoreFactSetsProperty(TWriter)
|
Represents method StoreFactSetsProperty(TWriter).
|
|
StoreFactsProperty(TWriter)
|
Represents method StoreFactsProperty(TWriter).
|
|
StoreModuleTextProperty(TWriter)
|
Represents method StoreModuleTextProperty(TWriter).
|
|
Unlock
|
Releases a thread's lock on the TInferenceEngine component allowing other threads to complete their Lock method. You must unlock the TInferenceEngine to allow other threads to not be blocked by Lock method calls.
|
|
UpdateDependencies(TIStringList)
|
Represents method UpdateDependencies(TIStringList).
|
|
UpdateDependentFact(IFact,IFact)
|
Represents method UpdateDependentFact(IFact,IFact).
|
