IBM Agent Building Environment Developer's Toolkit


Index

A B C D E F G H I J K L M N O P Q R S T U V W
A
  • access to library objects, addressing concurrency (455)
  • adapter
  • application (642)
  • application, example of (644)
  • binding a variable (687)
  • categories (638)
  • concepts (151)
  • configuration rules (809)
  • configuring (347), (369)
  • control of binding (688)
  • core, description of (637)
  • critical event information (654)
  • designing an (647)
  • domain (627), (700), (713)
  • domain change (701)
  • E-mail, example of (649)
  • effector calls (633), (742)
  • effectors, explained (715)
  • effectors, reply (712)
  • EventType (157)
  • execution considerations, in C++ (777)
  • execution considerations, in Java (781)
  • flow of rules (752)
  • implementing in AIX (756)
  • implementing in C++ (754)
  • implementing in Java (757)
  • inheriting from IAAdapter Class (759)
  • initialization at setup (233)
  • initialization, new object (202)
  • java, configuring in (346), (368)
  • new adapter function in C++ (206)
  • new adapter function in Java (207), (208)
  • new object
  • understanding (203)
  • writing methods for (204)
  • NNTP (645)
  • notify engine (628)
  • provided with toolkit (354)
  • register sensors (660), (716)
  • registration, initialization (210)
  • sample (361)
  • sample rules (807)
  • selector information (735)
  • selector, event (158)
  • sensor calls (634), (741)
  • start up steps (784)
  • summary of flow, stock monitor (274), (283)
  • time, example of core (247), (639)
  • trigger event (629)
  • using stock (186)
  • writing (53), (626)
  • rules (747)
  • tutorial (54)
  • your own (355)
  • agenda, rules (316)
  • agent
  • configuring (582), (586)
  • in C++ (576)
  • initialization (276)
  • starting (255), (291), (583), (588)
  • stopping (584), (590)
  • to application (575), (581)
  • agent programs, writing (341)
  • alarms, time adapter (797)
  • answer query (228), (696), (763)
  • antecedent-expression of a rule (86)
  • antecedent, formulation of (117)
  • application adapters (643)
  • application, adding agent to (573)
  • architecture overview (58)
  • atoms
  • bound terms (Facts) (120)
  • constant term (99)
  • explination of (90)
  • groups of, into expressions (113)
  • logical (91)
  • negations for (332)
  • nesting of (114)
  • reordering consequent for sensor bindings (320)
  • signatures in (330)
  • term list (94)
  • variable term (100)
  • avoiding cyclic rules (324)
  • B
  • binding free (unbound) variables, fact pool (145)
  • boolean sensors
  • definition (171), (661)
  • example (229)
  • invoke (220)
  • sensors, examples (175), (666)
  • sensors, test condition routine (288)
  • with test condition (694)
  • C
  • C++
  • adapter execution considerations (778)
  • adding an agent in (577)
  • E-mail adapter (189)
  • header file (774)
  • implementing an adapter in (755)
  • stock adapter (280)
  • chaining rules for reduction (336)
  • characters, escape (106)
  • clean slate function (538)
  • clear before write, log records (536)
  • client inferencing, description of (436)
  • collectors (431), (495)
  • complete rule, example of (116)
  • concurrent write operations (460)
  • conduct set, description of (407), (426)
  • conduct set, load, raise engine (598)
  • conduct set, loading and unloading (788)
  • configuration file (372)
  • configuration file statements (376)
  • configuring adapters
  • AGENT:CONFIG event (238)
  • AGENT:STARTING event (239)
  • DLL name, writing agent programs (358)
  • domain name, writing agent programs (357)
  • file statements (378)
  • passing parameters for (237)
  • provided with toolkit (356)
  • written in java (344), (366)
  • configuring agent (585)
  • configuring agents
  • establishing and changing (375)
  • file name (374)
  • file statements (379)
  • consequent atoms, reordering (319)
  • consequent-expression of a rule (87)
  • consequent, formulation of (118)
  • constant term (95)
  • ContentsElements (432), (496)
  • (513)
  • (511)
  • (512)
  • long term facts
  • metadata
  • rules
  • critical event, information (655)
  • cyclic rules, avoiding (325)
  • D
  • DBCS support, library (492)
  • deleting long term facts (524)
  • deleting rules (523)
  • derived facts (132)
  • derived facts, raise engine (624)
  • designing adapters, getting started (191)
  • designing an adapter (648)
  • DLL, writing agent programs (360)
  • domain name, writing agent programs (359)
  • E
  • effectors
  • action request, by engine (270)
  • action with adapters (181), (707)
  • adapter domain, functions of (710), (714)
  • arguments (718)
  • calls (635)
  • description of (699), (703)
  • implementing (804)
  • metadata association (728)
  • name (724), (726)
  • perform action routine (290)
  • perform action with adapters (706)
  • register (285), (717), (792)
  • registration (162), (213)
  • reply (711)
  • segnature (720)
  • selector handling (740)
  • stock adapter (275)
  • with adapters (631)
  • with e-mail (708)
  • engine
  • action request (271)
  • converters (421)
  • derived facts (621)
  • Log Example (614)
  • Log Output (608)
  • long term facts (619)
  • notification (652)
  • notify of event (798)
  • raise, description (594)
  • raise, load conduct set (596)
  • relates to rules (750)
  • Rule Set (612)
  • sensor, use with (683)
  • short term facts (620)
  • supplemental information request (264)
  • trigger event (602), (605)
  • escape characters (107)
  • event See trigger events
  • example of complete rule (115)
  • execution considerations, in C++ (779)
  • execution considerations, in Java (783)
  • execution steps
  • dynamic conduct set, loading (786)
  • dynamic conduct set, unloading (787)
  • shutdown (789)
  • start up (785)
  • expression of a rule, antecedent (88)
  • expression of a rule, consequent (89)
  • expressions, groups of atoms (110)
  • F
  • fact pool (137), (154), (261)
  • derived facts (141)
  • explination of (138)
  • free (unbound) variables (148)
  • long term facts (139)
  • sensor signature (321)
  • short term facts (140)
  • validation of rules (142), (144)
  • factoring rules for reduction (335)
  • facts
  • Facts (119)
  • derived, examples of (133)
  • long term
  • example of (124)
  • explination of (122), (123)
  • persistent storage of (125)
  • relate to atoms (121)
  • set (262), (656)
  • short term (155)
  • example of (131)
  • explination of (128)
  • multiple (fact set) (130)
  • storage of (129)
  • storing (79)
  • writing (78)
  • file, configuration (373)
  • G
  • generate notify event (302)
  • generic rule editor (545), (549), (560) See also rule editor
  • H
  • header file (775)
  • header information, trigger event (803)
  • I
  • IAAdapter functions
  • answer query (762)
  • event complete (764)
  • identify (765)
  • member functions (776)
  • perform action (766)
  • quiesce (767)
  • reset (768)
  • restart (769)
  • shutdown (770)
  • start (771)
  • stop (772)
  • test condition (773)
  • IAAdapter, member functions (760)
  • IAFactSet, objects (800)
  • implementation, file (457)
  • inference engine (599)
  • inferencing episode (136)
  • inferencing set, description of (408)
  • inferencing with client (435)
  • initialization
  • adapter registration (209)
  • adapter setup (235)
  • directory (565)
  • library (564)
  • new adapter object (200)
  • start up (251), (253)
  • timing intervals (241)
  • integer, constant type (108)
  • intervals, timing at initialization (243)
  • J
  • Java code
  • adapter execution considerations (782)
  • class, to represent Java adapter (351)
  • classes needed by interface adapter (353)
  • configuring adapters in (345), (367)
  • for stock adapter (298)
  • implementing an adapter in (758)
  • interface adapter (350)
  • monitor stock adapter (301)
  • sample StockAdapter (188), (349), (371)
  • stock adapter (279)
  • writing your own program (352)
  • java interface (348), (370)
  • Java interface
  • K
  • KIF (Knowledge Interchange Format) (69)
  • description of (73)
  • linear, conversion (420)
  • syntax (74)
  • use in writing rules (310)
  • with RuleSets (419)
  • L
  • library
  • access to objects, addressing concurrency (454)
  • atomicity controls (464)
  • build (488)
  • concurrent write operations (458)
  • create a directory (561)
  • create and store long term facts (500)
  • create and store rules (499)
  • DBCS support (491)
  • deleting long term facts (518)
  • deleting rules (517)
  • file implementation (456)
  • framework (487)
  • linking with the generic rule editor (490)
  • LogRecordSets (525)
  • long term facts, storing (424)
  • LTFactSets, relation to RuleSets (429)
  • metadata, storing (510)
  • new (not initialized) (562)
  • new rules (557)
  • object classes
  • Collector (384)
  • Colletor (433), (497)
  • Colletor, description of (437)
  • ContentsElement (385), (434), (498)
  • LogRecordSet (388), (478)
  • LogRecordSet, buffers (479)
  • LogRecordSet, levels of logging (482)
  • LogRecordSet, maximum size (480)
  • LogRecordSet, uni-directional (481)
  • LTFactSet (387)
  • RuleSet (386)
  • object lock with get/put (466)
  • object lock, implicit (467)
  • objects (383)
  • persistent storage, object types (485), (486)
  • platform independence (394)
  • repository independence (393)
  • retrieving
  • long term facts (504)
  • rules (503)
  • rule editor (543)
  • rule editor, running (547)
  • rule editor, syntax (553)
  • rule naming (566)
  • RuleSet metadata (571)
  • RuleSets, relation to LTFactSets (430)
  • sequential write operations (459)
  • services (395)
  • short term facts, storing (425)
  • start up (489)
  • storing information (509)
  • user interface (493)
  • using (381)
  • version management (468), (471)
  • versioning (465)
  • applies to objects (473)
  • Colletors (474)
  • LogRecordSets (477)
  • LTFactSets (476)
  • management (469), (472)
  • RuleSets (475)
  • wrapper classes (391)
  • write concurrency for logs (484)
  • load conduct set, raise engine (343), (597)
  • Log Example (615)
  • Log Output (610)
  • log records
  • clean slate (537)
  • clear before write (535)
  • explicit Open/Close (533)
  • implicit Open/Close (534)
  • metadata (529), (530)
  • read/write separation (539)
  • using (528)
  • LTFacts
  • create and store (502)
  • deleting (522)
  • raise engine (622)
  • relation to RuleSets (428)
  • retrieving and using (508)
  • storing (423)
  • using and retrieving (507)
  • LTFactSets
  • storing (422)
  • M
  • maintenance, RuleSets (411)
  • metadata
  • base object association (442)
  • base object name (443)
  • Collector (447)
  • log record markup (483)
  • log records (531)
  • LRSet (532)
  • LTFact (451)
  • LTFactSet (450)
  • names (452), (570)
  • retrieved object (441)
  • retrieving (514)
  • Rule (449)
  • RuleSet (448), (569)
  • stored object (440)
  • storing (515)
  • use by converters with KIF (446)
  • user-defined (438)
  • with effectors (729)
  • with RuleSet (680), (730)
  • with sensors (679)
  • miscellaneous classes, stock adapter (305)
  • N
  • name when created, RuleSet (413)
  • name, predicate (671)
  • name, sensor (672)
  • refid rules.authoring (682)
  • refid rules.editing (681)
  • name, variable (147)
  • names, metadata (453)
  • naming, rule (568)
  • negations for atoms (331)
  • new adapter object, initialization (201)
  • new library (563)
  • non-boolean sensors
  • definition (172), (662)
  • example (230)
  • invoke (221)
  • sensors, answer query (289)
  • sensors, examples (176), (667)
  • with answer query (695)
  • normalization, rules (317)
  • notification to engine, trigger events (258)
  • notify engine (653)
  • notify engine of event (799)
  • O
  • object classes, library (389)
  • options, sample agent program (365)
  • overview, architecture (59)
  • P
  • parameters, register
  • IAError (226)
  • procedure-name (216)
  • signature (222)
  • token (224)
  • type (218)
  • parts of a rule (83)
  • parts, toolkit (60)
  • perform action (293)
  • perform action with adapters (705)
  • persistent storage
  • base object (445)
  • long term facts (127)
  • parts of objects in (444)
  • rules (126), (401)
  • RuleSets (402)
  • plug-and-play (67)
  • predicate
  • explination of (92)
  • name (678), (733)
  • names (673)
  • part of fact pool (156)
  • signature (102), (677), (731), (734)
  • with effectors (732)
  • prefix, IALib (392)
  • programs, writing agent (342)
  • Q
  • quotes (104)
  • R
  • raise engine
  • derived facts (618)
  • description (593)
  • forward-chaining (592)
  • load conduct set (595)
  • Log Example (613)
  • Log Output (607)
  • long term facts (616)
  • Rule Set (611)
  • short term facts (617)
  • trigger event (601), (604)
  • read/write separation (540)
  • real, constant type (109)
  • register effectors (794)
  • invoking identify (212)
  • parameters (215), (234)
  • register parameters
  • IAError (227)
  • procedure-name (217)
  • signature (223)
  • token (225)
  • type (219)
  • register sensors (670), (793)
  • invoking identify (211)
  • parameters (214)
  • registration of effectors (161)
  • registration of sensors (160)
  • reordering consequent atoms for sensor bindings (318)
  • request by engine, effectors (269)
  • restrictions of sensors (698)
  • retrieval, rules (403)
  • retrieval, RuleSets (404)
  • rule editor
  • creating (187)
  • explination of (82)
  • features (544)
  • Java environment (551)
  • midify existing rules (558)
  • new rules (559)
  • rule naming (567)
  • running (548)
  • syntax (554)
  • rules
  • agenda (315)
  • avoiding cyclic (327)
  • chaining for rule reduction (334)
  • configuration (808)
  • create and store (501)
  • deleting (521)
  • editing (541)
  • editor, running (546)
  • editor, syntax (552)
  • fact pool (135)
  • factoring for rule reduction (333)
  • firing (143)
  • flow of (753)
  • groups of atoms (112)
  • inference, storage (405)
  • inferencing episode (134)
  • initialization (248)
  • internal reformulation (agenda) (313), (326)
  • loaded from storage (406)
  • modify existing (556)
  • new (555)
  • normalization (314)
  • part, antecedent-expression (84)
  • part, consequent-expression (85)
  • persistent storage (397)
  • reformulation by engine (309)
  • relate to adapters (150)
  • retrieval (398)
  • retrieving and using (505)
  • RuleSets (396)
  • sample adapter, writing (749)
  • sample, with adapter (806)
  • stock adapter, writing (192)
  • storing (72), (77)
  • understanding, inferencing (80)
  • using and retrieving (506)
  • with time dependencies (337)
  • writing (75), (751)
  • a tutorial (52)
  • more on (307)
  • using KIF (76)
  • using rule editor (542)
  • using your own adapter (748)
  • RuleSets
  • active state (414)
  • dynamic switching (410)
  • inactive state (415)
  • maintenance (409)
  • name when created (412)
  • persistent storage (399)
  • relation to LTFactSets (427)
  • retrieval (400)
  • rule objects (416)
  • standard metadata (417), (418)
  • S
  • sample adapter, stock (183)
  • sample agent program
  • background thread (578)
  • option (579)
  • options, start up (364)
  • using (362)
  • with iaagent (363)
  • selector handling
  • adapter (737)
  • by the engine (600)
  • conduct set association (380)
  • notify call (746)
  • on a sensor call (744)
  • on an effector call (745)
  • with time adapter (743)
  • sensors
  • action with adapters (182)
  • adapters, use with (632)
  • arguments (719)
  • boolean, example of (267), (295)
  • boolean, examples (174), (665)
  • boolean, test condition routine (286)
  • boolean, with test condition (693)
  • bound before invoking (686)
  • bound through invoking (689)
  • calls (636)
  • critical event, use with (657)
  • definition of boolean (659)
  • definition of non-boolean (658)
  • dependencies, use with (323)
  • e-mail examples (663)
  • engine, use with (684)
  • implementing (805)
  • initialization (165)
  • mapping predicate names of atoms (675)
  • metadata association (676)
  • names (669), (780)
  • non-boolean, answer query (692)
  • non-boolean, answer query routine (287)
  • non-boolean, example of (231)
  • non-boolean, examples (173), (664)
  • register (284), (668), (791)
  • registration, boolean (163)
  • registration, non-boolean (164)
  • restrictions (697)
  • selector handling (739)
  • signature (322), (685), (721)
  • stock adapter (266)
  • supplemental information request, by engine (263)
  • with rules (674)
  • sequential write operations (461)
  • short term facts, raise engine (623)
  • shutdown execution steps (790)
  • signatures in an atom (329), (722)
  • signatures, predicate (103), (723)
  • start up, initialization (252)
  • statements, configuration (377)
  • stock adapter (184)
  • annotated java code (277)
  • antecedent, stock compare (265)
  • generates trigger event (259)
  • initialization (245)
  • initialization at setup (240)
  • initialization at start up (254)
  • interactivity between Java and C++ (246)
  • Java code (299)
  • main parts of (278)
  • miscellaneous classes (306)
  • monitor stock prices (272), (281)
  • monitor thread, Java code (300)
  • rules, use with (198), (199)
  • stock monitor routine (260)
  • thoughts on writing (194)
  • time adapter, use with (196), (197)
  • timing intervals at initialization (244)
  • URL required (195)
  • using (185)
  • storing
  • facts (71)
  • metadata (516)
  • rules (70)
  • strings character (105)
  • subexpressions, groups of atoms (111)
  • summary of flow, stock monitor (273), (282)
  • symbols (101)
  • T
  • term
  • binding (691)
  • bound (166)
  • bound in list (704)
  • constant (97), (169), (297)
  • list (93)
  • name (725), (727)
  • truth validation (690)
  • unbound (167), (168)
  • variable (98), (170), (180)
  • test condition, boolean senor (268)
  • test condition, boolean sensors (296)
  • Thumb-nail Architecture (57)
  • time adapter, example of core (249), (640)
  • time dependencies, rules (338)
  • timing intervals at initialization (242)
  • toolkit architecture (68)
  • trigger events
  • adapter (630)
  • agent starting (236), (250), (294)
  • as critical event (651)
  • building (159)
  • complete (292)
  • creation (801)
  • domain change (702)
  • event complete (761)
  • explanation of (153)
  • fact set (303)
  • generating (152)
  • header information (149), (736), (802)
  • notification to engine (232), (256), (257), (304)
  • raise engine (603), (606), (609)
  • tutorial for writing adapters (56)
  • tutorial for writing rules (55)
  • types of sensors, boolean (177), (178)
  • types of sensors, non-boolean (179)
  • U
  • understanding rule inferencing (81)
  • use of variables in a consequent (328)
  • user interface, library (494)
  • user-defined metadata (439)
  • using library (382)
  • V
  • variable name (146)
  • variable term (96)
  • version management, library (470)
  • W
  • wrapper classes, library (390)
  • write operations, concurrent (463)
  • write operations, sequential (462)
  • writing adapters
  • getting started (190)
  • KIF syntax (311)
  • methods for object class (205)
  • stock, thoughts on writing (193)
  • writing agent programs (340)
  • writing rules, more on (308)

  • [ Top of Page | Previous Page | Table of Contents | Index ]