# A Genetic Algorithm Implementation

Save this PDF as:

Size: px
Start display at page:

## Transcription

1 A Genetic Algorithm Implementation Roy M. Turner Spring 2017 Contents 1 Introduction 3 2 Header information 3 3 Class definitions Individual Population GA (genetic algorithm) Initialization after methods Variables Alphabets condition-string Defined alphabets UI variables Methods/functions get-alphabet random-genome Fitness computation methods compute-fitnesses compute-fitness sort-by-fitness status display best-fitness, average-fitness, worst-fitness genome-as-string reproduce crossover mutate choose? add-individuals fittest

2 6 User interface Computing fitness string-match-fitness Running the GA next-generation run Sample GA task: Learn a string Collect statistics Finding out what the answer is best-answer best-answers Another GA task: TSP City map

3 1 Introduction The file genetic-algorithm.lisp contains code for a simple genetic algorithm (GA), written using CLOS. It was written both to provide a genetic algorithm implementation to experiment with as well as to give an example of a reasonably complex Lisp program. The file is written as a literate programming file, with (in this case, L A TEX) documentation interleaved with the code. If you are interested in the program that converts back and forth from Lisp L A TEX, let me know. 2 Header information 1 (in-package cl-user) 3 Class definitions The program is structured using three CLOS classes: ga: the genetic algorithm object itself; population: an object holding the population of individuals; and individual: an object representing an individual solution. 3.1 Individual The individual class holds all the information needed to represent an individual in the population, that is, a candidate solution to the problem. Each has: id: the name of the individual size: length of the genome kind: the name of the alphabet the genome is drawn from fitness: the individual s current The size of the genome is set when the GA is set up, as is the kind of genome it is. Kind here refers to the alphabet that the elements of the genome are drawn from; see the description of the variable *alphabet-map* for the kinds of genomes supported and their names. The fitness is a number that is returned from the fitness function (see class ga). The genome of an individual can be considered a string of characters by the user. Internally, however, the string is converted (via the function condition-string) to a list of symbols internally. Each symbol corresponds to a letter in the string. For example: CL-USER> (condition-string "Hi there") (H i t h e r e ) The s in the symbol names mean that the symbol has special characters that are not usually part of symbol names, such as lower-case letters. 1 The function genome-as-string converts this list back to a nice-looking string. 1 These aren t usually found in symbol names if we are using a case-insensitive Lisp, as I usually do. 3

4 2 (defclass individual () 3 ( 4 (id :initform (intern (symbol-name (gensym "INDIV"))) :initarg :id :accessor id) 5 (size :initform 20 :initarg :size :accessor size) 6 (genome :initform nil :initarg :genome :accessor genome) 7 (kind :initform bitstring :initarg :kind :accessor kind) 8 (fitness :initform nil :initarg :fitness :accessor fitness) 9 ) 10 ) 3.2 Population The population class defines a population of individuals. It has instance variables: id: the name of the population individuals: a list of all individuals in the population size: the size of the population individual-size: the size of each individual s genome (see 3.2) individual-kind: the kind of each individual s genome (see 3.2) 11 (defclass population () 12 ( 13 (id :initform (intern (symbol-name (gensym "POP"))) :initarg :id :accessor id) 14 (individuals :initform nil :initarg :individuals :accessor individuals) 15 (size :initform 50 :initarg :size :accessor size) 16 (individual-size :initform 20 :initarg :individual-size :accessor individual-size) 17 (individual-kind :initform bitstring :initarg :individual-kind 18 :accessor individual-kind) 19 ) 20 ) 3.3 GA (genetic algorithm) The ga class holds methods and instance variables needed for the operation of the GA. Instance variables include: id: the name of the GA population: the population (an instance of population) mutation-rate: the rate of mutations; that is, how likely a mutation is during each reproduction event crossover-rate: the rate of crossovers; that is, how likely a crossover event is during each reproduction fitness-function: a function that is applied to the genome of an individual to determine that individual s fitness (a number) 4

5 individual-size: the size of an individual s genome population-size: the size of the population individual-kind: the kind of genome in use (see the individual class) breeding-pairs: the number of breeding pairs to select each generation silent: if t, then no status information is printed; this can speed up the execution of the GA The breeding-pairs instance variable is used to determine how many of the fittest individuals are selected to produce children for the next generation. Currently, the top 2n individuals, where n = breeding-pairs, are selected and paired off in order. This is a place where other choices could be tried to see if it makes any difference. The pair then create two children. See the method reproduce for information about how reproduction actually takes place. 21 (defclass ga () 22 ( 23 (id :initform (intern (symbol-name (gensym "GA"))) :initarg :id :accessor id) 24 (population :initform nil :initarg :population :accessor population) 25 (mutation-rate :initform 0.1 :initarg :mutation-rate :accessor mutation-rate) 26 (crossover-rate :initform 0.1 :initarg :crossover-rate :accessor crossover-rate) 27 (fitness-function :initform # (lambda (i) (random 1.0)) 28 :initarg :fitness-function :accessor fitness-function) 29 (individual-size :initform 20 :initarg :individual-size :accessor individual-size) 30 (population-size :initform 50 :initarg :population-size :accessor population-size) 31 (generation :initform 0 :initarg :generation :accessor generation) 32 (individual-kind :initform bitstring :initarg :individual-kind :accessor individual-kind 33 (breeding-pairs :initform 4 :initarg :breeding-pairs :accessor breeding-pairs) 34 (silent :initform nil :initarg :silent :accessor silent) 35 ) 36 ) 3.4 Initialization after methods Often in CLOS, it s useful to perform additional actions after an object is initialized by make-instance. Instead of calling a user-defined initialization function, it s cleaner in many cases to write an :after method for the built-in method initialize-instance, which is called as a result of calling make-instance. The :after method is called after the built-in method without the user having to do anything. We use the :after methods here to set up the population and individuals when ga is instantiated. 37 (defmethod initialize-instance :after ((instance ga) &rest args) 38 (declare (ignore args)) 39 (with-slots (population individual-size 40 population-size generation individual-kind) instance 41 (setq generation 0) 42 (setq population (make-instance population :size population-size 43 :individual-size individual-size 44 :individual-kind individual-kind)) 5

6 45 (compute-fitnesses instance) 46 ) 47 ) (defmethod initialize-instance :after ((instance population) &rest args) 50 (declare (ignore args)) 51 (with-slots (individuals individual-size size individual-kind) instance 52 (setq individuals (loop for ind from 1 to size 53 collect (make-instance individual :size individual-size 54 :kind individual-kind 55 ))))) (defmethod initialize-instance :after ((instance individual) &rest args) 58 (declare (ignore args)) 59 (with-slots (size genome kind) instance 60 (setq genome (or genome (random-genome instance size kind))))) 4 Variables 4.1 Alphabets We define several alphabets for you to use. You may define others; if you do, however, you will need to modify the get-alphabet function. Each alphabet is present as a genome-like list and is in a variable named *alphabet-xxxx*, where XXXX describes the alphabet. First, we define a function needed to convert strings into genomes condition-string As we described when discussing the individual class, this will take a string and return a properlyformed genome. A genome is represented as a list of symbols, each of which corresponds to a character in the string. Two versions of this are provided, one, which just returns its argument, for when the genome is already a list, and the other that actually converts the string to a genome. 61 (defmethod condition-string ((str list)) 62 str) 63 (defmethod condition-string ((str string)) 64 (map list # (lambda (a) (intern (string a))) 65 str)) Defined alphabets Here are the alphabets we have defined: Lower case letters: 66 (defvar *alphabet-lower-case* 67 (condition-string "abcdefghijklmnopqrstuvwxyz")) Upper case letters: 6

7 68 (defvar *alphabet-upper-case* 69 (condition-string "ABCDEFGHIJKLMNOPQRSTUVWXYZ")) Numerals 0 9: 70 (defvar *alphabet-numerals* 71 (condition-string " ")) The space character: 72 (defvar *alphabet-space* (condition-string " ")) Punctuation symbols: 73 (defvar *alphabet-punctuation* 74 (condition-string ":;.?!,-")) Special characters: 75 (defvar *alphabet-special* 76 (condition-string \}]{[ \"/><")) Bits (0, 1): 77 (defvar *alphabet-bitstring* 78 (condition-string "01")) The variable *alphabet-map* contains a mapping from labels to the corresponding alphabets. The format of each entry in the map is: (label(s) alphabet(s)) where the first element is a (keyword) label or list of labels and the remainder is a list of names of alphabet variables or labels. So, for example, (:uppercase *alphabet-upper-case*) maps the label :uppercase to the variable containing the uppercase letters, and (:alphanumeric :alphabet :numerals) maps the label :alphanumeric to the concatenation of the alphabets named :alphabet and :numerals. The function get-alphabet uses this map to produce alphabets for (e.g.) reproduction and instantiation of individuals. 7

8 79 (defvar *alphabet-map* 80 ( 81 ((:bitstring :bits :binary) *alphabet-bitstring*) 82 (:uppercase *alphabet-upper-case*) 83 (:lowercase *alphabet-lower-case*) 84 (:punctuation *alphabet-punctuation*) 85 (:numerals *alphabet-numerals*) 86 (:special-chars *alphabet-special*) 87 (:alphabet+space :alphabet *alphabet-space*) 88 ((:letters :alphabet) :uppercase :lowercase) 89 (:alphanumeric :alphabet :numerals) 90 (:alphanumeric+space :alphabet+space :numerals) 91 (:all :alphanumeric+space :punctuation :special-chars) 92 ) 93 ) 4.2 UI variables The user interface, at the moment consisting of just a few functions (see Section 6), stores the target string, the GA instance, and some execution statistics in these variables 94 (defvar *target* (T h i s space i s space a space t e s t)) 95 (defvar *ga* nil) 96 (defvar *stats* nil) 5 Methods/functions 5.1 get-alphabet This uses the *alphabet-map* variable to find an alphabet based on a label; see that variable s description to see the valid alphabets. The label can be a symbol or a keyword. The alphabet is returned in the form of a genome, and it has been copied so that no modifications will affect the base alphabets themselves. 97 (defun get-alphabet (label) 98 (unless (keywordp label) 99 (setq label (intern (symbol-name label) keyword))) 100 (labels ((compose-alphabets (alphabets) 101 (cond 102 ((null alphabets) nil) 103 ((keywordp (car alphabets)) 104 (append (get-alphabet (car alphabets)) 105 (compose-alphabets (cdr alphabets)))) 106 (t 107 (append (eval (car alphabets)) 108 (compose-alphabets (cdr alphabets))))))) 109 (let ((alphabets (cdr (assoc label *alphabet-map* 110 :test # (lambda (a b) 111 (if (listp b) 8

9 112 (member a b) 113 (eql a b))))))) 114 (when (setq alphabets (compose-alphabets alphabets)) 115 (copy-list alphabets))))) 5.2 random-genome This returns a random genome of size size composed of characters drawn from the alphabet kind, which defaults bitstring. 116 (defmethod random-genome ((self individual) size &optional (kind bitstring)) 117 (let ((alphabet (if (consp kind) kind (get-alphabet kind)))) 118 (loop with len = (length alphabet) 119 for i from 1 to size 120 collect 121 (nth (random len) alphabet)))) 5.3 Fitness computation methods These compute the fitness of individuals based on a fitness function, contained in the GA instance compute-fitnesses These two methods, one for ga instances and one for population instances, together compute the fitness of all the individuals in the GA. 122 (defmethod compute-fitnesses ((self ga) &key fcn &allow-other-keys) 123 (with-slots (population fitness-function) self 124 (compute-fitnesses population :fitness-function (or fcn fitness-function)))) (defmethod compute-fitnesses ((self population) &key fitness-function &allow-other-keys) 128 (with-slots (individuals) self 129 (loop for indiv in individuals 130 do (compute-fitness indiv fitness-function)) 131 (sort-by-fitness self))) compute-fitness This applies a fitness function to the individual s genome. It updates the individual s fitness instance variable. There are two versions, one for an individual instance, and one for a genome; the former calls the latter. 132 (defmethod compute-fitness ((self individual) fcn) 133 (with-slots (fitness genome) self 134 (setq fitness (compute-fitness genome fcn)))) (defmethod compute-fitness ((genome list) fcn) 137 (funcall fcn genome)) 9

10 5.3.3 sort-by-fitness This method (of population) sorts all of a population s individuals by their fitness, with the best individuals first. 138 (defmethod sort-by-fitness ((self population)) 139 (with-slots (individuals) self 140 (setq individuals (sort individuals # (lambda (a b) 141 (> (fitness a) (fitness b))))))) 5.4 status This prints the status of ga to the screen. 142 (defmethod status ((self ga)) 143 (with-slots (generation silent) self 144 (unless silent 145 (format t 146 "~&Generation ~s: fitness (b/a/w) = ~,2f/~,2f/~,2f, best answer=~s~%" 147 generation (best-fitness self) (average-fitness self) 148 (worst-fitness self) 149 (car (best-answers self 1)))))) 5.5 display The display generic function and its methods (one each for ga, population, and individual) show the GA and its pieces in a nice form for the user. If :individuals-too? is specified for the population or GA version, then all the individuals are displayed as well. 150 (defmethod display ((self individual) &key (stream t)) 151 (with-slots (id fitness genome) self 152 (format stream "~&~2T~s (fitness=~,2f)~15t~s~%" 153 id fitness (genome-as-string self)))) (defmethod display ((self population) &key (stream t) (individuals-too? nil)) 156 (with-slots (id individuals size individual-size individual-kind) self 157 (format stream "~&~2T~s: ~s individuals with ~s genomes~%" 158 id size individual-kind) 159 (format stream "~5THighest/average/lowest fitness:~,2f/~,2f/~,2f~%" 160 (fitness (car individuals)) 161 (average-fitness self) 162 (fitness (car (last individuals)))) 163 (when individuals-too? 164 (mapcar # display individuals)))) (defmethod display ((self ga) &key (stream t) (individuals-too? nil)) 167 (with-slots (population id mutation-rate crossover-rate generation breeding-pairs) self 168 (format stream "~&GA program ~s:~%" id) 169 (format stream "~& Current generation: ~s~%" generation) 10

11 170 (format stream "~& Mutation rate: ~s~%" mutation-rate) 171 (format stream "~& Crossover-rate: ~s~%" crossover-rate) 172 (format stream "~& # breeding pairs: ~s~%" breeding-pairs) 173 (format stream "~& Population:~%") 174 (display population :stream stream :individuals-too? individuals-too?))) 5.6 best-fitness, average-fitness, worst-fitness These generic functions and their methods (for population, ga, individual) return the best, average, and worst fitnesses in the population. 175 (defmethod best-fitness ((self ga)) 176 (with-slots (population) self 177 (best-fitness population))) (defmethod worst-fitness ((self ga)) 180 (with-slots (population) self 181 (worst-fitness population))) (defmethod best-fitness ((self population)) 184 (with-slots (individuals) self 185 (fitness (car individuals)))) (defmethod worst-fitness ((self population)) 188 (with-slots (individuals) self 189 (fitness (car (last individuals))))) (defmethod average-fitness ((self ga)) 192 (with-slots (population) self 193 (average-fitness population))) (defmethod average-fitness ((self population)) 196 (with-slots (individuals size) self 197 (float (/ (apply # + (mapcar # fitness individuals)) size)))) 5.7 genome-as-string This takes a genome (a list) and converts the symbols back into characters and concatenates them. This make is much easier for the user to read. 198 (defmethod genome-as-string ((self individual) &key genome-list) 199 (with-slots (genome) self 200 (apply # concatenate (cons string (mapcar # symbol-name (or genome-list genome)))))) 5.8 reproduce These methods of the generic function reproduce together take two individuals and return two children (as two separate values). With probability crossover-rate, the genomes of the parents will be crossed over at some random point to create the children; with probability mutation-rate, 11

12 one or both of the children will suffer a random mutation. If no mutation or crossover occurs, the children are copies of the parents. 201 (defmethod reproduce ((p1 individual) (p2 individual) &key mutation-rate 202 crossover-rate alphabet) 203 (multiple-value-bind (ng1 ng2) 204 (reproduce (genome p1) (genome p2) :mutation-rate mutation-rate 205 :crossover-rate crossover-rate 206 :alphabet alphabet) 207 (values (make-instance individual :genome ng1 208 :size (size p1) :kind (kind p1)) 209 (make-instance individual :genome ng2 210 :size (size p1) :kind (kind p1))))) (defmethod reproduce ((g1 list) (g2 list) &key mutation-rate crossover-rate alphabet) 213 (when (symbolp alphabet) 214 (setq alphabet (get-alphabet alphabet))) 215 (setq g1 (copy-list g1) 216 g2 (copy-list g2)) 217 (when (choose? crossover-rate) 218 (multiple-value-setq (g1 g2) (crossover g1 g2))) 219 (when (choose? mutation-rate) 220 (setq g1 (mutate g1 alphabet))) 221 (when (choose? mutation-rate) 222 (setq g2 (mutate g2 alphabet))) 223 (values g1 g2)) 5.9 crossover The crossover method picks a random spot and crosses over two genomes: i.e., from that point on, the genomes of the two are switched. The method returns the genomes as two values. 224 (defmethod crossover ((a list) (b list)) 225 (let ((position (1+ (random (1- (length a))))) 226 kids) 227 (setq kids 228 (loop for counter from 1 to (length a) 229 for i in a 230 for j in b 231 when (>= counter position) 232 collect (list i j) 233 else 234 collect (list j i))) 235 (values (mapcar # car kids) 236 (mapcar # cadr kids)))) 12

13 5.10 mutate This method will mutate a genome by replacing a character at a random position by a random character from the alphabet the genome is composed of. 237 (defmethod mutate ((genome list) alphabet) 238 (setf (nth (random (length genome)) genome) 239 (nth (random (length alphabet)) alphabet)) 240 genome) 5.11 choose? This function takes a probability and returns t with that probability. 241 (defun choose? (probability) 242 (<= (random 1.0) probability)) 5.12 add-individuals Add the new individuals to the population. This then sorts the list of individuals by decreasing fitness. (Probably not the most efficient way I could have done this; I ll maybe change it later to insert rather than sort.) 243 (defmethod add-individuals ((self population) new) 244 (with-slots (individuals size) self 245 (setq individuals (append new individuals)) 246 (sort-by-fitness self) 247 (setq individuals (fittest self size)))) 5.13 fittest This returns the n fittest individuals in the population as a list. 248 (defmethod fittest ((self ga) &optional (n 1)) 249 (with-slots (population) self 250 (fittest population n))) (defmethod fittest ((self population) &optional (n 1)) 253 (with-slots (individuals) self 254 (loop for i from 1 to n 255 for indiv in individuals 256 collect indiv))) 6 User interface There are several functions the user can use to set up and run a genetic algorithm. One way, of course, is to create a ga instance using make-instance, then run it using the run method. For complex problems (e.g., learning a traveling salesperson task, etc.), this is probably the best thing to do. However, we provide a simple interface here for learning strings. The learn-string function creates a ga instance, stores it in the variable *GA*, and runs the GA. 13

14 6.1 Computing fitness You can define your own fitness functions, of course. Each should take one argument, a genome, and return a number. Other than that, there are no restrictions on what kinds of functions you can have. We have provided one for the learn-string function (below): string-match-fitness The string-match-fitness function simply counts the number of correct letters. Probably the GA s hill-climbing could be made more efficient by changing this to take into account how close the letters are to the target s and using the order of the letters in the alphabet. 257 (defun string-match-fitness (i) 258 (count t (mapcar # eql i *target*))) 6.2 Running the GA next-generation This method does the bulk of the GA s work. It is called by run repeatedly to evolve the GA. Each call, next-generation selects the fittest n individuals (as specified by the ga instance s breeding-pairs instance variable) and lets pairs of them reproduce. The children are added to the list of individuals, then the list is sorted and the best are kept (as specified by the population s size instance variable). 259 (defmethod next-generation ((self ga)) 260 (with-slots (population generation fitness-function breeding-pairs 261 crossover-rate mutation-rate individual-kind) self 262 (let ((pairs (fittest population (* 2 breeding-pairs)))) 263 (loop with c1 264 with c2 265 for i from 0 to breeding-pairs by do (multiple-value-setq (c1 c2) 267 (reproduce (nth i pairs) (nth (1+ i) pairs) 268 :crossover-rate crossover-rate 269 :mutation-rate mutation-rate 270 :alphabet individual-kind)) 271 (compute-fitness c1 fitness-function) 272 (compute-fitness c2 fitness-function) 273 (add-individuals population (list c1 c2)) 274 ) 275 (incf generation) 276 ))) run The primary method for running the GA is just called run. It takes one positional argument, the ga instance, and several keyword arguments: :for - if set, run for this many generations, then stop 14

15 :until-best-fitness - if set, run until the fitness of the best individual is this :until-average-fitness - if set, run until the average fitness of the population is this :until-generation - if set, run until this generation :recompute-fitness? - if set, recompute the fitness of all the individuals each generation; this would be useful, for example, if the situation is changing such that the fitnesses are likely to change :file - a filename to hold the data generated by the run :status-every - if set, print the status only one every this many generations Data is written to the file in the form: generation# best-fitness average-fitness worst-fitness fittest-genome Careful, though, since this will overwrite any old file of the same name. 277 (defmethod run ((self ga) &key until-best-fitness until-average-fitness 278 for until-generation recompute-fitness? (file "ga-results.dat") 279 (status-every 50)) 280 (with-open-file (out file :direction :output 281 :if-exists :supersede 282 :if-does-not-exist :create) 283 (with-slots (generation silent) self 284 (loop with status-counter = status-every 285 do (next-generation self) 286 (when recompute-fitness? 287 (compute-fitnesses self)) 288 (format out "~s ~s ~s ~s ~s~%" 289 generation (best-fitness self) 290 (average-fitness self) 291 (worst-fitness self) 292 (genome-as-string (car (fittest self 1))) 293 ) 294 (when (or (null status-counter) 295 (zerop status-counter)) 296 (status self) 297 (when status-counter 298 (setq status-counter status-every))) 299 (when for (decf for)) 300 (when status-counter (decf status-counter)) 301 until (or (and until-best-fitness (>= (best-fitness self) until-best-fitness)) 302 (and until-average-fitness (>= (average-fitness self) until-average-fitness)) 303 (and until-generation (>= generation until-generation)) 304 (and for (zerop for)))) 305 (unless silent 306 (format t "Run complete:") 307 (status self)) 308 (values (best-answer self) generation)))) 15

16 6.3 Sample GA task: Learn a string The learn-string function is used to create a GA and learn a string. It takes one positional argument, the string to be learned (as a string, which is converted to genome form), and several keyword arguments: :individual-kind - the kind of individual (genome); defaults to :alphanumeric+space :until-best-fitness - if set, the GA will run until the best fitness this value :until-average-fitness - if set, the GA will run until the average fitness this value :for - if set, the GA will run for this many generations :until-generation - if set, the GA will run until this generation is reached :status-every - this determines how often a status message is printed (default is every 50 generations) :breeding-pairs - how many breeding pairs to use (default 4) :mutation-rate - the mutation rate (0.1) :crossover-rate - the crossover rage (0.1) :population-size - the size of the population (50) :silent - if set, no there are no status messages (default is nil) :file - data is written to this file (default is learn-string-results.dat ) in the form described in the discussion of run. 309 (defun learn-string (string &key (individual-kind :alphanumeric+space) 310 until-best-fitness until-average-fitness 311 for until-generation 312 (file "learn-string-results.dat") 313 (status-every 50) 314 (breeding-pairs 4) 315 (mutation-rate 0.1) 316 (crossover-rate 0.1) 317 (population-size 50) 318 (silent nil) 319 (fitness-function # string-match-fitness)) (setq *target* (condition-string string)) (setq *ga* (make-instance ga 324 :breeding-pairs breeding-pairs 325 :mutation-rate mutation-rate 326 :crossover-rate crossover-rate 327 :population-size population-size 328 :individual-size (length *target*) 16

17 329 :individual-kind individual-kind 330 :fitness-function fitness-function 331 :silent silent)) (run *ga* :status-every status-every :file file 334 :until-generation until-generation 335 :until-best-fitness (or until-best-fitness (length string)) 336 :until-average-fitness until-average-fitness 337 :for for)) 6.4 Collect statistics The stats function takes a string and runs learn-string on substrings of it iterations times each, from 2 to the length of the string, collecting the average of the generations needed fro each substring. The stats are put into *stats*. The kind argument determines the kind of alphabet to use. (I should probably have this generate random strings for this in future.) 338 (defun stats (string &key (iterations 10) (kind :all)) 339 (setq *stats* nil) 340 (format t "~%") 341 (loop for i from 2 to (length string) 342 do (format t "~s" i) 343 (loop 344 for j from 1 to iterations 345 collect (multiple-value-bind (val gens) 346 (learn-string (subseq string (- (length string) i)) 347 :until-best-fitness i 348 :silent t 349 :individual-kind kind) 350 (format t ".") 351 gens) 352 into sum 353 finally (push (list i (float (/ (apply # + sum) iterations))) *stats*)) 354 finally (setq *stats* (reverse *stats*))) 355 (loop for run in *stats* 356 do (format t "~&~s~10t~,2f~%" (car run) (cadr run))) 357 *stats*) 6.5 Finding out what the answer is best-answer This returns the best answer (i.e., the genome of the fittest individual). 358 (defmethod best-answer ((self ga)) 359 (car (best-answers self 1))) (defmethod best-answers ((self ga) &optional (n 1) (as-strings? t)) 362 (with-slots (population) self 363 (best-answers population n as-strings?))) 17

18 6.5.2 best-answers This returns the n best answers at the current time. If as-strings? is set, then the genomes are translated to strings before being returned. 364 (defmethod best-answers ((self population) &optional (n 1) (as-strings? t)) 365 (with-slots (individuals) self 366 (loop 367 for i from 1 to n 368 collect (if (not as-strings?) 369 (genome (nth (1- i) individuals)) 370 (genome-as-string (nth (1- i) individuals))) 371 into ba 372 collect (fitness (nth (1- i) individuals)) into bf 373 finally (return (values ba bf))))) 6.6 Another GA task: TSP The Traveling Salesperson Problem (TSP) is a well-known NP-hard problem. Here, we will attempt to solve it with a GA. The task is to find the shortest route through a group of cities, visiting each city only once and ending up at the start city. The model uses (usually) a complete graph, though we can add extremely long (or infinite) paths between cities that don t have a real connection. We ll model the cities as a simple list of the form: ((a b 15) (b c 20)...) etc., meaning that the route from city a to city b is 15 units, etc. We assume a undirected graph. To convert this into a GA, we ll simply use a letter per city and let a string represent a path. Thus for 4 cities, a path might be: "abcda" representing starting at city a, going to b, c, and d, then back to a. The fitness function will compute the cost, and the GA will try to minimize that cost. Note that this inverts the sense of fitness. Thus, we ll make the costs negative, so that as we reduce the costs, we really get closer to 0, and so the fitness can be in the usual, increasing, sense City map 1. generate-tsp First, a function that will generate a random TSP problem given the number of cities and min and max link costs. 374 (defun generate-tsp (n mincost maxcost) 375 (let ((possible (loop for city in *alphabet-upper-case* 376 for i from 1 to n 377 collect city))) 378 (labels ((paths (city rest min max) 379 (cond 18

19 380 ((null rest) nil) 381 (t (append (loop for other in rest 382 collect (list city other (+ min (random (- max min))))) 383 (paths (car rest) (cdr rest) min max)))))) 384 (paths (car possible) (cdr possible) mincost maxcost)))) 2. *tsp* Now, a variable to hold the newly-created TSP. 385 (defvar *tsp* (generate-tsp )) 3. solve-tsp This function uses learn-string in order to solve a TSP. The fitness function is defined below. 386 (defun solve-tsp (&key tsp (n 5) (min 1) (max 10) 387 (individual-kind :alphanumeric+space) 388 until-best-fitness until-average-fitness 389 for until-generation 390 (file "learn-string-results.dat") 391 (status-every 50) 392 (breeding-pairs 4) 393 (mutation-rate 0.1) 394 (crossover-rate 0.1) 395 (population-size 50) 396 (silent nil) 397 ga) (setq *tsp* 400 (if tsp 401 tsp 402 (setq tsp (generate-tsp n min max)))) (let ((cities (remove-duplicates (apply # append 405 (mapcar # (lambda (a) 406 (list (car a) (cadr a))) 407 tsp))))) 408 (unless ga 409 (setq *ga* (make-instance ga 410 :breeding-pairs breeding-pairs 411 :individual-kind (copy-list cities) 412 :individual-size (1+ (length cities)) 413 :breeding-pairs breeding-pairs 414 :mutation-rate mutation-rate 415 :crossover-rate crossover-rate 416 :population-size population-size 417 :silent silent 19

20 418 :fitness-function # tsp-fitness-function 419 ))) (run *ga* :status-every status-every :file file 422 :until-generation until-generation 423 :until-best-fitness until-best-fitness 424 :until-average-fitness until-average-fitness 425 :for for))) 4. tsp-fitness-function This simply calculates the cost of the current path and returns it as a negative number. Thus shorter paths will be less negative, hence fitter. If a path does not begin and end at the same place, then it s penalized, as it is if a city occurs more than once (other than start and end). 426 (defvar *tsp-non-circuit-penalty* most-positive-fixnum) 427 (defvar *tsp-duplicate-city-penalty* most-positive-fixnum) (defun tsp-fitness-function (path) 430 (cond 431 ((not (eql (car path) (car (last path)))) 432 (- *tsp-non-circuit-penalty*)) 433 ((< (length (remove-duplicates path)) (1- (length path))) 434 (- *tsp-duplicate-city-penalty*)) 435 (t 436 (- (path-cost path *tsp*))))) (defun path-cost (path &optional (tsp *tsp*)) 440 (cond 441 ((< (length path) 2) 0) 442 (t (+ (segment-cost (car path) (cadr path) tsp) 443 (path-cost (cdr path) tsp))))) (defun segment-cost (a b &optional (tsp *tsp*)) 446 (or (third (car (member (list a b) tsp 447 :test # (lambda (target candidate) 448 (or (and (eql (car target) (car candidate)) 449 (eql (cadr target) (cadr candidate))) 450 (and (eql (car target) (cadr candidate)) 451 (eql (cadr target) (car candidate)))))))) 452 most-positive-fixnum)) 20

21 Index *TSP* (variable), 19 *alphabet-bitstring* (variable), 7 *alphabet-lower-case* (variable), 6 *alphabet-map* (variable), 7 *alphabet-numerals* (variable), 7 *alphabet-punctuation* (variable), 7 *alphabet-space* (variable), 7 *alphabet-special* (variable), 7 *alphabet-upper-case* (variable), 6 *ga* (variable), 8 *stats* (variable), 8 *target* (variable), 8 *tsp-duplicate-city-penalty* (variable), 20 *tsp-non-circuit-penalty* (variable), 20 reproduce (method), 11 run (method), 15 segment-cost (function), 20 solve-tsp (function), 19 sort-by-fitness (method), 10 stats (function), 17 status (method), 10 string-match-fitness (function), 14 tsp-fitness-function (function), 20 worst-fitness (method), 11 add-individuals (method), 13 average-fitness (method), 11 best-answer (method), 17 best-answers (method), 18 best-fitness (method), 11 choose? (function), 13 compute-fitness (method), 9 compute-fitnesses (method), 9 condition-string (method), 6 crossover (method), 12 display (method), 10 fittest (method), 13 ga (class), 4 generate-tsp (function), 18 genome-as-string (method), 11 get-alphabet (function), 8 individual (class), 3 learn-string (function), 16 mutate (method), 13 next-generation (method), 14 path-cost (function), 20 population (class), 4 random-genome (method), 9 21

### Object Oriented Programming (OOP)

Object Oriented Programming (OOP) o New programming paradigm o Actions Objects o Objects Actions o Object-oriented = Objects + Classes + Inheritance Imperative programming o OOP (Object-Oriented Programming)

### Common Lisp. Blake McBride

Contents Common Lisp Blake McBride (blake@mcbride.name) 1 Data Types 2 2 Numeric Hierarchy 3 3 Comments 3 4 List Operations 4 5 Evaluation and Quotes 5 6 String Operations 5 7 Predicates 6 8 Math Predicates

### Common LISP-Introduction

Common LISP-Introduction 1. The primary data structure in LISP is called the s-expression (symbolic expression). There are two basic types of s-expressions: atoms and lists. 2. The LISP language is normally

### 1 CLWEB INTRODUCTION 1

1 CLWEB INTRODUCTION 1 1. Introduction. This is CLWEB, a literate programming system for Common Lisp by Alex Plotnick plotnick@cs.brandeis.edu. It is modeled after the CWEB system by Silvio Levy and Donald

### Lecture Notes on Lisp A Brief Introduction

Why Lisp? Lecture Notes on Lisp A Brief Introduction Because it s the most widely used AI programming language Because Prof Peng likes using it Because it s good for writing production software (Graham

### Symbolic Programming. Dr. Zoran Duric () Symbolic Programming 1/ 89 August 28, / 89

Symbolic Programming Symbols: +, -, 1, 2 etc. Symbolic expressions: (+ 1 2), (+ (* 3 4) 2) Symbolic programs are programs that manipulate symbolic expressions. Symbolic manipulation: you do it all the

### Announcement. Overview. LISP: A Quick Overview. Outline of Writing and Running Lisp.

Overview Announcement Announcement Lisp Basics CMUCL to be available on sun.cs. You may use GNU Common List (GCL http://www.gnu.org/software/gcl/ which is available on most Linux platforms. There is also

### Object oriented programming

Object oriented programming The main ideas behind object-oriented programming: the same type of action may be carried out differently on different types of objects cutting a cake is different from cutting

### CS 480. Lisp J. Kosecka George Mason University. Lisp Slides

CS 480 Lisp J. Kosecka George Mason University Lisp Slides Symbolic Programming Symbols: +, -, 1, 2 etc. Symbolic expressions: (+ 1 2), (+ (* 3 4) 2) Symbolic programs are programs that manipulate symbolic

### Lisp: Question 1. Dr. Zoran Duric () Midterm Review 1 1/ 13 September 23, / 13

Lisp: Question 1 Write a recursive lisp function that takes a list as an argument and returns the number of atoms on any level of the list. For instance, list (A B (C D E) ()) contains six atoms (A, B,

### 19 Machine Learning in Lisp

19 Machine Learning in Lisp Chapter Objectives Chapter Contents ID3 algorithm and inducing decision trees from lists of examples. A basic Lisp implementation of ID3 Demonstration on a simple credit assessment

### LISP. Everything in a computer is a string of binary digits, ones and zeros, which everyone calls bits.

LISP Everything in a computer is a string of binary digits, ones and zeros, which everyone calls bits. From one perspective, sequences of bits can be interpreted as a code for ordinary decimal digits,

### CIS4/681 { Articial Intelligence 2 > (insert-sort '( )) ( ) 2 More Complicated Recursion So far everything we have dened requires

1 A couple of Functions 1 Let's take another example of a simple lisp function { one that does insertion sort. Let us assume that this sort function takes as input a list of numbers and sorts them in ascending

### Literate Programming in Lisp (LP/Lisp)

Literate Programming in Lisp (LP/Lisp) Roy M. Turner Technical Report 2010 2 Department of Computer Science University of Maine Orono, ME 04469 Contents 1 1 Introduction This document describes LP/Lisp

### (defmacro while (condition &body body) `(iterate loop () (if,condition (loop)))))

; PARCIL - A Parser for C syntax In Lisp version 0.1a copyright (c) 1992 by Erann Gat, all rights reserved This program is free software; you can redistribute it and/or modify it under the terms of the

### (defvar *state* nil "The current state: a list of conditions.")

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; GPS engine for blocks world ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (defvar *dbg-ids* nil "Identifiers used by dbg") (defvar *state* nil "The current state: a list of conditions.")

### Artificial Intelligence Programming

Artificial Intelligence Programming Rob St. Amant Department of Computer Science North Carolina State University Lisp basics NC State University 2 / 99 Why Lisp? Some recent Lisp success stories include

### A Quick Introduction to Common Lisp

CSC 244/444 Notes last updated ug. 30, 2016 Quick Introduction to Common Lisp Lisp is a functional language well-suited to symbolic I, based on the λ-calculus and with list structures as a very flexible

### Lecture #2 Kenneth W. Flynn RPI CS

Outline Programming in Lisp Lecture #2 Kenneth W. Flynn RPI CS Items from last time Recursion, briefly How to run Lisp I/O, Variables and other miscellany Lists Arrays Other data structures Jin Li lij3@rpi.edu

### MIDTERM EXAMINATION - CS130 - Spring 2005

MIDTERM EAMINATION - CS130 - Spring 2005 Your full name: Your UCSD ID number: This exam is closed book and closed notes Total number of points in this exam: 231 + 25 extra credit This exam counts for 25%

### Custom Specializers in Object-Oriented Lisp

Custom Cadence Design Systems Goldsmiths, University of London 23rd May 2008 Common : Skill: Unification of various dialects; Not dead yet. Common Skill Internal dialect from Cadence Design Systems; Extension

### Functional Programming. Pure Functional Languages

Functional Programming Pure functional PLs S-expressions cons, car, cdr Defining functions read-eval-print loop of Lisp interpreter Examples of recursive functions Shallow, deep Equality testing 1 Pure

### SCHEME 7. 1 Introduction. 2 Primitives COMPUTER SCIENCE 61A. October 29, 2015

SCHEME 7 COMPUTER SCIENCE 61A October 29, 2015 1 Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme programs,

### Allegro CL Certification Program

Allegro CL Certification Program Lisp Programming Series Level I Review David Margolies 1 Summary 1 A lisp session contains a large number of objects which is typically increased by user-created lisp objects

### Important Example: Gene Sequence Matching. Corrigiendum. Central Dogma of Modern Biology. Genetics. How Nucleotides code for Amino Acids

Important Example: Gene Sequence Matching Century of Biology Two views of computer science s relationship to biology: Bioinformatics: computational methods to help discover new biology from lots of data

### CL-STORE: CL Serialization Package

CL-STORE: CL Serialization Package Copyright c (c) (C) 2004 Sean Ross All rights reserved. Redistribution and use in source and binary forms, with or without modication, are permitted provided that the

### STREAMS 10. Basics of Streams. Practice with Streams COMPUTER SCIENCE 61AS. 1. What is a stream? 2. How does memoization work?

STREAMS 10 COMPUTER SCIENCE 61AS Basics of Streams 1. What is a stream? 2. How does memoization work? 3. Is a cons-stream a special form? Practice with Streams 1. Define a procedure (ones) that, when run

### Problems 3-1, 3.3, 3.4 and 3.5 in Chapter 3 of Winston and Horn's LISP (see Below)

Homework Solutions: Problem Set Homework 2 Due uesday September 8, 2015 in class Be sure to follow the guidelines for Programming Assignments. Since these problems are simple, you may skip the Statement

### Introduction to Lisp

Last update: February 16, 2010 Introduction to Lisp Dana Nau Dana Nau 1 Outline I assume you know enough about computer languages that you can learn new ones quickly, so I ll go pretty fast If I go too

### Scheme. Functional Programming. Lambda Calculus. CSC 4101: Programming Languages 1. Textbook, Sections , 13.7

Scheme Textbook, Sections 13.1 13.3, 13.7 1 Functional Programming Based on mathematical functions Take argument, return value Only function call, no assignment Functions are first-class values E.g., functions

### 2. Reasons for implementing clos-unit

A CLOS Implementation of the JUnit Testing Framework Architecture: A Case Study Sandro Pedrazzini Canoo Engineering AG sandro.pedrazzini@canoo.com Abstract There are different reasons why you would like

### GENETIC ALGORITHM with Hands-On exercise

GENETIC ALGORITHM with Hands-On exercise Adopted From Lecture by Michael Negnevitsky, Electrical Engineering & Computer Science University of Tasmania 1 Objective To understand the processes ie. GAs Basic

### STREAMS 10. Basics of Streams. Practice with Streams COMPUTER SCIENCE 61AS. 1. What is a stream?

STREAMS 10 COMPUTER SCIENCE 61AS Basics of Streams 1. What is a stream? A stream is an element and a promise to evaluate the rest of the stream. Streams are a clever idea that allows one to use sequence

### Functional Programming. Pure Functional Languages

Functional Programming Pure functional PLs S-expressions cons, car, cdr Defining functions read-eval-print loop of Lisp interpreter Examples of recursive functions Shallow, deep Equality testing 1 Pure

### Intro. Scheme Basics. scm> 5 5. scm>

Intro Let s take some time to talk about LISP. It stands for LISt Processing a way of coding using only lists! It sounds pretty radical, and it is. There are lots of cool things to know about LISP; if

### CS61A Notes 02b Fake Plastic Trees. 2. (cons ((1 a) (2 o)) (3 g)) 3. (list ((1 a) (2 o)) (3 g)) 4. (append ((1 a) (2 o)) (3 g))

CS61A Notes 02b Fake Plastic Trees Box and Pointer Diagrams QUESTIONS: Evaluate the following, and draw a box-and-pointer diagram for each. (Hint: It may be easier to draw the box-and-pointer diagram first.)

### Principles of Programming Languages Topic: Functional Programming Professor L. Thorne McCarty Spring 2003

Principles of Programming Languages Topic: Functional Programming Professor L. Thorne McCarty Spring 2003 CS 314, LS, LTM: Functional Programming 1 Scheme A program is an expression to be evaluated (in

### CS 842 Ben Cassell University of Waterloo

CS 842 Ben Cassell University of Waterloo Recursive Descent Re-Cap Top-down parser. Works down parse tree using the formal grammar. Built from mutually recursive procedures. Typically these procedures

### Functional programming techniques

Functional programming techniques o Currying o Continuations o Streams. Lazy evaluation Currying o Haskell B. Curry. o Second-order programming: o Functions that return other functions. o Example: A two-arguments

### AllegroCache. Reference Manual. Franz Inc. version 3.1.2

AllegroCache Reference Manual Franz Inc. version 3.1.2 AllegroCache 3.1.0 2 Table of Contents Introduction...3 Package...3 Creating persistent objects...3 Indexes...5 Maps...5 Sets...6 Transactions...7

### regsim.scm ~/umb/cs450/ch5.base/ 1 11/11/13

1 File: regsim.scm Register machine simulator from section 5.2 of STRUCTURE AND INTERPRETATION OF COMPUTER PROGRAMS This file can be loaded into Scheme as a whole. Then you can define and simulate machines

### ;;; Determines if e is a primitive by looking it up in the primitive environment. ;;; Define indentation and output routines for the output for

Page 1/11 (require (lib "trace")) Allow tracing to be turned on and off (define tracing #f) Define a string to hold the error messages created during syntax checking (define error msg ""); Used for fancy

### Fall 2017 Discussion 7: October 25, 2017 Solutions. 1 Introduction. 2 Primitives

CS 6A Scheme Fall 207 Discussion 7: October 25, 207 Solutions Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write

### Spring 2018 Discussion 7: March 21, Introduction. 2 Primitives

CS 61A Scheme Spring 2018 Discussion 7: March 21, 2018 1 Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme

### Garbage In/Garbage SIGPLAN Out

Garbage In/Garbage SIGPLAN Out The COMFY 6502 Compiler Author: Henry G. Baker, http://home.pipeline.com/ hbaker1/home.html; hbaker1@pipeline.com Last June [Baker97], we described the COMFY language which

### NST: A Unit Test Framework for Common Lisp

Smart Information Flow Technologies (SIFT, LLC) TC-lispers, June 9, 2009 Outline 1 Unit testing 2 3 The basic idea Early implementations, and other lessons How it maybe should work 4 What is unit testing?

XLISP: An Object-oriented Lisp Version 2.0 February 6, 1988 by David Michael Betz 127 Taylor Road Peterborough, NH 03458 (603) 924-6936 (home) Copyright (c) 1988, by David Michael Betz All Rights Reserved

### Robot Programming with Lisp

4. Functional Programming: Higher-order Functions, Map/Reduce, Lexical Scope Institute for Artificial University of Bremen 9 of November, 2017 Functional Programming Pure functional programming concepts

### Scheme: Strings Scheme: I/O

Scheme: Strings Scheme: I/O CS F331 Programming Languages CSCE A331 Programming Language Concepts Lecture Slides Wednesday, April 5, 2017 Glenn G. Chappell Department of Computer Science University of

### UMBC CMSC 331 Final Exam Section 0101 December 17, 2002

0 / 0 1 / 20 UMBC CMSC 331 Final Exam Section 0101 December 17, 2002 Name: Student ID#: 2 / 25 3 / 20 4 / 25 5 / 20 6 /40 7 /40 You will have two hours to complete this closed book exam. We reserve the

### Using a waiting protocol to separate concerns in the mutual exclusion problem

Using a waiting protocol to separate concerns in the mutual exclusion problem Frode V. Fjeld frodef@cs.uit.no Department of Computer Science, University of Tromsø Technical Report 2003-46 November 21,

### Scheme Quick Reference

Scheme Quick Reference COSC 18 Fall 2003 This document is a quick reference guide to common features of the Scheme language. It is not intended to be a complete language reference, but it gives terse summaries

### ALISP interpreter in Awk

ALISP interpreter in Awk Roger Rohrbach 1592 Union St., #94 San Francisco, CA 94123 January 3, 1989 ABSTRACT This note describes a simple interpreter for the LISP programming language, written in awk.

### Meet the Macro. a quick introduction to Lisp macros. Patrick Stein / TC Lisp Users Group /

Meet the Macro a quick introduction to Lisp macros Patrick Stein / TC Lisp Users Group / 2009-07-14 Attack Plan Some other things called macros First look at Lisp macros More advanced macros Uh-oh, my

### Interpreters and Tail Calls Fall 2017 Discussion 8: November 1, 2017 Solutions. 1 Calculator. calc> (+ 2 2) 4

CS 61A Interpreters and Tail Calls Fall 2017 Discussion 8: November 1, 2017 Solutions 1 Calculator We are beginning to dive into the realm of interpreting computer programs that is, writing programs that

### Project 2: Scheme Interpreter

Project 2: Scheme Interpreter CSC 4101, Fall 2017 Due: 12 November 2017 For this project, you will implement a simple Scheme interpreter in C++ or Java. Your interpreter should be able to handle the same

### Racket: Modules, Contracts, Languages

Racket: Modules, Contracts, Languages Advanced Functional Programming Jean-Noël Monette November 2013 1 Today Modules are the way to structure larger programs in smaller pieces. Modules can import and

### Section 10: LISP to Scheme. Evolution of Software Languages

Section Evolution of Software Languages Theo D'Hondt Bachelor of Computer Science Faculty of Sciences and Bio-Engineering Sciences Vrije Universiteit Brussel Academic Year 2015-2016 Evolution of Software

### Visual Lisp/CLOS Programming in OpenMusic

Visual Lisp/CLOS Programming in OpenMusic Jean Bresson. Carlos Agon. Gérard Assayag IRCAM - CNRS UMR STMS Music Representation Research Group Paris, France. This is a preliminary version of the article

### Vectors in Scheme. Data Structures in Scheme

Data Structures in Scheme Vectors in Scheme In Scheme, lists and S-expressions are basic. Arrays can be simulated using lists, but access to elements deep in the list can be slow (since a list is a linked

### Visual Lisp/CLOS Programming in OpenMusic

Visual Lisp/CLOS Programming in OpenMusic Jean Bresson. Carlos Agon. Gérard Assayag IRCAM - CNRS UMR STMS Music Representation Research Group Paris, France. This is a preliminary version of the article

### CSCI 2210: Programming in Lisp. Progn. Block. CSCI Programming in Lisp; Instructor: Alok Mehta 1. ANSI Common Lisp, Chapters 5-10

CSCI 2210: Programming in Lisp ANSI Common Lisp, Chapters 5-10 CSCI 2210 - Programming in Lisp; Instructor: Alok Mehta; 4.ppt 1 Progn Progn Creates a block of code Expressions in body are evaluated Value

### Problem Set 4: Streams and Lazy Evaluation

Due Friday, March 24 Computer Science (1)21b (Spring Term, 2017) Structure and Interpretation of Computer Programs Problem Set 4: Streams and Lazy Evaluation Reading Assignment: Chapter 3, Section 3.5.

### MORE SCHEME. 1 What Would Scheme Print? COMPUTER SCIENCE MENTORS 61A. October 30 to November 3, Solution: Solutions begin on the following page.

MORE SCHEME COMPUTER SCIENCE MENTORS 61A October 30 to November 3, 2017 1 What Would Scheme Print? Solutions begin on the following page. 1. What will Scheme output? Draw box-and-pointer diagrams to help

### Allegro CL Certification Program

Allegro CL Certification Program Lisp Programming Series Level I Presented by 1 About David Margolies Manager, Documentation, Franz Inc Been working with Lisp since 1984 dm@franz.com 2 About Franz Inc.

### Delayed Expressions Fall 2017 Discussion 9: November 8, Iterables and Iterators. For Loops. Other Iterable Uses

CS 6A Delayed Expressions Fall 07 Discussion 9: November 8, 07 Iterables and Iterators An iterable is any container that can be processed sequentially. Examples include lists, tuples, strings, and dictionaries.

### Emacs Lisp Introduction

Emacs Lisp Introduction GNU Emacs is a full-featured text editor that contains a complete Lisp system that allows the user to write programs that control the editor. Dozens of applications have been written

### Scheme as implemented by Racket

Scheme as implemented by Racket (Simple view:) Racket is a version of Scheme. (Full view:) Racket is a platform for implementing and using many languages, and Scheme is one of those that come out of the

### Lisp: Lab Information. Donald F. Ross

Lisp: Lab Information Donald F. Ross General Model program source text stream What you need to write lexical analysis lexemes tokens syntax analysis is_id, is_number etc. + grammar rules + symbol table

### CS A331 Programming Language Concepts

CS A331 Programming Language Concepts Lecture 10 Alternative Programming Languages (Functional LISP Declarative - PROLOG) March 24, 2014 Sam Siewert Functional PL Concepts Based on Lambda Calculus Output

### Fall 2017 December 4, 2017

CS 61A Final Review Fall 2017 December 4, 2017 Instructions Form a small group. Start on the first problem. Check off with a helper or discuss your solution process with another group once everyone understands

### (Func&onal (Programming (in (Scheme)))) Jianguo Lu

(Func&onal (Programming (in (Scheme)))) Jianguo Lu 1 Programming paradigms Func&onal No assignment statement No side effect Use recursion Logic OOP AOP 2 What is func&onal programming It is NOT what you

### Loading Multiple Versions of an ASDF System in the Same Lisp Image

Loading Multiple Versions of an ASDF System in the Same Lisp Image Vsevolod Domkin 10 th European Lisp Symposium 2017-04-03 It all started with... I'm yet to see a name conflict in Lisp that can't be solved

### Outline. Best-first search. Greedy best-first search A* search Heuristics Local search algorithms

Outline Best-first search Greedy best-first search A* search Heuristics Local search algorithms Hill-climbing search Beam search Simulated annealing search Genetic algorithms Constraint Satisfaction Problems

### Design and Analysis of Algorithms 演算法設計與分析. Lecture 7 April 6, 2016 洪國寶

Design and Analysis of Algorithms 演算法設計與分析 Lecture 7 April 6, 2016 洪國寶 1 Course information (5/5) Grading (Tentative) Homework 25% (You may collaborate when solving the homework, however when writing up

### Lecture #5 Kenneth W. Flynn RPI CS

Outline Programming in Lisp Lecture #5 Kenneth W. Flynn RPI CS We've seen symbols in three contexts so far: > (setf sym ) (let ((sym ))...) >'Sym SYM -- Context The first of these refers to a special (or

### Scheme in Scheme: The Metacircular Evaluator Eval and Apply

Scheme in Scheme: The Metacircular Evaluator Eval and Apply CS21b: Structure and Interpretation of Computer Programs Brandeis University Spring Term, 2015 The metacircular evaluator is A rendition of Scheme,

### Department of Computer and information Science Norwegian University of Science and Technology

Department of Computer and information Science Norwegian University of Science and Technology http://www.idi.ntnu.no/ A Crash Course in LISP MNFIT272 2002 Anders Kofod-Petersen anderpe@idi.ntnu.no Introduction

### Parsing INI Files in Lisp

Parsing INI Files in Lisp Gene Michael Stover created Sunday, 2005 February 20 updated Sunday, 2005 February 20 Copyright c 2005 Gene Michael Stover. All rights reserved. Permission to copy, store, & view

### Functional Programming - 2. Higher Order Functions

Functional Programming - 2 Higher Order Functions Map on a list Apply Reductions: foldr, foldl Lexical scoping with let s Functional-11, CS5314, Sp16 BGRyder 1 Higher Order Functions Functions as 1st class

### The Users Guide. and. API Reference

McCLIM User s Manual The Users Guide and API Reference Copyright c 2004,2005,2006,2007,2008,2017 the McCLIM hackers. i Table of Contents Introduction......................................... 1 Standards...........................................................

### IMPROVING A GREEDY DNA MOTIF SEARCH USING A MULTIPLE GENOMIC SELF-ADAPTATING GENETIC ALGORITHM

Proceedings of Student/Faculty Research Day, CSIS, Pace University, May 4th, 2007 IMPROVING A GREEDY DNA MOTIF SEARCH USING A MULTIPLE GENOMIC SELF-ADAPTATING GENETIC ALGORITHM Michael L. Gargano, mgargano@pace.edu

### Speaker Name: Bill Kramer. Course: CP33-2 A Visual LISP Wizard's Intro to Object Magic. Course Description

Speaker Name: Bill Kramer Course: CP33-2 A Visual LISP Wizard's Intro to Object Magic Course Description This course introduces the use of objects in Visual LISP and demonstrates how they can be created

### Lisp Users and Vendors Conference. August 10, Tutorial on. Style. Peter Norvig. Sun Microsystems Labs Inc. Kent Pitman. Harlequin, Inc.

Lisp Users and Vendors Conference August 10, 1993 Tutorial on Good Lisp Programming Style Peter Norvig Sun Microsystems Labs Inc. Kent Pitman Harlequin, Inc. Portions copyright c 1992, 1993 Peter Norvig.

### CS 342 Lecture 7 Syntax Abstraction By: Hridesh Rajan

CS 342 Lecture 7 Syntax Abstraction By: Hridesh Rajan 1 Reading SICP, page 11-19, Section 1.1.6 Little Schemer, Chapter 2 2 The Idea of Syntax Abstraction Problem. Often programming tasks are repetitive,

### Normal Order (Lazy) Evaluation SICP. Applicative Order vs. Normal (Lazy) Order. Applicative vs. Normal? How can we implement lazy evaluation?

Normal Order (Lazy) Evaluation Alternative models for computation: Normal (Lazy) Order Evaluation Memoization Streams Applicative Order: evaluate all arguments, then apply operator Normal Order: pass unevaluated

### Design and Analysis of Algorithms 演算法設計與分析. Lecture 7 April 15, 2015 洪國寶

Design and Analysis of Algorithms 演算法設計與分析 Lecture 7 April 15, 2015 洪國寶 1 Course information (5/5) Grading (Tentative) Homework 25% (You may collaborate when solving the homework, however when writing

### A Brief Introduction to Scheme (II)

A Brief Introduction to Scheme (II) Philip W. L. Fong pwlfong@cs.uregina.ca Department of Computer Science University of Regina Regina, Saskatchewan, Canada Lists Scheme II p.1/29 Lists Aggregate data

### 4/22/2014. Genetic Algorithms. Diwakar Yagyasen Department of Computer Science BBDNITM. Introduction

4/22/24 s Diwakar Yagyasen Department of Computer Science BBDNITM Visit dylycknow.weebly.com for detail 2 The basic purpose of a genetic algorithm () is to mimic Nature s evolutionary approach The algorithm

### Building a system for symbolic differentiation

Computer Science 21b Structure and Interpretation of Computer Programs Building a system for symbolic differentiation Selectors, constructors and predicates: (constant? e) Is e a constant? (variable? e)

### HIERARCHICAL DATA What is a Tree? How is it different from a Deep List? When would you use one over the other?

HIERARCHICAL DATA 5 COMPUTER SCIENCE 61AS Concepts and Definitions 1. What is a Tree? How is it different from a Deep List? When would you use one over the other? A Tree is an Abstract Data Type composed

### 1. Problem Representation

Answer Key CSci 5511 Artificial Intelligence 1 October 7, 2008 Exam 1 1. Problem Representation 20 points [graded by baylor] Consider the following problem: you are given a path of N white and black squares.

### Assignment #6: Markov-Chain Language Learner CSCI E-220 Artificial Intelligence Due: Thursday, October 27, 2011

1. General Idea Assignment #6: Markov-Chain Language Learner CSCI E-220 Artificial Intelligence Due: Thursday, October 27, 2011 You will write a program that determines (as best as possible) the language

### CS 314 Principles of Programming Languages. Lecture 16

CS 314 Principles of Programming Languages Lecture 16 Zheng Zhang Department of Computer Science Rutgers University Friday 28 th October, 2016 Zheng Zhang 1 CS@Rutgers University Class Information Reminder:

### Scheme Basics > (butfirst '(help!)) ()

Scheme Basics > (butfirst '(help!)) () [The butfirst of a *sentence* containing one word is all but that word, i.e., the empty sentence. (BUTFIRST 'HELP!) without the inner parentheses would be butfirst

### Essentials of Programming Languages Language

Essentials of Programming Languages Language Version 6.90.0.26 April 20, 2018 The Essentials of Programming Languages language in DrRacket provides a subset of functions and syntactic forms of racket mostly

### Scheme: Data. CS F331 Programming Languages CSCE A331 Programming Language Concepts Lecture Slides Monday, April 3, Glenn G.

Scheme: Data CS F331 Programming Languages CSCE A331 Programming Language Concepts Lecture Slides Monday, April 3, 2017 Glenn G. Chappell Department of Computer Science University of Alaska Fairbanks ggchappell@alaska.edu

### ESA: A CLIM Library for Writing Emacs-Style Applications

GOLDSMITHS Research Online Conference or Workshop Item Strandh, Robert, Henriksen, Troels, Murray, David and Rhodes, Christophe ESA: A CLIM Library for Writing Emacs-Style Applications You may cite this