CLIPS C Language Integrated Production System

CLIPS C Language Integrated Production System

Introduzione CLIPS: C Language Integrated Production System CLIPS è un tool per lo sviluppo di Sistemi Basati su Conoscenza le cui origini risalgono al 1984 (NASAs Johnson Space Center). Implementato in linguaggio C per eliminare i problemi legati alluso del linguaggio LISP. Linguaggio a regole basato sullalgoritmo Rete con il meccanismo di attivazione delle regole di tipo Forward Chaining La versione 5.0 (1991) introduce due nuovi paradigmi di programmazione: programmazione procedurale e programmazione orientata agli oggetti (CLIPS Object- Oriented Language (COOL))

Riferimenti - CLIPS Reference Manual: Volume I - The Basic Programming Guide Volume II - The Advanced Programming Guide Volume III The Interfaces Guide - CLIPS Users Guide http://www.ghg.net/clips/clips.html http://www.ghg.net/clips/download/documentation/ CLIPS is released as public domain software and as such you are under no obligation to pay for its use. However, if you derive commercial or monetary benefit from use of the software or just want to show support, please consider making a voluntary payment based on the worth of the software to you as compensation for the time and effort required to develop and maintain CLIPS. Payments can be made online at http://order.kagi.com/?jkt.

Esecuzione 1. utilizzando una interfaccia testuale a linea di comando;

2. utilizzando una interfaccia a finestre; 3. come sistema esperto embedded. Esecuzione

I primi comandi I comandi CLIPS sono sempre racchiusi fra parentesi Alcuni comandi importanti (exit) abbandona CLIPS (clear) rimuove tutte le regole e i fatti dalla memoria (reset) rimuove i fatti ma non le regole dalla memoria (run) avvia l'esecuzione di un programma CLIPS

Alla base CLIPS opera mantenendo una lista di fatti ed un insieme di regole che operano sui fatti. Un fatto rappresenta informazione (colore verde) o (genitore Giovanni Maria) I fatti vengono creati asserendoli nel database dei fatti utilizzando il comando assert: CLIPS>(assert (colore verde)) <Fact-0> Intro CLIPS: Fatti e regole <Fact-0>: risposta del CLIPS per dire che è stato inserito un nuovo fatto (numero 0) nel database dei fatti. CLIPS>(facts) f-0 (colore verde) For a total of 1 fact

Intro CLIPS: Fatti e regole I fatti possono anche essere rimossi dal database dei fatti utilizzando il comando retract: CLIPS>(assert (colore verde)) <Fact-0> CLIPS>(assert (colore rosso)) <Fact-1> Ritrattiamo il primo fatto e visualizziamo la lista dei fatti: CLIPS>(retract 0) CLIPS>(facts) f-1 (colour red) For a total of 1 fact. Per ritrattare un fatto bisogna specificare un numero (factindex). I fact-indice non vengono riusati. Una volta ritrattato il fatto 0, il prossimo fatto asserito avrà indice 2 e non 0

I soli fatto hanno un uso limitato. E' necessaria l'applicazione di regole per lo sviluppo di un programma in grado di effettuare funzioni utili. In generale, una regola è espressa nella forma SE qualcosa è vera ALLORA esegui qualche azione. Questo tipo di regola è detta produzione. Tipica regola CLIPS: Intro CLIPS: Fatti e regole (defrule morde (animale cane) => (assert (animale morde))) se c'è un fatto (animale cane) nel db dei fatti, allora asserisci un altro fatto (animale morde), nel db dei fatti

Una regola consiste di tre parti (defrule morde dà alla regola un nome unico (animale cane) è il pattern (la parte IF ) della regola (assert (animale morde)) è l'azione (la parte THEN) ESEMPIO Intro CLIPS: Fatti e regole CLIPS> (clear) CLIPS> (defrule morde (animale cane) => (assert (animale morde))) CLIPS> (rules) CLIPS> (assert (animale cane)) CLIPS> (facts) CLIPS> (run) CLIPS> (facts)

Inseriamo questa nuova regola Intro CLIPS: Fatti e regole (defrule cane (animale-ha coda) (animale-ha quattro-zampe) => (assert (animale cane))) CLIPS> (reset) Ora asseriamo i seguenti fatti (animale-ha coda) e (animale-ha quattro-zampe) CLIPS> (facts) 2 fatti CLIPS> (run) CLIPS> (facts) 4 fatti!!! Regole e fatti possono essere scritti in un file di testo con estensione clp e poi caricati in CLIPS.

Intro CLIPS: Fatti e regole Il costrutto deffacts ci permette di asserire più fatti nel db ogni volta che si resetta il sistema. (deffacts startup (maschio gianni) (femmina lucia) (maschio luca) (femmina maria) (genitore gianni lucia) (genitore maria lucia)) I wildcard (defrule figlio-gianni (genitore gianni?) => (printout t "trovato un figlio di Gianni" crlf)) CLIPS>(run) trovato un figlio di Gianni CLIPS>

Le variabili nei pattern Intro CLIPS: Fatti e regole (defrule maschi (maschio?m) => (printout t "trovato un maschio"?m crlf)) CLIPS>(run) trovato un maschio gianni trovato un maschio luca CLIPS> (defrule madre (femmina?f) (genitore?f?x) => (printout t "trovata madre"?m di?x crlf))

L'astrazione dati La rappresentazione dellinformazione in CLIPS avviene per mezzo di fatti, oggetti e variabili globali Fatti I fatti sono uno strumento di base, di alto livello, per la rappresentazione dellinformazione in CLIPS. Ogni fatto rappresenta una porzione di informazione memorizzata nel db dei fatti (lista dei fatti fact-list). I fatti rappresentano lunità fondamentale di dati utilizzata dalle regole. I fatti possono essere aggiunti alla fact-list (utilizzando il comando assert), rimossi dalla fact-list (utilizzando il comando retract), modificati (utilizzando il comando modify), o duplicati (utilizzando il comando duplicate).

Elementi di base Il CLIPS fornisce tre elementi di base per scrivere programmi: - tipi di dati primitivi, - funzioni per la manipolazione dei dati, e - costrutti per laggiunta di conoscenza. Tipi di dati per la rappresentazione di valori numerici integer: 237, 15, +12, -32 float: 237e3, 15.09, +12.0, -32.3e-7 <integer> ::= [+ -] <digit>+ <digit> ::= 0 1 2 3 4 5 6 7 8 9 <float> ::= <integer> <exponent> <integer>. [exponent]. <unsigned integer> [exponent] <integer>. <unsigned integer> [exponent] <unsigned-integer> ::= <digit>+ <exponent> ::= e E <integer>

Elementi di base Tipi di dati per la rappresentazione di valori simbolici Symbol: sequenza di caratteri che partono con un carattere ASCII stampabile, seguito da zero o più caratteri ASCII stampabili. Non può iniziare con i caratteri? e $? poiché sono riservati alle variabili symbol: foo, Hello, B76-HI, bad_value, 127A, 456-93-039, @+=-%, 2each String: insieme di caratteri che iniziano con il simbolo " seguiti da caratteri ASCII stampabili e che terminano con il simbolo " string: " foo", "a and b", "1 number", "a\"quote

Elementi di base external-address: gli indirizzi delle strutture dati esterne restituiti da una funzione integrata con il CLIPS fact-adresses: un fatto è una lista di valori atomici ai quali si può fare riferimento per posizione (ordered facts) o per nome (non-ordered o template facts). Ad un fatto si fa riferimento con un indice o con un indirizzo instance-name, instance-address: una istanza è un oggetto, istanziazione di una specifica classe alla quale si può far riferimento con il suo nome Oggetti CLIPS: float, integers, symbol, string, multifield, external-adresses, fact-adresses o instances di una classe user-defined.

Un instance-name è un simbolo racchiuso tra parentesi quadre [pump-1] [foo] [+++] [123-890] Elementi di base In CLIPS un segnaposto con un valore è detto field. Un multifield value è una sequenza di zero o più single field values racchiusi tra parentesi tonde (a) (1 bar foo) () (x 3.0 "red" 567) Costante: singolo field con valore fisso Variabile: locazione simbolica utilizzata per immagazzinare valori Commenti: preceduti dal simbolo ;

Una funzione in CLIPS è una porzione di codice eseguibile identificata da uno specifico nome che restituisce un valore o ha un effetto collaterale. Il costrutto deffunction permette allutente di definire nuove funzioni, direttamente nellambiente CLIPS. Questo tipo di funzioni agiscono come le altre (user defined functions e system define functions), però, invece di essere eseguite direttamente (come accade per il codice scritto in un linguaggio esterno) vengono interpretate dallambiente CLIPS. Le funzioni generiche possono essere definite utilizzando i costrutti defgeneric e defmethod. Questo tipo di funzioni permettono lesecuzione di diverse porzioni di codice in base agli argomenti passati alla funzione. Quindi, un singolo nome di funzione può essere sovraccaricato con più porzioni di codice. Clips utilizza la notazione prefissa per le funzioni (* 8 (+ 3 (* 2 3 4) 9) (* 3 4)) Elementi di base

Il CLIPS fornisce molti costrutti: defmodule, defrule, deffacts, deftemplate, defglobal, deffunction, defclass, definstances, defmessage-handler, defgeneric, e defmethod. Elementi di base

I fatti Per poter utilizzare i comandi retract, modify, e duplicate è necessario specificare un fatto per mezzo del suo fact-index o fact-address. Ad ogni fatto aggiunto (o modificato) viene associato un indice intero (unico) detto fact-index i fact-index partono da zero e sono incrementati di uno per ogni nuovo fatto cambiato Leffetto dei comandi reset o clear è di porre a zero i fact-index Un fatto può anche essere specificato per mezzo del suo factaddress, ottenuto catturando il valore restituito dai comandi che restituiscono un fact-address (assert, modify, e duplicate) o mappando una variabile al fact-address di un fatto in un pattern nella LHS di una regola La memorizzazione dei fatti può avvenire in modo ordinato e in modo non-ordinato

Fatti ordinati I fatti ordinati sono costituiti da un simbolo seguito da una sequenza di zero o più campi separati da spazi e delimitati da una parentesi aperta a sinistra e da una parentesi chiusa a destra. Il primo campo di un fatto ordinato specifica una relazione che è applicata ai restanti campi del fatto. Per esempio, (padre giovanni mario) dice che giovanni è il padre mario. (forno acceso) (altezza 100 m) (elenco-spesa zucchero miele zucchine pomodori)

I fatti ordinati rappresentano informazione ordinata. Per poter accedere a questo tipo di informazione bisogna conoscere i campi che la contengono. I fatti non ordinati (o template) forniscono la possibilità di astrarre dalla struttura del fatto assegnando dei nomi ad ogni campo nel fatto. Il costrutto deftemplate (analogo alla definizione di record o di struttura in C) viene utilizzato per creare un template che poi può essere utilizzato per accedere ai campi per nome. Un template è definito da zero o più definizioni di slots. (cliente (nome "Paolo Rossi") (id X9345A)) (punto-di-massa (x-velocita 100) (y-velocita -200)) Fatti non ordinati (corso (docente "Bianchi") (#-studenti 30) (aula "37A")) (corso (#-studenti 30) (docente "Bianchi") (aula "37A"))

Gli oggetti Un oggetto in CLIPS è un simbolo, una stringa, un numero floating-point o intero, un multifield value, un external-address o una istanza di una classe user-defined. Gli oggetti sono descritti da una proprietà e da un comportamento. Una classe è un template di proprietà e comportamenti comuni ad oggetti che sono istanze della classe. Rolls-Royce della classe SYMBOL "Rolls-Royce" della classe STRING 8.0 della classe FLOAT 8 della classe INTEGER (8.0 Rolls-Royce 8 [Rolls-Royce]) della classe MULTIFIELD <Pointer- 00CF61AB> della classe EXTERNAL-ADDRESS [Rolls-Royce] della classe CAR (a user-defined class)

Variabili globali Il costrutto defglobal permette la definizione di variabili globali. È possibile accedere da qualsiasi parte a queste variabili. Alcuni costrutti (come defrule e deffunction) permettono lallocazione di variabili locali alle quali si può accedere dallinterno del costrutto, ma che non hanno significato alcuno al di fuori del costrutto. Una variabile globale in CLIPS è simile alle variabili globali dei linguaggi procedurali, ma ha tipizzazione debole (non necessariamente deve contenere un valore di un solo tipo)

Rappresentazione della conoscenza Per rappresentare la conoscenza CLIPS fornisce un paradigma euristico ed un paradigma procedurale. Conoscenza Euristica: le regole Un metodo per rappresentare la conoscenza in CLIPS è attraverso la regola. Le regole sono utilizzate per rappresentare euristiche che specificano un insieme di azioni da effettuare in una data situazione. Una regola è costituita da un antecedente (left-hand-side, LHS) e da un conseguente (right-hand-side, RHS)

Le regole Lantecedente di una regola è un insieme di condizioni (conditional elements) che devono essere vere affinché la regola sia applicabile. In CLIPS, la soddisfacibilità delle condizioni di una regola è basata sullesistenza o meno di specifici fatti nella fact-list o di specifiche istanze di classi nella instance-list. Un tipo di condizione che può essere specificata è il pattern. I pattern sono costituiti da un insieme di restrizioni utilizzate per determinare quali fatti o oggetti soddisfano le condizioni nel pattern. Il processo di matching fra fatti/oggetti e il pattern è detto pattern-matching. Il CLIPS fornisce un motore inferenziale che automaticamente mappa i pattern sulla fact-list e/o sulla instance-list corrente, determinando quali regole sono applicabili

Le regole Il conseguente di una regola è costituito da un insieme di azioni da eseguire quando il motore inferenziale del CLIPS decide di applicare la regola. Se sono applicabili più regole, il motore inferenziale utilizza una strategia di risoluzione di conflitti per selezionare quale regola deve essere eseguita Dopo aver eseguito le azioni della regola selezionata (che possono influenzare la lista delle regole applicabili) il motore inferenziale seleziona unaltra regola da eseguire Questo processo continua fin quando non restano regole applicabili

Conoscenza procedurale Il CLIPS supporta anche un paradigma procedurale per la rappresentazione della conoscenza come quello dei linguaggi Pascal e C. Le funzioni (deffunctions) e le funzioni generiche (generic functions) permettono allutente di definire nuovi elementi eseguibili che provocano un effetto collaterale oppure che restituiscono un valore. I message-handlers permettono allutente di definire il comportamento degli oggetti specificando la loro risposta ai messaggi. Deffunctions, generic functions e message-handlers sono porzioni di codice procedurale specificati dallutente che il CLIPS esegue quando opportuno. Defmodules permette di partizionare la base di conoscenza

CLIPS Object Oriented In un linguaggio orientato agli oggetti, tutti gli elementi di programmazione sono oggetti manipolati per mezzo di messaggi. In CLIPS, la definizione di un oggetto è più forte: numeri floating-point e interi, simboli, stringhe, multifield values, external-addresses, fact-addresses e istanze di classi userdefined. Tutti gli oggetti possono essere manipolati con i messaggi. Le istanze delle classi user-defined devono essere manipolate con i messaggi. Caratteristiche di un sistema OOP: astrazione, incapsulazione, ereditarietà, polimorfismo e binding dinamico.

I template I fatti ordinati rappresentano informazione posizionale. Per accedere a questo tipo di informazione, lutente deve conoscere non solo il tipo di dato memorizzato ma anche quali campi lo contengono. I fatti non ordinati (o template) forniscono la possibilità di astrarre dalla struttura dei fatti assegnando dei nomi ad ogni campo del fatto. Il costrutto deftemplate viene utilizzato per creare un template che può essere usato per definire fatti non ordinati.

I template (deftemplate <deftemplate-name> [<comment>] <slot-definition>*) <slot-definition> ::= <single-slot-definition> <multislot-definition> <single-slot-definition> ::= (slot <slot-name> <template-attribute>*) <multislot-definition> ::= (multislot <slot-name> <template-attribute>*) <template-attribute> ::= <default-attribute> <constraint-attribute> <default-attribute> ::= (default?derive?none <expression>*) (default-dynamic <expression>*) (deftemplate corso (slot nome) (slot studenti) (slot docente) (slot aula))

I valori di default <default-attribute> specifica il valore da utilizzare come default quando viene asserito un template Lattributo default specifica un valore di default statico. La valutazione avviene una sola volta alla definizione del deftemplate. Lattributo default-dynamic è un dynamic default. La valutazione avviene ogni volta che viene asserito un template.

I valori di default CLIPS> (clear) CLIPS> (deftemplate foo (slot w (default?none)) (slot x (default?derive)) (slot y (default (gensym*))) (slot z (default-dynamic (gensym*)))) CLIPS> (assert (foo)) [TMPLTRHS1] Slot w requires a value because of its (default?none) attribute. CLIPS> (assert (foo (w 3))) <Fact-0> CLIPS> (assert (foo (w 4))) <Fact-1> CLIPS> (facts) f-0 (foo (w 3) (x nil) (y gen1) (z gen2)) f-1 (foo (w 4) (x nil) (y gen1) (z gen3)) For a total of 2 facts. CLIPS>

(deftemplate object (slot name (type SYMBOL) (default?derive)) (slot location (type SYMBOL) (default?derive)) (slot on-top-of (type SYMBOL) (default floor)) (slot weight (allowed-values light heavy) (default light)) (multislot contents (type SYMBOL) (default?derive))) I vincoli

initial-fact Quando si asserisce o si fa riferimento ad un fatto ordinato (come in un LHS pattern) viene creato un implied template con un solo slot. CLIPS> (clear) CLIPS> (assert (foo 1 2 3)) <Fact-0> CLIPS> (defrule yak (bar 4 5 6) =>) CLIPS> (list-deftemplates) initial-fact foo bar For a total of 3 deftemplates. CLIPS> (facts) f-0 (foo 1 2 3) For a total of 1 fact. CLIPS>

Il costrutto deffacts Il costrutto deffacts permette di definire una lista di fatti che vengono asseriti automaticamente quando si invoca il comando reset. I fatti asseriti con deffacts possono essere ritrattati o mappati come gli atri fatti. La initial fact-list, che include ogni deffacts definito, viene sempre ricostruita dopo ogni comando reset Sintassi (deffacts <deffacts-name> [<comment>] <RHS-pattern>*)

Il costrutto deffacts (deffacts albero-genealogico "Albero G (maschio mario) (femmina giulia) (genitore mario giulia)) Dopo ogni avvio e dopo il comando clear, CLIPS costruisce automaticamente i seguenti deftemplate e deffacts. (deftemplate initial-fact) (deffacts initial-fact (initial-fact))

Il costrutto defrule Uno dei principali metodi per la rappresentazione della conoscenza in CLIPS è attraverso la regola. Una regola è una collezione di condizioni ed azioni da compiere quando le condizioni sono soddisfatte. Lo sviluppatore di un sistema esperto definisce le regole che descrivono come risolvere un problema. Lesecuzione delle regole è basata sullesistenza o meno di fatti o istanze delle classi definite dallutente. CLIPS fornisce il meccanismo (inference engine) che cerca di eseguire un matching fra le regole e lo stato attuale del sistema (come rappresentato dalla fact-list e dalla instance-list) ed applica le azioni Utilizzeremo il termine pattern entity per far riferimento ad un fatto o ad una istanza di una classe definita dallutente

Definire le regole Le regole sono definite utilizzando il costrutto defrule. (defrule <rule-name> [<comment>] [<declaration>] ; Rule Properties <conditional-element>* ; Left-Hand Side (LHS) => <action>*) ; Right-Hand Side (RHS) Le azioni vengono eseguite in modalità sequenziale, se e solo se, sono soddisfatte tutte le condizioni (conditional-element) in LHS. (defrule esempio "Esempio di regola" (frigo luce accesa) (frigo porta aperta) => (assert (frigo cibo guasto)))

Ciclo d'esecuzione di regole Costruita la base di conoscenza (in forma di regole) e preparata la fact-list e/o la instance-list, il CLIPS è pronto per eseguire le regole. Nei linguaggi di programmazione convenzionali, il programmatore definisce esplicitamente la sequenza delle operazioni. Ciò non accade in CLIPS. La conoscenza (regole) e i dati (fatti e istanze) sono separati, e il motore inferenziale fornito dal CLIPS viene utilizzato per applicare la conoscenza ai dati.

Ciclo d'esecuzione di regole a) Si considera la lista delle regole poste nellagenda appartenenti al modulo corrente definito nel focus stack Si seleziona quella che si trova al top della lista e la si esegue Se non ci sono regole da attivare: Si elimina il modulo corrente dal focus stack Si passa il controllo al modulo successivo: Se il focus stack è vuoto lesecuzione termina, altrimenti si attivano le regole del nuovo modulo corrente b) Si esegue la RHS della regola selezionata per lesecuzione

Ciclo d'esecuzione di regole c) il risultato del passo b) comporta la modifica della memoria di lavoro questo provoca lattivazione di altre regole o la disattivazione di quelle già presenti nellagenda le regole attivate vengono messe nellagenda del modulo in cui sono definite e lordine è determinato: Salience, e Conflict resolution stategy le regole disattivate vengono eliminate dallagenda d) Se è stata definita una rivalutazione dinamica del salience, allora i valori dei salience appartenenti alle regole esistenti nellagenda, vengono rivalutati; si riprende dal punto a)

Strategia di risoluzione dei conflitti L agenda è la lista di tutte le regole che hanno la parte sinistra (LHS) soddisfatta (e non sono ancora state eseguite). Ogni modulo ha la sua propria agenda. Agisce come uno stack: la regola al top è la prima ad essere eseguita. Quando una regola viene attivata, la sua posizione nellagenda è basata sui seguenti fattori: al di sopra di tutte le regole con salience più basso ed al di sotto di tutte le regole con salience più alto; fra regole con stesso salience, è la strategia di risoluzione del conflitto (conflict resolution strategy) a determinare la posizione; se una regola è attivata (insieme ad altre) per la stessa modifica della WM, e i passi a) e b) non sono in grado di specificare lordine, allora viene ordinata in base alla sistemazione delle altre regole attivate insieme ad essa.

Salience Lutente può assegnare una priorità ad una regola tramite la salience rule property. I valori di salience possono essere valutati: - quando viene definita la regola, - quando viene attivata la regola o ad ogni esecuzione. (defrule test-1 (declare (salience 99)) (fire test-1) => (printout t "Rule test-1 firing." crlf)) (defrule test-2 (declare (salience (+?*constraint-salience* 10))) (fire test-2) => (printout t "Rule test-2 firing." crlf))

Conflict Resolution: Depth Strategy Le regole attivate sono posizionate sopra tutte le regole con lo stesso salience il fatto-a attiva la regola-1 e la regola-2 il fatto-b attiva la regola-3 e la regola-4 Allora se viene asserito il fatto-a prima del fatto-b, la regola-3 e la regola-4 saranno poste al di sopra della regola-1 e della regola-2 nellagenda. Però la posizione, della regola-1 relativa alla regola-2 e la regola-3 relativa alla regola-4 sarà arbitraria.

Conflict Resol.: Breadth Strategy Le regole attivate sono posizionate al di sotto di tutte le regole con lo stesso salience. il fatto-a attiva la regola-1 e la regola-2 il fatto-b attiva la regola-3 e la regola-4 Allora se viene asserito il fatto-a prima del fatto-b, la regola-1 e la regola-2 saranno poste al di sopra della regola-3 e della regola-4 nellagenda. Però la posizione, della regola-1 relativa alla regola-2 e la regola-3 relativa alla regola-4 sarà arbitraria.

Conflict Res.: Simplicity-Complexity Simplicity Strategy Fra tutte le regole con lo stesso salience, le nuove regole attivate sono posizionate al di sopra di tutte le attivazioni di regole con maggiore o uguale specificità. La specificity di un regola è determinata dal numero di confronti da effettuare nella LHS della regola. Complexity Strategy Fra tutte le regole con stesso salience, le nuove regole attivate sono poste al di sopra di tutte le attivazioni di regole con minore o uguale specificità.

Conflict Resolution: LEX Strategy Fra tutte le regole con lo stesso salience, le nuove regole attivate sono poste utilizzando la strategia OPS5. Ogni fatto ed ogni istanza sono etichettati con un time tag per indicare quanto siano recenti rispetto agli altri fatti e istanze nel sistema. I pattern entities associati ad ogni attivazione di regola sono ordinati in modo decrescente per determinare la posizione tra le regole con lo stesso salience. Unattivazione con un più recente pattern entities è sistemata prima di una attivazione con pattern entities meno recenti. rule-6: f-1,f-4 rule-5: f-1,f-2,f-3, rule-1: f-1,f-2,f-3 rule-2: f-3,f-1 rule-4: f-1,f-2, rule-3: f-2,f-1 rule-6: f-4,f-1 rule-5: f-3,f-2,f-1, rule-1: f-3,f-2,f-1 rule-2: f-3,f-1 rule-4: f-2,f-1, rule-3: f-2,f-1

Conflict Resolution: MEA Strategy Fra tutte le regole con lo stesso salience, le nuove regole attivate sono posizionate utilizzando la strategia OPS5. Il primo time tag del pattern entity associato con il primo pattern è utilizzato per determinare dove inserire lattivazione. Unattivazione, il cui primo time tag del pattern è più grande di altri primi tag delle attivazioni, è inserita prima delle altre attivazione nellagenda. Esempio: sei attivazioni con lordinamento MEA (dove la virgola alla fine dellattivazione indica la presenza di un pattern negato) rule-2: f-3,f-1 rule-3: f-2,f-1 rule-6: f-1,f-4 rule-5: f-1,f-2,f-3, rule-1: f-1,f-2,f-3 rule-4: f-1,f-2,

Conflict Resolut.: Ramdom Strategy Ad ogni attivazione viene assegnato un numero casuale utilizzato per determinare la sua posizione rispetto a tutte quelle con lo stesso salience. Questo numero casuale viene ricordato quando viene cambiata la strategia in modo che quando viene selezionata di nuovo la strategia random viene riprodotto lo stesso ordinamento.

LHS Sintassi La LHS di una regola CLIPS è costituita da una serie di elementi condizionali (CEs) che devono essere soddisfatti affinché la regola sia posta in agenda. Tipi di elementi condizionali: - pattern: contengono vincoli utilizzati per determinare se qualche pattern entities (facts or instances) soddisfa il pattern. - test: usato per valutare espressioni - and: un intero gruppo di CEs deve essere soddisfatto - or: solo un elemento di un gruppo di CEs deve essere soddisfatto - not: un CE non deve essere soddisfatto - exists: occorrenza di almeno un match parziale - forall: un insieme di CEs è soddisfatto per ogni match parziale - logical: la creazione di fatti e istanze sulla RHS dipende da alcune condizioni sulla LHS

Sintassi <conditional-element> ::= <pattern-ce> <assigned-pattern-ce> <not-ce> <and-ce> <or-ce> <logical-ce> <test-ce> <exists-ce> <forall-ce> LHS Sintassi

Pattern Conditional Element I Pattern conditional elements sono costituiti da una collezione di campi constraints, wildcards, e variabili utilizzati per vincolare linsieme dei fatti o istanze che hanno un matching con il pattern CE. I field constraints sono insiemi di vincoli utilizzati per testare un singolo vincolo o slot di un pattern entity. Oltre ai literal constraints, il CLIPS fornisce altri tre tipi di vincoli: connective constraints, predicate constraints, e return value constraints. I Wildcards sono utilizzati nei pattern CEs per indicare che un singolo campo o gruppo di campi può avere un matching con qualsiasi cosa. Le Variabili sono utilizzate per memorizzare il valore di un campo in modo che da utilizzarlo successivamente nella LHS di una regola, in altri elementi condizionali, o nella RHS di una regola come argomento di unazione.

Literal Constraint Il vincolo più elementare (literal constraint) che può essere utilizzato in un pattern CE è quello che definisce precisamente il valore esatto da mappare con un campo Un literal pattern CE è costituito da costanti (floats, integers, symbols, strings, e instance names). Non contiene variabili o wildcards. Tutti i vincoli in un literal pattern devono avere esattamente un matching con tutti i campi di un pattern entity. Un ordered pattern CE contenente solo literal: (<constant-1>... <constant-n>) Un deftemplate pattern CE contenente solo literal : (<deftemplate-name> (<slot-name-1> <constant-1>)... (<slot-name-n> <constant-n>))

Wildcards Single e Multifield CLIPS ha due simboli wildcard che possono essere utilizzati per il matching nei campi di un pattern single-field wildcard, denotato dal simbolo?, mappa ogni valore memorizzato in esattamente un campo nel pattern entity multifield wildcard, denotato dai simboli $?, mappa ogni valore in zero o più campi in un pattern entity

Wildcards Single e Multifield CLIPS> (clear) CLIPS> (defrule find-data (data? blue red $?) =>) CLIPS> (reset) CLIPS> (agenda) 0 find-data: f-5 0 find-data: f-3 For a total of 2 activations. CLIPS> (facts) f-0 (initial-fact) f-1 (data 1.0 blue "red") f-2 (data 1 blue) f-3 (data 1 blue red) f-4 (data 1 blue RED) f-5 (data 1 blue red 6.9) For a total of 6 facts. CLIPS>

Wildcards Single e Multifield I Multifield wildcard e i literal constraints possono essere utilizzati insieme per fornire delle potenti capacità di patternmatching (data $? YELLOW $?) (data YELLOW blue red green) (data YELLOW red) (data red YELLOW) (data YELLOW) (data YELLOW data YELLOW)

Variabili Single e Multifield I simboli wildcard rimpiazzano porzioni di un pattern ed accettano ogni valore. Il valore di un campo essendo rimpiazzato può essere catturato in una variabile per confronti, visualizzazioni o altre manipolazioni successive. Questo si ottiene facendo seguire direttamente il wildcard dal nome della variabile. <constraint> ::= <constant>? $? <single-field-variable> <multifield-variable> <single-field-variable> ::=?<variable-symbol> <multifield-variable> ::= $?<variable-symbol>

Variabili Single e Multifield CLIPS> (clear) CLIPS> (reset) CLIPS> (assert (data 2 blue green) (data 1 blue) (data 1 blue red)) <Fact-3> CLIPS> (facts) f-0 (initial-fact) f-1 (data 2 blue green) f-2 (data 1 blue) f-3 (data 1 blue red) For a total of 4 facts. CLIPS> (defrule find-data-1 (data?x?y?z) => (printout t?x " : "?y " : "?z crlf)) CLIPS> (run) 1 : blue : red 2 : blue : green CLIPS>

Variabili Single e Multifield CLIPS> (reset) CLIPS> (assert (data 1 blue) (data 1 blue red) (data 1 blue red 6.9)) <Fact-3> CLIPS> (facts) f-0 (initial-fact) f-1 (data 1 blue) f-2 (data 1 blue red) f-3 (data 1 blue red 6.9) For a total of 4 facts. CLIPS> (defrule find-data-1 (data?x $?y?z) => (printout t "?x = "?x crlf "?y = "?y crlf "?z = "?z crlf "------" crlf)) CLIPS> (run)

?x = 1?y = (blue red)?z = 6.9 ------?x = 1?y = (blue)?z = red ------?x = 1?y = ()?z = blue ------ CLIPS> Variabili Single e Multifield

Variabili Single e Multifield CLIPS> (clear) CLIPS> (deffacts data (data red green) (data purple blue) (data purple green) (data red blue green) (data purple blue green) (data purple blue brown)) CLIPS> (defrule find-data-1 (data red?x) (data purple?x) =>) CLIPS> (defrule find-data-2 (data red $?x) (data purple $?x) =>) CLIPS> (reset) CLIPS> (facts) f-0 (initial-fact) f-1 (data red green) f-2 (data purple blue) f-3 (data purple green) f-4 (data red blue green) f-5 (data purple blue green) f-6 (data purple blue brown) For a total of 7 facts. CLIPS> (agenda) 0 find-data-2: f-4,f-5 0 find-data-1: f-1,f-3 0 find-data-2: f-1,f-3 For a total of 3 activations. CLIPS>

Sono disponibili tre connective constraints per collegare singoli vincoli e variabili. - & (and): soddisfatto se i due vincoli adiacenti sono soddisfatti; - (or): soddisfatto se uno dei due vincoli adiacenti è soddisfatto; - ~ (not): soddisfatto se il successivo vincolo non si verifica. Connettivi <term-1>&<term-2>... &<term-3> <term-1> <term-2>... <term-3> ~<term> <constraint> ::=? $? <connected-constraint> <connected-constraint> ::= <single-constraint> <single-constraint> & <connected-constraint> <single-constraint> <connected-constraint> <single-constraint> ::= <term> ~<term> <term> ::= <constant> <single-field-variable> <multifield-variable>

Connettivi CLIPS> (clear) CLIPS> (deftemplate data-b (slot value)) CLIPS> (deffacts AB (data-a green) (data-a blue) (data-b (value red)) (data-b (value blue))) CLIPS> (defrule example1-1 (data-a ~blue) =>) CLIPS> (defrule example1-2 (data-b (value ~red&~green)) =>) CLIPS> (defrule example1-3 (data-b (value green red)) =>) CLIPS> (reset) CLIPS> (facts) f-0 (initial-fact) f-1 (data-a green) f-2 (data-a blue) f-3 (data-b (value red)) f-4 (data-b (value blue)) For a total of 5 facts. CLIPS> (agenda) 0 example1-2: f-4 0 example1-3: f-3 0 example1-1: f-1 For a total of 3 activations. CLIPS>

Connettivi CLIPS> (clear) CLIPS> (deftemplate data-b (slot value)) CLIPS> (deffacts B (data-b (value red)) (data-b (value blue))) CLIPS> (defrule example2-1 (data-b (value?x&~red&~green)) => (printout t "?x in example2-1 = "?x crlf)) CLIPS> (defrule example2-2 (data-b (value?x&green red)) => (printout t "?x in example2-2 = "?x crlf)) CLIPS> (reset) CLIPS> (run)?x in example2-1 = blue?x in example2-2 = red CLIPS>

Predicati A volte è necessario vincolare un campo in base alla verità di una data espressione booleana. Un predicate constraint permette che una predicate function (che ritorna il simbolo FALSE se non soddisfatta e il simbolo non-false se soddisfatta) venga invocata durante il processo di pattern-matching. Tipicamente, i predicate constraint sono utilizzati in congiunzione con i connective constraint e unificazione di variabile (cioè bisogna unificare la variabile da testare e connetterla al predicate constraint). :<function-call> <term> ::= <constant> <single-field-variable> <multifield-variable> :<function-call>

CLIPS> (clear) CLIPS> (defrule example-1 (data?x&:(numberp?x)) =>) CLIPS> (assert (data 1) (data 2) (data red)) <Fact-2> CLIPS> (agenda) 0 example-1: f-1 0 example-1: f-0 For a total of 2 activations. CLIPS> Predicati

CLIPS> (clear) CLIPS> (defrule example-4 (data?y) (data?x&:(>?x?y)) =>) CLIPS> (assert (data 3) ; f-0 (data 5) ; f-1 (data 9)) ; f-2 <Fact-2> CLIPS> (agenda) 0 example-4: f-0,f-2 0 example-4: f-1,f-2 0 example-4: f-0,f-1 For a total of 3 activations. CLIPS> Predicati

Valori di ritorno È possibile utilizzare il valore restituito da una funzione esterna per vincolare il valore di un campo. Il return value constraint (=) permette allutente di chiamare una funzione esterna da un pattern. Il valore è incorporato direttamente nel pattern nella posizione in cui la funzione è stata chiamata, come se fosse stato un literal constraint, ed ogni matching patterns deve mappare questo valore come se la regola fosse stata scritta con questo valore. Si noti che la funzione viene valutata ogni volta che viene controllato il vincolo. =<function-call> <term> ::= <constant> <single-field-variable> <multifield-variable> :<function-call> =<function-call>

Valori di ritorno CLIPS> (clear) CLIPS> (deftemplate data (slot x) (slot y)) CLIPS> (defrule twice (data (x?x) (y =(* 2?x))) =>) CLIPS> (assert (data (x 2) (y 4)) ; f-0 (data (x 3) (y 9))) ; f-1 <Fact-1> CLIPS> (agenda) 0 twice: f-0 For a total of 1 activation. CLIPS>

Valori di ritorno CLIPS> (clear) CLIPS> (defclass DATA (is-a USER) (role concrete) (pattern-match reactive) (slot x (create-accessor write))) CLIPS> (defrule return-value-example-2 (object (is-a DATA) (x?x1)) (object (is-a DATA) (x?x2&=(+ 5?x1) =(- 12?x1))) =>) CLIPS> (make-instance of DATA (x 4)) [gen1] CLIPS> (make-instance of DATA (x 9)) [gen2] CLIPS> (make-instance of DATA (x 3)) [gen3] CLIPS> (agenda) 0 return-value-example-2: [gen3],[gen2] 0 return-value-example-2: [gen2],[gen3] 0 return-value-example-2: [gen1],[gen2] For a total of 3 activations. CLIPS>

Indirizzi Alcune azioni RHS, come retract e unmake-instance, operano su un intero pattern CE. Per indicare su quale fatto o istanza essi agiranno, può essere unificata una variabile con i fact-address o instance-address di un pattern CE. <assigned-pattern-ce> ::=?<variable-symbol> <- <pattern-ce>

Indirizzi (defrule dummy (data 1)?fact <- (dummy pattern) => (retract?fact)) (defrule compare-facts-1?f1 <- (color ~red)?f2 <- (color ~green) (test (neq?f1?f2)) => (printout t "Rule fires from different facts" crlf)) (defrule compare-facts-2?f1 <- (color ~red)?f2 <- (color ~green&:(neq?f1?f2)) => (printout t "Rule fires from different facts" crlf))

Test Una possibilità aggiuntiva è fornita con il test conditional element. Il test CE è soddisfatto se la chiamata alla funzione con il test CE è valutata non-false e insoddisfatta se la chiamata alla funzione è valutata FALSE. <test-ce> ::= (test <function-call>) CLIPS> (clear) CLIPS> (defrule example-1 (data?x) (value?y) (test (>= (abs (-?y?x)) 3)) =>) CLIPS> (assert (data 6) (value 9)) <Fact-1> CLIPS> (agenda) 0 example-1: f-0,f-1 For a total of 1 activation. CLIPS>

Or Il CE or consente lattivazione di una regola da uno dei CE. Se uno dei CE allinterno del CE or è soddisfatto, allora lintero CE or sarà soddisfatto. Il CE or ha lo stesso effetto di scrivere più regole con LHS e RHS simili. <or-ce> ::= (or <conditional-element>+) (defrule system-fault (error-status unknown) (or (temp high) (valve broken) (pump (status off))) => (printout t "The system has a fault." crlf))

And Il CLIPS assume che tutte le regole abbiano un and CE implicito su tutti i conditional elements della LHS. Questo significa che tutti i conditional elements nella LHS devono essere soddisfatti per poter attivare la regola. Il CLIPS fornisce anche un and CE esplicito. <and-ce> ::= (and <conditional-element>+) (defrule system-flow (error-status confirmed) (or (and (temp high) (valve closed)) (and (temp low) (valve open))) => (printout t "The system is having a flow problem." crlf))

Not Il not conditional element fornisce la possibilità di rappresentare lassenza di informazione. Il not CE è soddisfatto solo se il conditional element che contiene non è soddisfatto. <not-ce> ::= (not <conditional-element>)

Not (defrule high-flow-rate (temp high) (valve open) (not (error-status confirmed)) => (printout t "Recommend closing of valve due to high temp crlf)) (defrule check-valve (check-status?valve) (not (valve-broken?valve)) => (printout t "Device "?valve " is OK" crlf)) (defrule double-pattern (data red) (not (data red?x?x)) => (printout t "No patterns with red green green!" crlf ))

Exists exists CE fornisce un meccanismo per determinare se un gruppo di CE è soddisfatto da almeno un insieme di pattern entities. <exists-ce> ::= (exists <conditional-element>+) (defrule example (exists (a?x) (b?x)) =>) è equivalente a (defrule example (not (not (and (a?x) (b?x)))) =>)

Forall forall CE fornisce un meccanismo per determinare se un gruppo di CE è soddisfatto per ogni occorrenza di un altro specificato CE. <forall-ce> ::= (forall <conditional-element> <conditional-element>+) (defrule example (forall (a?x) (b?x) (c?x)) =>) è equivalente a (defrule example (not (and (a?x) (not (and (b?x) (c?x))))) =>)

CLIPS> (clear) CLIPS> (defrule all-students-passed (forall (student?name) (reading?name) (writing?name) (arithmetic?name)) => (printout t "All students passed." crlf)) CLIPS> (reset) CLIPS> (agenda) 0 all-students-passed: f-0, For a total of 1 activation. CLIPS> (assert (student Bob)) <Fact-1> CLIPS> (agenda) CLIPS> Forall

CLIPS> (assert (reading Bob) (writing Bob)) <Fact-3> CLIPS> (agenda) CLIPS> CLIPS> (assert (arithmetic Bob)) <Fact-4> CLIPS> (agenda) 0 all-students-passed: f-0, For a total of 1 activation. CLIPS> CLIPS> (assert (student John)) <Fact-5> CLIPS> (agenda) CLIPS> (retract 1 5) CLIPS> (agenda) 0 all-students-passed: f-0, For a total of 1 activation. CLIPS> Forall

Proprietà delle regole È possibile definire le proprietà o le caratteristiche di una regola. Le caratteristiche sono dichiarate nella LHS di un regola utilizzando la parola chiave declare. In una regola deve esserci un solo comando declare e deve apparire prima di tutti i CE della LHS <declaration> ::= (declare <rule-property>+) <rule-property> ::= (salience <integer-expression>) (auto-focus <boolean-symbol>) <boolean-symbol> ::= TRUE FALSE

Salience La salience permette di assegnare una priorità ad una regola. Quando ci sono più regole in agenda, verrà eseguita quella con priorità più alta. Il valore del salience deve essere un intero compreso tra 10000 e +10000. Se non specificato, il valore salience di default per una regola è zero. (defrule test-1 (declare (salience 99)) (fire test-1) => (printout t "Rule test-1 firing." crlf)) (defrule test-2 (declare (salience (+?*constraint-salience* 10))) (fire test-2) => (printout t "Rule test-2 firing." crlf))

Defglobal Il costrutto defglobal permette la definizione e laccesso a variabili globali. È possibile accedere alle variabili globali in un processo di pattern-matching, ma il loro cambiamento non invoca il processo di pattern-matching. La funzione bind viene utilizzata per settare il loro valore. Il loro valore originale viene ripristinato utilizzando il comando reset oppure invocando la funzione bind senza valori. Possono essere rimosse utilizzando il comando clear o il comando undefglobal. (defglobal [<defmodule-name>] <global-assignment>*) <global-assignment> ::= <global-variable> = <expression> <global-variable> ::=?*<symbol>*

Defglobal Luso delle variabili globali è permesso ovunque (come per le variabili locali), ma con due eccezioni: 1. Non possono essere utilizzate come parametri in deffunction, defmethod, o message-handler; 2. Non possono essere utilizzate nello stesso modo in cui sono usate le variabili locali nella LHS di una regola per legare un valore. Regola illegale (defrule example (fact?*x*) =>) Regola legale (defrule example (fact?y&:(>?y?*x*)) =>)

Defglobal (defrule example (fact?y&:(>?y?*x*)) =>) Questa regola non viene modificata quando cambia il valore di?*x*. Per esempio, se?*x* è 4 e viene aggiunto il fatto (fact 3), allora la regola non è soddisfatta. Se si cambia il valore di?*x* a 2, la regola non sarà attivata. (defglobal?*x* = 3?*y* =?*x*?*z* = (+?*x*?*y*)?*q* = (create$ a b c))

Deffunction Il costrutto deffunction permette la definizione di nuove funzioni direttamente in CLIPS. Le deffunctions sono equivalenti alle altre funzioni, lunica differenza è che le deffunctions sono scritte in CLIPS ed interpretate, mentre le funzioni esterne sono scritte in un linguaggio esterno (come il C) ed eseguite direttamente dal CLIPS. Le deffunctions permetto laggiunta di nuove funzioni senza ricompilare il CLIPS. (deffunction <name> [<comment>] (<regular-parameter>* [<wildcard-parameter>]) <action>*) <regular-parameter> ::= <single-field-variable> <wildcard-parameter> ::= <multifield-variable> Una deffunction deve avere un unico nome, non esiste loverloading, e deve essere dichiarata prima di essere usata, ad eccezioni delle deffunctions ricorsive.

Deffunction CLIPS> (clear) CLIPS> (deffunction print-args (?a?b $?c) (printout t?a " "?b " and " (length?c) " extras: "?c crlf)) CLIPS> (print-args 1 2) 1 2 and 0 extras: () CLIPS> (print-args a b c d) a b and 2 extras: (c d) CLIPS> Quando una deffunction viene invocata, le sue azioni sono eseguite nellordine. Il valore restituito da una deffunction è la valutazione dellultima azione. Se una deffunction non ha azioni essa restituisce il simbolo FALSE. Se si verifica un errore tutte le azioni non ancora eseguite verranno abortite, e verrà restituito il simbolo FALSE.

Deffunction (deffunction factorial (?a) (if (or (not (integerp?a)) (<?a 0)) then (printout t "Factorial Error!" crlf) else (if (=?a 0) then 1 else (*?a (factorial (-?a 1)))))) La ricorsione mutua fra due deffunctions richiede una dichiarazione forward: un dichiarazione senza azioni. (deffunction foo ()) (deffunction bar () (foo)) (deffunction foo () (bar))

I moduli CLIPS supporta lo sviluppo e lesecuzione modulare della conoscenza. I moduli CLIPS, creati con il costrutto defmodule, permettono il raggruppamento di un insieme di costrutti in modo da controllare esplicitamente laccesso ai costrutti da altri moduli. Questo tipo di controllo è simile allo scope globale e locale utilizzato in linguaggi come il C o Ada. Restringendo laccesso ai costrutti deftemplate e defclass, i moduli possono funzionare come blackboards, permettendo solo a certi fatti e a certe istanze di essere visibili in altri moduli. I moduli sono usati anche da regole per fornire il controllo dellesecuzione.

(defmodule <module-name> [<comment>] <port-spec>*) <port-spec> ::= (export <port-item>) (import <module-name> <port-item>) <port-item> ::=?ALL?NONE <port-construct>?all <port-construct>?none <port-construct> <construct-name>+ <port-construct> ::= deftemplate defclass defglobal deffunction defgeneric I moduli

I moduli (defmodule FOO (import BAR?ALL) (import YAK deftemplate?all) (import GOZ defglobal x y z) (export defgeneric +) (export defclass?all)) (defrule DETECTION::Find-Fault (sensor (name?name) (value bad)) => (assert (fault (name?name)))) (defglobal DETECTION?*count* = 0) (defmessage-handler DETECTION::COMPONENT get-charge () (*?self:flux?self:flow)) (defmethod DETECTION::+ ((?x STRING) (?y STRING)) (str-cat?x?y))

I moduli Definito il modulo è possibile specificare i costrutti che ne faranno parte. I costrutti deffacts, deftemplate, defrule, deffunction, defgeneric, defclass, e definstances specificano il modulo in cui saranno presenti come parte del nome. Il modulo del costrutto defglobal è indicato specificando il nome del modulo dopo la parola chiave defglobal. Il modulo di un defmethod è specificato come parte dello specificatore di generic function. (defrule DETECTION::Find-Fault (sensor (name?name) (value bad)) => (assert (fault (name?name)))) (defglobal DETECTION?*count* = 0) (defmessage-handler DETECTION::COMPONENT get-charge () (*?self:flux?self:flow)) (defmethod DETECTION::+ ((?x STRING) (?y STRING)) (str-cat?x?y))

CLIPS> (clear) CLIPS> (defmodule A) CLIPS> (defmodule B) CLIPS> (defrule foo =>) CLIPS> (defrule A::bar =>) CLIPS> (list-defrules) bar For a total of 1 defrule. CLIPS> (set-current-module B) A CLIPS> (list-defrules) foo For a total of 1 defrule. CLIPS> I moduli

I moduli I comandi undefrule e ppdefrule richiedono il nome del costrutto sul quale operare. Con i moduli è possibile avere costrutti con lo stesso nome ma in moduli diversi. Module specifier: è la specifica esplicita del modulo di un nome (un symbol), module-name::. Per esempio MAIN::find-stuff, indica che il costrutto findstuff è nel modulo MAIN (il modulo standard del CLIPS). Un modulo può anche essere specificato implicitamente poiché esiste sempre un modulo corrente. Il modulo corrente viene cambiato ogni volta che si utilizza il costrutto defmodule oppure la funzione set-currentmodule

CLIPS> (clear) CLIPS> (defmodule A) CLIPS> (defglobal A?*x* = 0) CLIPS> (defmodule B) CLIPS> (defglobal B?*y* = 1) CLIPS> (ppdefglobal y) (defglobal B?*y* = 1) CLIPS> (ppdefglobal B::y) (defglobal B?*y* = 1) CLIPS> (ppdefglobal x) [PRNTUTIL1] Unable to find defglobal x CLIPS> (ppdefglobal A::x) (defglobal A?*x* = 0) CLIPS> I moduli

I moduli In generale i costrutti di un modulo non possono essere utilizzati da un altro modulo. Un costrutto si dice visibile in un modulo se il costrutto può essere utilizzato in quel modulo. Quindi, se per esempio, il modulo B vuole utilizzare il deftemplate foo definito nel modulo A, allora il modulo A deve esportare il deftemplate foo e il modulo B lo deve importare. CLIPS> (clear) CLIPS> (defmodule A) CLIPS> (deftemplate A::foo (slot x)) CLIPS> (defmodule B) CLIPS> (defrule B::bar (foo (x 3)) =>) [PRNTUTIL2] Syntax Error: Check appropriate syntax for defrule ERROR: (defrule B::bar (foo ( CLIPS> (clear) CLIPS> (defmodule A (export deftemplate foo)) CLIPS> (deftemplate A::foo (slot x)) CLIPS> (defmodule B (import A deftemplate foo)) CLIPS> (defrule B::bar (foo (x 3)) =>) CLIPS>

I moduli Export specifications Un modulo può esportare tutti i suoi costrutti visibili: export? ALL Un modulo può esportare tutti i suoi costrutti visibili di un tipo particolare: export name-of-the-construct?all Un modulo può esportare specifici costrutti visibili: export name-of-the-construct-type name-of-one-or-more-visible-constructs-of-the-specified-type (defmodule A (export?all)) (defmodule B (export deftemplate?all)) (defmodule C (export defglobal foo bar yak))

I moduli Import Specification Un modulo può importare tutti i costrutti visibili di un altro modulo: import module-name?all Un modulo può importare tutti i costrutti visibili di un tipo particolare da un altro modulo: import module-name name-of-the-constructtype?all Un modulo può importare specifici costrutti visibili di un altro modulo: import module-name name-of-the-construct-type name-of-one-or-more-visible-constructs-of-the-specified-type (defmodule A (import D?ALL)) (defmodule B (import D deftemplate?all)) (defmodule C (import D defglobal foo bar yak))

I moduli I fatti e le istanze appartengono ai moduli in cui sono definiti i corrispondenti deftemplate e defclass (e non ai moduli che li creano). I fatti e le istanze sono visibili nei moduli che importano i corrispondenti deftemplate o defclass. Questo permette una base di conoscenza partizionata in modo che le regole e gli altri costrutti possono vedere solo le istanze e i fatti cui sono interessati. Si noti che il deftemplate initial-fact deve essere esplicitamente importato dal modulo MAIN

CLIPS> (clear) CLIPS> (defmodule A (export deftemplate foo bar)) CLIPS> (deftemplate A::foo (slot x)) CLIPS> (deftemplate A::bar (slot y)) CLIPS> (deffacts A::info (foo (x 3)) (bar (y 4))) CLIPS> (defmodule B (import A deftemplate foo)) CLIPS> (reset) CLIPS> (facts A) f-1 (foo (x 3)) f-2 (bar (y 4)) For a total of 2 facts. CLIPS> (facts B) f-1 (foo (x 3)) For a total of 1 fact. CLIPS> I moduli

I moduli Ogni modulo ha la sua propria rete di pattern-matching per le sue regole ed una sua propria agenda. Quando vien dato il comando run, viene eseguita lagenda del modulo attivo. Lesecuzione delle regole continua finché non diventa attivo un altro modulo, non ci sono altre regole nellagenda, oppure viene eseguita la funzione return da una RHS di una regola. Quando un modulo attivo termina lesecuzione delle regole in agenda, il current focus viene rimosso dal focus stack e diventa attivo il successivo modulo sul focus stack. Prima che una regola venga eseguita, il modulo corrente diventa quello in cui la regola è definita. Il current focus può essere definito utilizzando il comando focus.

CLIPS> (clear) CLIPS> (defmodule MAIN (export?all)) CLIPS> (defrule MAIN::focus-example => (printout t "Firing rule in module MAIN." crlf) (focus A B)) CLIPS> (defmodule A (import MAIN deftemplate initial-fact)) CLIPS> (defrule A::example-rule => (printout t "Firing rule in module A." crlf)) CLIPS> (defmodule B (import MAIN deftemplate initial-fact)) CLIPS> (defrule B::example-rule => (printout t "Firing rule in module B." crlf)) CLIPS> (reset) CLIPS> (run) Firing rule in module MAIN. Firing rule in module A. Firing rule in module B. CLIPS> I moduli

Attributi I constraint attributes, associati ai costrutti deftemplates e defclasses, permettono di verificare la validità dei tipi dei valori degli slot quando vengono creati template facts e istanze. Vengono anche utilizzati nei pattern della LHS di una regola per determinare lattivazione della regola. Esistono due tipi di constraint checking: static e dynamic (set-static-constraint-checking e set-dynamicconstraint-checking). <constraint-attribute> ::= <type-attribute>! <allowed-constant-attribute> <range-attribute> <cardinality-attribute>

<type-attribute> ::= (type <type-specification>) <type-specification> ::= <allowed-type>+?variable <allowed-type> := SYMBOL STRING LEXEME INTEGER FLOAT NUMBER INSTANCE-NAME INSTANCE-ADDRESS INSTANCE EXTERNAL-ADDRESS FACT-ADDRESS Attributi

Attributi allowed constant attributes permettono di specificare le costanti di uno specifico tipo che è possibile associare al valore di uno slot. allowed-values attribute permette di specificare un insieme di valori che è possibile associare ad uno slot. (allowed-symbols red green blue) (allowed-values red green blue)

Attributi <allowed-constant-attribute> ::= (allowed-symbols!<symbol-list>) (allowed-strings <string-list>) (allowed-lexemes <lexeme-list> (allowed-integers!<integer-list>) (allowed-floats!<float-list>) (allowed-numbers!<number-list>) (allowed-instance-names <instance-list>) (allowed-values!<value-list>) <symbol-list> ::= <symbol>+?variable <string-list> ::= <string>+?variable <lexeme-list> ::= <lexeme>+?variable <integer-list> ::= <integer>+?variable <float-list> ::= <float>+?variable <number-list> ::= <number>+?variable <instance-name-list> ::= <instance-name>+?variable <value-list> ::= <constant>+?variable

Attributi range attribute: intervallo numerico per i valori di uno slot (quando per lo slot utilizziamo valori numerici) <range-attribute> ::= (range <range-specification> <range-specification>) <range-specification> ::= <number>?variable cardinality attribute: restringe il numero di campi di un multifield slot. <cardinality-attribute> ::= (cardinality <cardinality-specification> <cardinality-specification> <cardinality-specification> ::= <integer>?variable

Default values Attributi 1) Il tipo di default per lo slot è scelto dalla lista dei tipi:symbol, STRING, INTEGER, FLOAT, INSTANCE-N A M E, I N S T A N C E -A D D R E S S, F A C T -ADDRESS, EXTERNAL-ADDRESS. 2) Se il tipo di default ha una allowed constant restriction, allora viene scelto come default il primo valore specificato nello allowed constant attribute 3) Se il valore di default non è stato specificato al passo 2 e il tipo di default è INTEGER o FLOAT ed è specificato il range attribute, allora viene utilizzato come valore di default il minimo valore dellintervallo se non è?variable, altrimenti il massimo se non è?variable.

Attributi 4) Se il valore di default non è stato specificato né al passo 2 né al passo 3, allora viene utilizzato il valore di default default. Esso assume valore nil per il tipo SYMBOL, "" per il tipo STRING, 0 per il tipo INTEGER, 0.0 per il tipo FLOAT, [nil] per il tipo INSTANCE-NAME, un puntatore ad una istanza fittizia per il tipo INSTANCE-ADDRESS, un puntatore ad un fatto fittizio per il tipo FACT-ADDRESS, e il puntatore NULL per il tipo EXTERNAL-ADDRESS. 5) Se il valore di default da derivare è per un single field slot, allora viene usato il valore derivato dai passi 1 a 4. Il valore di default per un multifield slot è un multifield value di lunghezza zero. Se il multifield slot ha una cardinalità minima maggiore di zero, allora viene creato un multifield value con una lunghezza della minima cardinalità.

Attributi CLIPS> (deftemplate bar (slot a (type SYMBOL INTEGER)) (slot b (type INTEGER FLOAT)) (slot c (type SYMBOL STRING))) CLIPS> (defrule error (bar (a?x)) (bar (b?x)) (bar (c?x)) =>) [RULECSTR1] Variable?x in CE #3 slot c has constraint conflicts which make the pattern unmatchable ERROR: (defrule error-4 (bar (a?x)) (bar (b?x)) (bar (c?x)) =>)

Attributi CLIPS> (deftemplate foo (multislot x (cardinality?variable 3))) CLIPS> (deftemplate bar (multislot y (cardinality?variable 2))) CLIPS> (deftemplate woz (multislot z (cardinality 7?VARIABLE))) CLIPS> (defrule error (foo (x $?x)) (bar (y $?y)) (woz (z $?x $?y)) =>) [CSTRNCHK1] The group of restrictions found in CE #3 do not satisfy the cardinality restrictions for slot z ERROR: (defrule error (foo (x $?x)) (bar (y $?y)) (woz (z $?x $?y)) =>)

Attributi CLIPS> (deftemplate foo (slot x (type SYMBOL))) CLIPS> (defrule Error (foo (x?x)) (test (>?x 10)) =>) [RULECSTR2] Previous variable bindings of?x caused the type restrictions for argument #1 of the expression (>?x 10) found in CE #2 to be violated ERROR: (defrule error (foo (x?x)) (test (>?x 10)) =>) CLIPS>

Predicate Functions Azioni e funzioni (numberp <expression>) Testing for numbers (floatp <expression>) Testing for floats (integerp <expression>) Testing for Integers (lexemep <expression>) Testing for Strings or Symbols (stringp <expression>) Testing for Strings (symbolp <expression>) Testing for Symbols (evenp <integer-expression>) Testing for Even Numbers (oddp <integer-expression>) Testing for Odd Numbers (multifieldp <expression>) Testing for Multifield Values (pointerp <expression>) Testing for External-Address (eq <expression> <expression>+) Comparing for Equality (neq <expression> <expression>+) Comparing for Inequality

Azioni e funzioni Comparing Numbers for Equality and Inequality (= <numeric-expression> <numeric-expression>+) (<> <numeric-expression> <numeric-expression>+) (> <numeric-expression> <numeric-expression>+) (>= <numeric-expression> <numeric-expression>+) (< <numeric-expression> <numeric-expression>+) (<= <numeric-expression> <numeric-expression>+) Boolean (and <expression>+) (or <expression>+) (not <expression>)

Azioni e funzioni Multifield Functions Creating (create$ <expression>*) CLIPS> (create$ hammer drill saw screw pliers wrench) (hammer drill saw screw pliers wrench) CLIPS> (create$ (+ 3 4) (* 2 3) (/ 8 4)) (7 6 2) Specifying (nth$ <integer-expression> <multifield-expression>) Finding (member$ <expression> <multifield-expression>) Comparing (subsetp <multifield-expression> <multifield-expression>)

Azioni e funzioni Deletion of fields in a multifield (delete$ <multifield-expression> <begin-integer-expression> <end-integer-expression>) CLIPS> (delete$ (create$ hammer drill saw pliers wrench) 3 4) (hammer drill wrench) CLIPS> (delete$ (create$ computer printer hard-disk) 1 1) (printer hard-disk) Creating Multifield Values from Strings. (explode$ <string-expression>) CLIPS> (explode$ "hammer drill saw screw") (hammer drill saw screw) CLIPS> (explode$ "1 2 abc 3 4 \"abc\" \"def\"") (1 2 abc 3 4 "abc" "def") CLIPS> (explode$ "?x ~ )") ("?x" "~" ")")

Azioni e funzioni Creating Strings from Multifield Values (implode$ <multifield-expression>) CLIPS> (implode$ (create$ hammer drill screwdriver)) "hammer drill screwdriver wrench pliers saw CLIPS> (implode$ (create$ 1 "abc" def "ghi" 2)) "1 "abc" def "ghi" 2 CLIPS> (implode$ (create$ "abc def ghi")) ""abc def ghi" Extracting a Sub-sequence from a Multifield Value (subseq$ <multifield-value> <begin-integer-expression> <end-integer-expression>) CLIPS> (subseq$ (create$ hammer drill wrench pliers) 3 4) (wrench pliers) CLIPS> (subseq$ (create$ 1 "abc" def "ghi" 2) 1 1) (1)

Azioni e funzioni Replacing Fields within a Multifield Value (replace$ <multifield-expression> <begin-integer-expression> <end-integer-expression> <single-or-multi-field-expression>+) CLIPS> (replace$ (create$ drill wrench pliers) 3 3 machete) (drill wrench machete) CLIPS> (replace$ (create$ a b c d) 2 3 x y (create$ q r s)) (a x y q r s d) CLIPS>

Azioni e funzioni Inserting Fields within a Multifield Value (insert$ <multifield-expression> <integer-expression> <single-or-multi-field-expression>+) CLIPS> (insert$ (create$ a b c d) 1 x) (x a b c d) CLIPS> (insert$ (create$ a b c d) 4 y z) (a b c y z d) CLIPS> (insert$ (create$ a b c d) 5 (create$ q r)) (a b c d q r) CLIPS>

Azioni e funzioni Getting the First Field from a Multifield Value CLIPS> (first$ (create$ a b c)) (a) CLIPS> (first$ (create$)) () CLIPS> Getting All but the First Field from a Multifield Value CLIPS> (rest$ (create$ a b c)) (b c) CLIPS> (rest$ (create$)) () CLIPS>

Azioni e funzioni Determining the Number of Fields in a Multifield Value CLIPS> (length$ (create$ a b c d e f g)) 7 CLIPS> Deleting Specific Values within a Multifield Value CLIPS> (delete-member$ (create$ a b a c) b a) (c) CLIPS> (delete-member$ (create$ a b c c b a) (create$ b a)) (a b c c) CLIPS> Replacing Specific Values within a Multifield Value CLIPS> (replace-member$ (create$ a b a b) (create$ a b a) a b) (a b a a b a a b a a b a) CLIPS> (replace-member$ (create$ a b a b) (create$ a b a) (create$ a b)) (a b a a b a) CLIPS>

Azioni e funzioni String Functions (str-cat <expression>*) (sym-cat <expression>*) (sub-string <integer-expression> <integer-expression> <string-expression>) (str-index <lexeme-expression> <lexeme-expression>) (eval <string-or-symbol-expression>) (build <string-or-symbol-expression>) (upcase <string-or-symbol-expression>) (lowcase <string-or-symbol-expression>) (str-compare <string-or-symbol-expression> <string-or-symbol-expression>) (str-length <string-or-symbol-expression>) (check-syntax <construct-or-function-string>) (string-to-field <string-or-symbol-expression>)

CLIPS I/O Logical Names: stdin, stdout, wclips, wdialog, wdisplay, werror, wwarning, wtrace. Common I/O Functions: open, close, printout, read, readline, format, rename, remove (open <file-name> <logical-name> [<mode>]) (close [<logical-name>]) (printout <logical-name> <expression>*) (read [<logical-name>]) (readline [<logical-name>]) (format <logical-name> <string-expression> <expression>*) (rename <old-file-name> <new-file-name>) (remove <file-name>)

Funzioni matematiche Addition: (+ <numeric-expression> <numeric-expression>+) Subtraction: (- <numeric-expression> <numeric-expression>+) Multiplication: (* <numeric-expression> <numeric-expression>+) Division: (/ <numeric-expression> <numeric-expression>+) Integer Division: (div <numeric-expression> <numeric-expression>+) Maximum and Minimum Numeric Value: (max <numeric-expression>+) (min <numeric-expression>+)

Funzioni matematiche (abs <numeric-expression>) (float <numeric-expression>) (integer <numeric-expression>) acos (arccosine), acosh (hyperbolic arccosine), acot (arccotangent), acoth (hyperbolic arccotangent), acsc (arccosecant), acsch (hyperbolic arccosecant), asec (arcsecant), asech (hyperbolic arcsecant), asin (arcsine), asinh (hyperbolic arcsine), atan (arctangent), atanh (hyperbolic arctangent), cos (cosine), cosh (hyperbolic cosine), cot (cotangent), coth (hyperbolic tangent), csc (cosecant), csch (hyperbolic cosecant), sec (secant), sech (hyperbolic secant), sin (sine), sinh (hyperbolic sine), tan (tangent), tanh (hyperbolic tangent). (deg-grad <numeric-expression>), (deg-rad <numericexpression>), (grad-deg <numeric-expression>), (rad-deg <numericexpression>), (pi)

Funzioni matematiche (sqrt <numeric-expression>) (** <numeric-expression> <numeric-expression>) (exp <numeric-expression>) (log <numeric-expression>) (log10 <numeric-expression>) (round <numeric-expression>) (mod <numeric-expression> <numeric-expression>)

Binding Variables (bind <variable> <expression>*) Funzioni Procedurali CLIPS> (defglobal?*x* = 3.4) CLIPS>?*x* 3.4 CLIPS> (bind?*x* (+ 8 9)) 17 CLIPS>?*x* 17 CLIPS> (bind?*x* (create$ a b c d)) (a b c d) CLIPS>?*x* (a b c d) CLIPS> (bind?*x* d e f) (d e f) CLIPS>?*x* (d e f) CLIPS> (bind?*x*) 3.4 CLIPS>?*x* 3.4

Funzioni Procedurali Ifthenelse (if <expression> then <action>* [else <action>*]) (defrule closed-valves (temp high) (valve?v closed) => (if (=?v 6) then (printout t "The special valve "?v " is closed!" crlf) (assert (perform special operation)) else (printout t "Valve "?v " is normally closed" crlf)))

Funzioni Procedurali While (while <expression> [do] <action>*) (defrule open-valves (valves-open-through?v) => (while (>?v 0) (printout t "Valve "?v " is open" crlf) (bind?v (-?v 1))))

Loop-for-count Funzioni Procedurali (loop-for-count <range-spec> [do] <action>*) <range-spec> ::= <end-index> (<loop-variable> <start-index> <end-index>) (<loop-variable> <end-index>) <start-index> ::= <integer-expression> <end-index> ::= <integer-expression> CLIPS> (loop-for-count 2 (printout t "Hello world" crlf)) Hello World Hello world FALSE CLIPS> (loop-for-count (?cnt1 2 4) do (loop-for-count (?cnt2 1 3) do (printout t?cnt1 " "?cnt2 crlf)))

2 1 2 2 2 3 3 1 3 2 3 3 4 1 4 2 4 3 FALSE CLIPS>

Funzioni Procedurali (progn <expression>*) CLIPS> (progn (setgen 5) (gensym)) gen5 CLIPS> (progn$ <list-spec> <expression>*) <list-spec> ::= <multifield-expression> (<list-variable> <multifield-expression>) CLIPS> (progn$ (?field (create$ abc def ghi)) (printout t "--> "?field " "?field-index " <--" crlf)) --> abc 1 <-- --> def 2 <-- --> ghi 3 <-- CLIPS>

(return [<expression>]) CLIPS> (deffunction sign (?num) (if (>?num 0) then (return 1)) (if (<?num 0) then (return -1)) 0) CLIPS> (sign 5) 1 CLIPS> (sign -10) -1 CLIPS> (sign 0) 0 CLIPS> Funzioni Procedurali

Funzioni Procedurali (break) CLIPS> (deffunction iterate (?num) (bind?i 0) (while TRUE do (if (>=?i?num) then (break)) (printout t?i " ") (bind?i (+?i 1))) (printout t crlf)) CLIPS> (iterate 1) 0 CLIPS> (iterate 10) 0 1 2 3 4 5 6 7 8 9 CLIPS>

Funzioni Procedurali (switch <test-expression> <case-statement>* [<default-statement>]) <case-statement> ::= (case <comparison-expression> then <action>*) <default-statement> ::= (default <action>*) CLIPS> (defglobal?*x* = 0) CLIPS> (defglobal?*y* = 1) CLIPS> (deffunction foo (?val) (switch?val (case?*x* then *x*) (case?*y* then *y*) (default none))) CLIPS> (foo 0) *x* CLIPS> (foo 1) *y* CLIPS> (foo 2) none CLIPS>