LISP - Prédicats

Les prédicats sont des fonctions qui testent leurs arguments pour certaines conditions spécifiques et retournent nil si la condition est fausse, ou une valeur non nulle est que la condition est vraie.

Le tableau suivant présente certains des prédicats les plus couramment utilisés -

N ° Sr. Prédicat et description
1

atom

Il prend un argument et renvoie t si l'argument est un atome ou nul dans le cas contraire.

2

equal

Il prend deux arguments et retourne t s'ils sont structurellement égaux ou nil autrement.

3

eq

Il prend deux arguments et retourne t s'il s'agit des mêmes objets identiques, partageant le même emplacement mémoire ou nil autrement.

4

eql

Il prend deux arguments et retourne t si les arguments sont eq, ou s’il s’agit de nombres du même type avec la même valeur, ou s’il s’agit d’objets caractère représentant le même caractère, ou nil autrement.

5

evenp

Il prend un argument numérique et retourne t si l'argument est un nombre pair ou nil sinon.

6

oddp

Il prend un argument numérique et retourne t si l'argument est un nombre impair ou nil sinon.

sept

zerop

Il prend un argument numérique et retourne t si l'argument est zéro ou nil sinon.

8

null

Il prend un argument et retourne t si l'argument est évalué à nil, sinon il retourne nil.

9

listp

Il prend un argument et retourne t si l'argument est évalué à une liste sinon il retourne nil.

dix

greaterp

Il prend un ou plusieurs arguments et retourne t s'il y a un seul argument ou si les arguments sont successivement plus grands de gauche à droite, ou nil sinon.

11

lessp

Il prend un ou plusieurs arguments et retourne t s'il y a un seul argument ou si les arguments sont successivement plus petits de gauche à droite, ou nil sinon.

12

numberp

Il prend un argument et retourne t si l'argument est un nombre ou nil sinon.

13

symbolp

Il prend un argument et retourne t si l'argument est un symbole sinon il retourne nil.

14

integerp

Il prend un argument et retourne t si l'argument est un entier sinon il retourne nil.

15

rationalp

Il prend un argument et retourne t si l'argument est un nombre rationnel, soit un ratio soit un nombre, sinon il renvoie nil.

16

floatp

Il prend un argument et retourne t si l'argument est un nombre à virgule flottante sinon il retourne nil.

17

realp

Il prend un argument et retourne t si l'argument est un nombre réel sinon il retourne nil.

18

complexp

Il prend un argument et retourne t si l'argument est un nombre complexe sinon il retourne nil.

19

characterp

Il prend un argument et retourne t si l'argument est un caractère sinon il retourne nil.

20

stringp

Il prend un argument et retourne t si l'argument est un objet chaîne sinon il retourne nil.

21

arrayp

Il prend un argument et retourne t si l'argument est un objet tableau sinon il retourne nil.

22

packagep

Il prend un argument et retourne t si l'argument est un package sinon il retourne nil.

Exemple 1

Créez un nouveau fichier de code source nommé main.lisp et tapez le code suivant dedans.

(write (atom 'abcd))
(terpri)
(write (equal 'a 'b))
(terpri)
(write (evenp 10))
(terpri)
(write (evenp 7 ))
(terpri)
(write (oddp 7 ))
(terpri)
(write (zerop 0.0000000001))
(terpri)
(write (eq 3 3.0 ))
(terpri)
(write (equal 3 3.0 ))
(terpri)
(write (null nil ))

Lorsque vous exécutez le code, il renvoie le résultat suivant -

T
NIL
T
NIL
T
NIL
NIL
NIL
T

Exemple 2

Créez un nouveau fichier de code source nommé main.lisp et tapez le code suivant dedans.

(defun factorial (num)
   (cond ((zerop num) 1)
      (t ( * num (factorial (- num 1))))
   )
)
(setq n 6)
(format t "~% Factorial ~d is: ~d" n (factorial n))

Lorsque vous exécutez le code, il renvoie le résultat suivant -

Factorial 6 is: 720