;;; CVS PARSING FUNCTION - EXECUTABLE FILE  ; tree ";" for big comments, two for full-line comments, one for in-line comments... just conventions, as *global-variable*...
(load "split-sequence.lisp")
(setf aggregate nil) ; setf is setq when needed, but it's more flexible in general
 (parse-csv)	; this way you call a normal function, that can be reused
 
 ;; I formatted it a little more lispy, as teached in "Common Lisp - A gentle introduction to symbolic computation"
 ;; It's esasier with spaces than with tabs. Suggested base tabulation is of 2 spaces
(defun parse-csv (&optional (filename (first *args*)))	; &optional says: if you give parse-csv an argument, it's the filename; otherwise, get it from (first *args)
  "Parses a CSV file and DOES THINGS"  ; in-line documentation. Try (documentation 'parse-csv 'function) :D
  (with-open-file (stream filename) 
    (do ((line (read-line stream nil) (read-line stream nil))) 
        ((null line) aggregate) ; returns the aggregate value in output - no need to print it
	    (let* (		; let* is equivalent to let but bounds its arguments one at a time
		    (tmp    (split-sequence:SPLIT-SEQUENCE #\, line )) 	; this can still be made in LET*
		    (key    (intern (first tmp)))
		    (newval (parse-integer (car (last tmp)) :junk-allowed t)) ; CAR is lispy :P
		    (val    (cdr (assoc key aggregate))) ) ; this can stay in LET* too
          (if val   (rplacd (assoc key aggregate) (+ newval val))
	   		        (setq aggregate (acons key newval aggregate))))))

;;; get split-sequence from http://www.cliki.net/SPLIT-SEQUENCE
(load "split-sequence.lisp")
(setq aggregate '()) ;; the association list to store results
 
(with-open-file (stream (first *args*)) ;; open the file specified on cli
    (do ((line (read-line stream nil) 	;;; initialize with read-line
               (read-line stream nil))) ;;; step is read-line
        ((null line)) 			;;; termination condition
 
	;; split the output string on a comma using the split-sequence
	(setq tmp (split-sequence:SPLIT-SEQUENCE #\, line ) )
 
	(let (
		(key 	(intern (first tmp))					) 	;; our key
		(newval (parse-integer (first (last tmp)) :junk-allowed t)	)	;; convert the last value to an int
	     )
		   (setq val 	(cdr (assoc key aggregate))	)	;; check if key is in the assoc; if it's not, VAL will be NIL
 
		   (if val
	  		(rplacd (assoc key aggregate) (+ newval val)) 	;; if exist update old entry
	   		(setq aggregate (acons key newval aggregate))	;; else add a new entry
		)
	)
    )
    (print aggregate)
)

init(start);
i:=istart;
repeat
  generate (j in Nh(i))
  if fit(j) >= fit(i) then i:=j;
until f(j)

 
(defun dec2bin (n)  ; ci serve per ottenere la rappresentazione binaria del max
  "Restituisce la rappresentazione binaria di N, come lista di bit"
  (dec2bin-acc n nil))
 
(defun dec2bin-acc (n acc)
  "Versione di dec2bin con accumulatore per tail recursion"
  (if (= (length lst) n) lst
    (expand-bin (cons 0 lst) n)))
 
(defun fitness (n)
  "Restituisce la fitness di un numero"
  (length (remove-if #'zerop n)) )
 
(defun generate (i top) ;; a partire da questa versione, top è un numero decimale
  "Restituisce il primo tra i migliori vicini di I, stando attento a non sforare TOP"
  (let ((pos (position 0 i :from-end t)))
    (if (null pos) i
      (let ((copy (copy-list i)))
        (setf (nth pos copy) 1)
        (if (= (fitness i) (fitness j)) )
 
(defun best (lst)
  "Data una lista di codifiche binarie, restituisce quella con fitness migliore"
  (car (sort lst #'best-fit-check)) )
 
(defun local-search (n)
  "Esegue una ricerca locale con spazio delle soluzioni tra 0 e N"
  (do* ((i     (init n)     (best (list i j)))
        (j     (generate i n) (generate i n))
        (i-dec (bin2dec i)  (bin2dec i))
        (fi    (fitness i)  (fitness i))         ;NOTA: solo per leggibilità, per ottimizzazione rimuoverle
        (fj    (fitness j)  (fitness j)))
       ((or (equal i j) (> fi fj))  ; ecco che vado ad assicurarmi dal loop sul massimo
        (format t #|"~&FINE:|#"~&Soluzione finale:  ~D = ~A - Fitness: ~D" i-dec i fi)
         i-dec)
       (format t "~&Passaggio attuale: ~D = ~A - Fitness: ~D" i-dec i fi) ))

init(start);
i:=istart;
repeat
  generate (j in Nh(i))
  if fit(j) >= fit(i) then i:=j;
until f(j)

(defun dec2bin (n)  ; ci serve per ottenere la rappresentazione binaria del max
  "Restituisce la rappresentazione binaria di N, come lista di bit"
  (dec2bin-acc n nil))
 
(defun dec2bin-acc (n acc)
  "Versione di dec2bin con accumulatore per tail recursion"
  (if (= (length lst) n) lst
    (expand-bin (cons 0 lst) n)))
 
(defun fitness (n)
  "Restituisce la fitness di un numero"
  (length (remove-if #'zerop n)) )
 
(defun generate (i top) ;; a partire da questa versione, top è un numero decimale
  "Restituisce il primo tra i migliori vicini di I, stando attento a non sforare TOP"
  (let ((pos (position 0 i :from-end t)))
    (if (null pos) i
      (let ((copy (copy-list i)))
        (setf (nth pos copy) 1)
        (if (= (fitness i) (fitness j)) )
 
(defun best (lst)
  "Data una lista di codifiche binarie, restituisce quella con fitness migliore"
  (car (sort lst #'best-fit-check)) )
 
(defun local-search (n)
  "Esegue una ricerca locale con spazio delle soluzioni tra 0 e N"
  (do* ((i     (init n)     (best (list i j)))
        (j     (generate i n) (generate i n))
        (i-dec (bin2dec i)  (bin2dec i))
        (fi    (fitness i)  (fitness i))         ;NOTA: solo per leggibilità, per ottimizzazione rimuoverle
        (fj    (fitness j)  (fitness j)))
       ((or (equal i j) (> fi fj))  ; ecco che vado ad assicurarmi dal loop sul massimo
        (format t #|"~&FINE:|#"~&Soluzione finale:  ~D = ~A - Fitness: ~D" i-dec i fi)
         i-dec)
       (format t "~&Passaggio attuale: ~D = ~A - Fitness: ~D" i-dec i fi) ))

init(start);
i:=istart;
repeat
  generate (j in Nh(i))
  if fit(j) >= fit(i) then i:=j;
until f(j)

(defun dec2bin (n)  ; ci serve per ottenere la rappresentazione binaria del max
  "Restituisce la rappresentazione binaria di N, come lista di bit"
  (dec2bin-acc n nil))
 
(defun dec2bin-acc (n acc)
  "Versione di dec2bin con accumulatore per tail recursion"
  (if (= (length lst) n) lst
    (expand-bin (cons 0 lst) n)))
 
(defun fitness (n)
  "Restituisce la fitness di un numero"
  (length (remove-if #'zerop n)) )
 
(defun generate (i top) ;; a partire da questa versione, top è un numero decimale
  "Restituisce il primo tra i migliori vicini di I, stando attento a non sforare TOP"
  (let ((pos (position 0 i :from-end t)))
    (if (null pos) i
      (let ((copy (copy-list i)))
        (setf (nth pos copy) 1)
        (if (= (fitness i) (fitness j)) )
 
(defun best (lst)
  "Data una lista di codifiche binarie, restituisce quella con fitness migliore"
  (car (sort lst #'best-fit-check)) )
 
(defun local-search (n)
  "Esegue una ricerca locale con spazio delle soluzioni tra 0 e N"
  (do* ((i     (init n)     (best (list i j)))
        (j     (generate i n) (generate i n))
        (i-dec (bin2dec i)  (bin2dec i))
        (fi    (fitness i)  (fitness i))         ;NOTA: solo per leggibilità, per ottimizzazione rimuoverle
        (fj    (fitness j)  (fitness j)))
       ((or (equal i j) (> fi fj))  ; ecco che vado ad assicurarmi dal loop sul massimo
        (format t #|"~&FINE:|#"~&Soluzione finale:  ~D = ~A - Fitness: ~D" i-dec i fi)
         i-dec)
       (format t "~&Passaggio attuale: ~D = ~A - Fitness: ~D" i-dec i fi) ))