(defun runonce()
  (setf *seed0* (+ *seed0* 25))
  (setf end_development_cache (generate-end-development))
  (reset-seed)
  (print "PB:")
  (print (runpbsim end_development_cache))
  (reset-seed)
  (print "AG:")
  (print (runagsim "ag" end_development_cache))
  (reset-seed)
  (print "AG2:")
  (print (runagsim "ag2" end_development_cache))
  (reset-seed)
  (print "HY:")
  (print (runhysim end_development_cache))
  *seed0*
  )

(defun updatevaluesold(inrequirements)
  (mapcar #'(lambda(x) (progn
                         (setf (car x) (+ (car x) (randnorm 0 (globdef-req_value_sigma gv))))
                         x
                         )) inrequirements)
)

(defun updatevalues(inrequirements)
  (mapcar #'(lambda (x) (progn
                          (if (req-req_active x)
                              (setf (req-req_value x) (+ (req-req_value x) (* (req-req_value x) (pop (req-req_future_values x)))))
                              )
                          x
                          )) inrequirements)
  )
    


(defun addnewrequirements(inrequirements iteration)
  (mapcar #'(lambda (x) (if (and (not (null (req-req_activate_at_iter x))) (= (req-req_activate_at_iter x) iteration))
                            (progn
                              (setf (req-req_active x) t)
                              x
                              )
                            x
                            )) inrequirements)
  )
  
(defun addnewrequirements_v2(AG_Plan AG_Heap iteration)
  (dolist (h AG_Heap)
    (if (and (not (null (req-req_activate_at_iter h))) (= (req-req_activate_at_iter h) iteration))
      (progn
        (setf (req-req_active h) t)
        (setf AG_Plan (append AG_Plan (list h)))
        (setf AG_Heap (remove h AG_Heap))
      )
    )
  )
  (append (list AG_Plan) AG_Heap)
)
  


(defun retrieve-initial-requirements (allrequirements)
  (split-list (random-between-int (* (globdef-initial_bound_lower gv) (globdef-num_reqs gv)) (* (globdef-initial_bound_upper gv) (globdef-num_reqs gv))) allrequirements)
 )

(defun propersort (inrequirements conditionfunction keyfunction)
  (let ((sortablerequirements (remove-if #'(lambda (x) (null (req-req_active x))) inrequirements))
        (unsortablerequirements (remove-if #'(lambda (x) (not (null (req-req_active x)))) inrequirements))
        )
    (progn
      (setf sortablerequirements (sort sortablerequirements conditionfunction :key keyfunction))
      (append sortablerequirements unsortablerequirements)
      )
    )
  )

(defun averageResults(results fn)
  (remove nil (mapcar #'(lambda (x)
                          (if (< (length (remove nil x))
                                 (* (globdef-num_trials gv) 0.2)
                                 )
                          nil
                          (/ (float (apply #'+ (remove nil x))) (length (remove nil x)))
                          )
              )
          (do ((i 0)
       (newlists nil))
      ((> i 50) newlists)
    (setf newlists (append newlists (list (mapcar #'(lambda (x) (nth i x)) (mapcar #'(lambda (x) (funcall fn x)) results)))))

    ;(print newlists)
    (incf i)
    
    )
          ))
)

(defun outputResults (filename results)
  (with-open-file (out filename :direction :output :if-exists :supersede :if-does-not-exist :create)
    (do ((i 0))
        ((> i (- (length (car results)) 1)))
      (format out "~,2F ~T ~,2F ~%" (nth i (car (cdr results))) (nth i (car results)))
      (incf i)
    )
    )
  )
  
(defun outputGraph (&optional (toFile nil) (title nil) (endCost nil) (graphOF t) (graphPB t) (graphAG t) (graphAG2 t) (graphHY t))
  (let ((numPlots 0))
    (with-open-file (out "proj2-pom1v2/dynGraph.gp" :direction :output :if-exists :supersede :if-does-not-exist :create)
      (format out "set xlabel \"Cumulative Cost\"~%")
      (format out "set ylabel \"Cumulative Value\"~%")
      (if title
        (format out "set title ~s~%" title)
      )    
      (if endCost
        (format out "set xrange [0:~s]~%" endCost)
      )
      
      (if toFile
        (progn
          (format out "set palette gray~%")
          (format out "set term postscript eps enhanced monochrome~%")
          (format out "set output '~a.eps'~%" title)
        )
      )
      
      (format out "~%plot ")
      (if graphOF
        (progn
          (format out "\"plotOFresult.dat\" using 1:2 title \"Optimal Frontier\" with linespoints")
          (incf numPlots)
        )
      )
      
      (if graphPB
        (progn
          (if (> numPlots 0)
            (format out ",\\~%")
          )
          (format out "\"plotpbresult.dat\" using 1:2 title \"Plan-Based\" with linespoints")
          (incf numPlots)
        )
      )
      
      (if graphAG
        (progn
          (if (> numPlots 0)
            (format out ",\\~%")
          )
          (format out "\"plotagresult.dat\" using 1:2 title \"Agile\" with linespoints")
          (incf numPlots)
        )
      )
      
      (if graphAG2
        (progn
          (if (> numPlots 0)
            (format out ",\\~%")
          )
          (format out "\"plotag2result.dat\" using 1:2 title \"Agile 2\" with linespoints")
          (incf numPlots)
        )
      )
      
      (if graphHY
        (progn
          (if (> numPlots 0)
            (format out ",\\~%")
          )
          (format out "\"plothyresult.dat\" using 1:2 title \"Hybrid\" with linespoints")
          (incf numPlots)
        )
      )
      
      (if (not toFile)
        (format out "~%pause -1")
      )
      
    )
  )
  
)

;(defun runtest()
  ;(setf (globdef-num_trials gv) 1000)
  ;(setf (globdef-ave_new_req_per_iter gv) 20)
  ;(setf (globdef-req_value_sigma gv) 2)
  ;(runtrials)
  ;)

(defun runpom1()
  (runlow)
  (runmed)
  (runhigh)
  )

(defun runlow(&optional (runonce t) (toFile nil) (title nil) (endCost nil) (graphOF t) (graphPB t) (graphAG t) (graphAG2 t) (graphHY t) (oSeed 13))
  (setf (globdef-num_trials gv) 1000)
  (setf (globdef-ave_new_req_per_iter gv) .001)
  (setf (globdef-req_value_sigma gv) .001)
  (if runonce
    (runtrials runonce toFile "Low Dynamism - Single Run" endCost graphOF graphPB graphAG graphAG2 graphHY oSeed)
    (runtrials runonce toFile "Low Dynamism - Averaged Runs" endCost graphOF graphPB graphAG graphAG2 graphHY oSeed)
  )
)

(defun runmed(&optional (runonce t) (toFile nil) (title nil) (endCost nil) (graphOF t) (graphPB t) (graphAG t) (graphAG2 t) (graphHY t) (oSeed 3))
  (setf (globdef-num_trials gv) 1000)
  (setf (globdef-ave_new_req_per_iter gv) 1.4)
  (setf (globdef-req_value_sigma gv) .15)
  (if runonce
    (runtrials runonce toFile "Medium Dynamism - Single Run" endCost graphOF graphPB graphAG graphAG2 graphHY oSeed)
    (runtrials runonce toFile "Medium Dynamism - Averaged Runs" endCost graphOF graphPB graphAG graphAG2 graphHY oSeed)
  )
)

(defun runhigh(&optional (runonce t) (toFile nil) (title nil) (endCost nil) (graphOF t) (graphPB t) (graphAG t) (graphAG2 t) (graphHY t) (oSeed 13))
  (setf (globdef-num_trials gv) 1000)
  (setf (globdef-ave_new_req_per_iter gv) 20)
  (setf (globdef-req_value_sigma gv) 2)
  (if runonce
    (runtrials runonce toFile "High Dynamism - Single Run" endCost graphOF graphPB graphAG graphAG2 graphHY oSeed)
    (runtrials runonce toFile "High Dynamism - Averaged Runs" endCost graphOF graphPB graphAG graphAG2 graphHY oSeed)
  )
  
)

;(setf oSeed 0)
(defun runtrials(&optional (runonce t) (toFile nil) (title nil) (endCost nil) (graphOF t) (graphPB t) (graphAG t) (graphAG2 t) (graphHY t) (oSeed 0))
  (let ((OF_resultlist nil)
        (OF_currentresult nil)
        (OI_resultlist nil)
        (OI_currentresult nil)
        (PB_resultlist nil)
        (PB_currentresult nil)
        (AG_resultlist nil)
        (AG_currentresult nil)
        (AG2_resultlist nil)
        (AG2_currentresult nil)
        (HY_resultlist nil)
        (HY_currentresult nil)
        (HY2_resultlist nil)
        (HY2_currentresult nil)
        (numruns (globdef-num_trials gv))
		(oEndCost nil)
        )
        
        (if runonce
          (setf numruns 1)          
        )                 
        (print oSeed)
    
    (dotimes (i numruns)
      
      (setf *seed0* (+ 10000 (* oSeed 25)))  
      ;(reset-seed)
      (setf end_development_cache (generate-end-development))
      (reset-seed)
      (setf OF_currentresult (list (runOFsim end_development_cache)))
     ; (print OF_currentresult)
      (setf OF_resultlist (append OF_resultlist OF_currentresult))
     ; (print OF_resultlist)
      (reset-seed)
      (setf OI_currentresult (list (runOIsim  end_development_cache)))
      (setf OI_resultlist (append OI_resultlist OI_currentresult))
      (reset-seed)
      (setf PB_currentresult (list (runpbsim end_development_cache)))
      ;(print (sumcost (third (car PB_currentresult))))
      (setf PB_resultlist (append PB_resultlist PB_currentresult))
      (reset-seed)
      (setf AG_currentresult (list (runagsim "ag" end_development_cache)))
      ;(print (sumcost (third (car AG_currentresult))))
      (setf AG_resultlist (append AG_resultlist AG_currentresult))
      (reset-seed)
      (setf AG2_currentresult (list (runagsim "ag2" end_development_cache)))
      ;(print (sumcost (third (car AG2_currentresult))))
      (setf AG2_resultlist (append AG2_resultlist AG2_currentresult))
      (reset-seed)
      (setf HY_currentresult (list (runhysim end_development_cache)))
      (setf HY_resultlist (append HY_resultlist HY_currentresult))
      (reset-seed)
      (setf HY2_currentresult (list (runhysim_v2 end_development_cache)))
      (setf HY2_resultlist (append HY2_resultlist HY2_currentresult))
	  
	  (incf oSeed)
      
    )
     (print (car PB_resultList))
     (print "-----")
     (print (car (last (second (car PB_resultList)))))
     ;(print (list (averageResults AG2_resultList #'first) (averageResults AG2_resultList #'second)))
	
	
	(setf oEndCost (* 1.4 (car (last (second (car HY_resultList))))))
	
	(outputGraph toFile title oEndCost graphOF graphPB graphAG graphAG2 graphHY)
    
    (if runonce
      (progn
        (outputResults "proj2-pom1v2/plotOFresult.dat" (car OF_resultlist))
        (outputResults "proj2-pom1v2/plotOIresult.dat" (car OI_resultlist))
        (outputResults "proj2-pom1v2/plotpbresult.dat" (car PB_resultlist))
        (outputResults "proj2-pom1v2/plotagresult.dat" (car AG_resultlist))
        (outputResults "proj2-pom1v2/plotag2result.dat" (car AG2_resultlist))
        (outputResults "proj2-pom1v2/plothyresult.dat" (car HY_resultlist))
        (outputResults "proj2-pom1v2/plothy2result.dat" (car HY2_resultlist))
        ;(run-program "proj2-pom1/graph.sh" nil :wait   nil :pty    nil :input  :stream :error :output :output t)
      )
      (progn
        (outputResults "proj2-pom1v2/plotOFresult.dat" (list (averageResults OF_resultlist #'first) (averageResults OF_resultlist #'second)))
        (outputResults "proj2-pom1v2/plotOIresult.dat" (list (averageResults OI_resultlist #'first) (averageResults OI_resultlist #'second)))
        (outputResults "proj2-pom1v2/plotpbresult.dat" (list (averageResults PB_resultlist #'first) (averageResults PB_resultlist #'second)))
        (outputResults "proj2-pom1v2/plotagresult.dat" (list (averageResults AG_resultlist #'first) (averageResults AG_resultlist #'second)))
        (outputResults "proj2-pom1v2/plotag2result.dat" (list (averageResults AG2_resultlist #'first) (averageResults AG2_resultlist #'second)))
        (outputResults "proj2-pom1v2/plothyresult.dat" (list (averageResults HY_resultlist #'first) (averageResults HY_resultlist #'second)))
        (outputResults "proj2-pom1v2/plothy2result.dat" (list (averageResults HY2_resultlist #'first) (averageResults HY2_resultlist #'second)))
        ;(run-program "proj2-pom1/graph.sh" nil :wait   nil :pty    nil :input  :stream :error :output :output t)
      )
    )
    
    
 
  )
)

(defun runpbsim(end_developement_cache)
  (do* ((requirements (generate-value-cost))
        (PB_TotalCost (sumcost requirements))
        (PB_Plan (propersort (copy-list requirements) #'> #'(lambda (x) (/ (req-req_value x) (req-req_cost x)))))
        (PB_Completed (list))
        (current_iter 1)
        (end_development nil)
        (end_development_list (copy-list end_developement_cache))
        )
       ((or (> current_iter (globdef-num_iters gv)) end_development) (list (cumulativecost PB_Completed #'sumvalue) (cumulativecost PB_Completed #'sumcost)))

    (if (= current_iter 1)
        (progn
          ;(print requirements)
          ;(print PB_Plan)
        ))
    (if (> current_iter (globdef-min_iters gv))
        (setf end_development (pop end_development_list))
        )
        
    ; (if (= current_iter 1)
      ; (progn 
        ; (format t "~%")
        ; (dolist (p PB_Plan)
          ; (format t "~s/~s " (req-req_value p) (req-req_cost p))
        ; )
        ; (format t "~%")
        ; (format t "future values = ~s ~%" (req-req_future_values (second PB_Plan)))
      ; )
    ; )
    
    ; (print "PB---------")
    ; (if (> (length PB_Completed) 0)
      ; (progn
        ; (format t "~%~s/~s~% " (req-req_value (second PB_Completed)) (req-req_cost (second PB_Completed)))
        ; (format t "~s~% " (req-req_future_values (second PB_Completed)))
      ; )
    ; )
    
    ;(print "iter")
    ;(print current_iter)
    (do ((PB_RequirementCompleted))
        ((or (= 0 (length (remove-if #'(lambda (x) (null (req-req_active x))) PB_Plan))) 
          (> (+ (req-req_cost (car PB_Plan)) (sumcost PB_Completed)) (/ (* PB_TotalCost current_iter) (globdef-num_iters gv)))
          )
        )
      (setf PB_RequirementCompleted (pop PB_Plan))
      ;(print (req-req_value PB_RequirementCompleted))
      ;(incf PB_TotalIterationCost (second PB_RequirementCompleted))
      (setf (req-req_satisfied PB_RequirementCompleted) t)
      (setf (req-req_satisfied_in_iter PB_RequirementCompleted) current_iter)
      (setf PB_Completed (append PB_Completed (list PB_RequirementCompleted)))
      )
    ;put your code here
   
    ;(print "Plan before Update")
    ;(print PB_Plan)
    (setf PB_Plan (updatevalues PB_Plan))
    (setf PB_Completed (updatevalues PB_Completed))
    (setf PB_Plan (remove-if #'(lambda (x) (if (<= (req-req_value x) 0)
                                               t
                                               nil
                                               ))
                             PB_Plan))
    (setf PB_Completed (remove-if #'(lambda (x) (if (<= (req-req_value x) 0)
                                               t
                                               nil
                                               ))
                             PB_Completed))                         
                             
    ; ; set completed values to 0 if less than 0
    ; (dolist (compReq PB_Completed)
      ; (if (< (req-req_value compReq) 0)
        ; (setf (req-req_value compReq) 0)
      ; )
    ; )
    
    (setf PB_Plan (addnewrequirements PB_Plan current_iter))
    ;(print "Plan after Update")
    ;(print PB_Plan)
    ;(format t "PB Iter ~D" current_iter)
    (incf current_iter)
    )
  )

(defun runOIsim(end_developement_cache)
  (do* ((requirements (generate-value-cost))
        (OI_TotalCost (sumcost requirements))
        (OI_Plan (propersort (copy-list requirements) #'> #'(lambda (x) (/ (req-req_value x) (req-req_cost x)))))
        (OI_Completed (list))
        (current_iter 1)
        (end_development nil)
        (end_development_list (copy-list end_developement_cache))
        )
       ((or (> current_iter (globdef-num_iters gv)) end_development) (list (cumulativecost OI_Completed #'sumvalue) (cumulativecost OI_Completed #'sumcost)))

    (if (= current_iter 1)
        (progn
          ;(print requirements)
          ;(print PB_Plan)
        ))
    (if (> current_iter (globdef-min_iters gv))
        (setf end_development (pop end_development_list))
        )
    (do ((OI_RequirementCompleted))
        ((or (= 0 (length (remove-if #'(lambda (x) (null (req-req_active x))) OI_Plan)))
             (> (+ (req-req_cost (car OI_Plan)) (sumcost OI_Completed))
                (/ (* OI_TotalCost current_iter) (globdef-num_iters gv)))))
      (setf OI_RequirementCompleted (pop OI_Plan))
      ;(print PB_RequirementCompleted)
      ;(incf PB_TotalIterationCost (second PB_RequirementCompleted))
      (setf (req-req_satisfied OI_RequirementCompleted) t)
      (setf (req-req_satisfied_in_iter OI_RequirementCompleted) current_iter)
      (setf OI_Completed (append OI_Completed (list OI_RequirementCompleted)))
      )
 
    (incf current_iter)
    )
  )


(defun runOFsim_old (end_development_cache)
  (do* ((requirementsi (generate-value-cost))
        (OF_TotalCost (sumcost requirementsi))
	;(requirements (retrieve-initial-requirements requirementsi))
	(OF_Plan requirementsi)
	;(AG_Heap (getHeap requirements))
	(OF_Completed (list))
	(current_iter 1)
	(end_development nil)
        (end_development_list (copy-list end_development_cache))
	)
       ((or (> current_iter (globdef-num_iters gv)) end_development)
        (list (cumulativecost OF_Completed #'sumvalue) (cumulativecost OF_Completed #'sumcost)))
    ; check for end development
    (if (> current_iter (globdef-min_iters gv))
	(setf end_development (pop end_development_list))
	)
    
    (if (= current_iter 1)
        (progn
          ;(print requirementsi)
          ;(print PB_Plan)
        ))
    ; sort list
    (setf OF_Plan (propersort (copy-list OF_Plan) #'> #'(lambda (x) (/ (req-req_value x) (req-req_cost x)))))
  
    (do ((OF_RequirementCompleted))
        ((or (= 0 (length (remove-if #'(lambda (x) (null (req-req_active x))) OF_Plan)))
             (> (+ (req-req_cost (car OF_Plan)) (sumcost OF_Completed))
                (/ (* OF_TotalCost current_iter) (globdef-num_iters gv)))))
      (setf OF_RequirementCompleted (pop OF_Plan))
      (setf (req-req_satisfied OF_RequirementCompleted) t)
      (setf (req-req_satisfied_in_iter OF_RequirementCompleted) current_iter)
      (setf OF_Completed (append OF_Completed (list OF_RequirementCompleted)))
      )

    (setf OF_Plan (updatevalues OF_Plan))
    (setf OF_Plan (addnewrequirements OF_Plan current_iter))

    (incf current_iter)
    )
)

(defun runOFsim (end_development_cache)
  (let* ((finalValues (do* ((requirementsi (generate-value-cost))
                          (OF_TotalCost (sumcost requirementsi))
                          (OF_Plan requirementsi)
                          (OF_Completed (list))
                          (current_iter 1)
                          (end_development nil)
                          (end_development_list (copy-list end_development_cache))
                          )
                        ((or (> current_iter (globdef-num_iters gv)) end_development) (list OF_Plan OF_TotalCost))
                        (if (> current_iter (globdef-min_iters gv))
                            (setf end_development (pop end_development_list))
                        )
                        (setf OF_Plan (updatevalues OF_Plan))
                        (setf OF_Plan (addnewrequirements OF_Plan current_iter))
                        (incf current_iter)
                        ))
        (OF_Plan (car finalValues))
        (OF_TotalCost (car (cdr finalValues))))
        
          (do* (

            ;(AG_Heap (getHeap requirements))
            (OF_Completed (list))
            (current_iter 1)
            (end_development nil)
            (end_development_list (copy-list end_development_cache))
            )
               ((or (> current_iter (globdef-num_iters gv)) end_development)
                (list (cumulativecost OF_Completed #'sumvalue) (cumulativecost OF_Completed #'sumcost)))
            ; check for end development
            (if (> current_iter (globdef-min_iters gv))
            (setf end_development (pop end_development_list))
            )
            
            (if (= current_iter 1)
                (setf OF_Plan (propersort (copy-list OF_Plan) #'> #'(lambda (x) (/ (req-req_value x) (req-req_cost x)))))
                )
            
          
            (do ((OF_RequirementCompleted))
                ((or (= 0 (length (remove-if #'(lambda (x) (null (req-req_active x))) OF_Plan)))
                     (> (+ (req-req_cost (car OF_Plan)) (sumcost OF_Completed))
                        (/ (* OF_TotalCost current_iter) (globdef-num_iters gv)))))
              (setf OF_RequirementCompleted (pop OF_Plan))
              (setf (req-req_satisfied OF_RequirementCompleted) t)
              (setf (req-req_satisfied_in_iter OF_RequirementCompleted) current_iter)
              (setf OF_Completed (append OF_Completed (list OF_RequirementCompleted)))
              )
        
            
        
            (incf current_iter)
            )
        )
)
    
(defun runagsim (simtype end_development_cache)
  (do* ((requirementsi (generate-value-cost))
        (AG_TotalCost (sumcost requirementsi))
	(requirements (retrieve-initial-requirements requirementsi))
	(AG_Plan (getPlan requirements))
	(AG_Heap (getHeap requirements))
	(AG_Completed (list))
	(current_iter 1)
	(end_development nil)
        (end_development_list (copy-list end_development_cache))
	)
       ((or (> current_iter (globdef-num_iters gv)) end_development) (list (cumulativecost AG_Completed #'sumvalue) (cumulativecost AG_Completed #'sumcost)))
    ; check for end development
    (if (> current_iter (globdef-min_iters gv))
	(setf end_development (pop end_development_list))
	)
  ; (print "----")
  ; (print (length requirementsi))
  ; (print (length AG_Plan))
  ; (print (length AG_Heap))
    
    ; (format t "~%~s_TotalCost = ~s~%" simtype AG_TotalCost)
    ; (format t "~s~%" end_development_cache)
    ; ;(print (globdef-min_iters gv))
    ; (format t "end dev = ~s~%" end_development)
    ; (format t "current iter = ~s~%" current_iter)
    
    (if (= current_iter 1)
        (progn
          ;(print requirementsi)
          ;(print PB_Plan)
        ))
        
    ; sort list
    (if (string= simtype "ag")
        (setf AG_Plan (propersort (copy-list AG_Plan) #'> #'(lambda (x) (req-req_value x))))
        (setf AG_Plan (propersort (copy-list AG_Plan) #'> #'(lambda (x) (/ (req-req_value x) (req-req_cost x)))))
        )
    ;(print "Debug 1")
    
    ; (if (= current_iter 1)
      ; (progn 
        ; (format t "~%")
        ; (dolist (p AG_Plan)
          ; (format t "~s/~s " (req-req_value p) (req-req_cost p))
        ; )
        ; (format t "~%")
      ; )
    ; )

    (do ((AG_RequirementCompleted))
        ((or (= 0 (length (remove-if #'(lambda (x) (null (req-req_active x))) AG_Plan))) (> (+ (req-req_cost (car AG_Plan)) (sumcost AG_Completed)) (/ (* AG_TotalCost current_iter) (globdef-num_iters gv)))))
      (setf AG_RequirementCompleted (pop AG_Plan))
      ;(print PB_RequirementCompleted)
      ;(incf PB_TotalIterationCost (second PB_RequirementCompleted))
      (setf (req-req_satisfied AG_RequirementCompleted) t)
      (setf (req-req_satisfied_in_iter AG_RequirementCompleted) current_iter)
      (setf AG_Completed (append AG_Completed (list AG_RequirementCompleted)))
      )

    (setf AG_Plan (updatevalues AG_Plan))
    (setf AG_Heap (updatevalues AG_Heap))
    (setf AG_Completed (updatevalues AG_Completed))
    
    (setf AG_Plan (remove-if #'(lambda (x) (if (<= (req-req_value x) 0)
                                               t
                                               nil
                                               ))
                             AG_Plan))
    (setf AG_Heap (remove-if #'(lambda (x) (if (<= (req-req_value x) 0)
                                               t
                                               nil
                                               ))
                             AG_Heap))
    (setf AG_Completed (remove-if #'(lambda (x) (if (<= (req-req_value x) 0)
                                               t
                                               nil
                                               ))
                             AG_Completed))                         
    ; ; set completed values to 0 if less than 0
    ; (dolist (compReq AG_Completed)
      ; (if (< (req-req_value compReq) 0)
        ; (setf (req-req_value compReq) 0)
      ; )
    ; )

    ;(format t "plan = ~f heap = ~f ~%" (length AG_Plan) (length AG_Heap)) 
    (setf requirements (addnewrequirements_v2 AG_Plan AG_Heap current_iter))
    ;(print requirements)
    (setf AG_Plan (getPlan requirements))
    (setf AG_Heap (getHeap requirements))
    ;(format t "plan = ~f heap = ~f ~%" (length AG_Plan) (length AG_Heap))
    
    ;(setf AG_Heap (addnewrequirements AG_Heap current_iter))
    

    
    ; take a poission number of reqs from heap and add to plan
    (let ((pRandNum (pRandom (globdef-ave_unimpl_req_per_iter gv))))
    ;(let ((pRandNum (round (globdef-ave_unimpl_req_per_iter gv))))

      ; append some poission number of reqs from heap to plan
      (if (> pRandNum (length (remove-if #'(lambda (x) (null (req-req_active x))) AG_Heap)))
          (setf pRandNum (length (remove-if #'(lambda (x) (null (req-req_active x))) AG_Heap)))
          )
      (setf AG_Plan (append AG_Plan (car (split-list pRandNum AG_Heap))))
      ;(print "debug 3.1")
      ; set new heap
      (setf AG_Heap (cdr (split-list pRandNum AG_Heap)))
      )

    ; update values of plan
    
    ;(format t "AG Iter ~D" current_iter)
    ; increment iteration
    (incf current_iter)
    )
)

(defun runhysimold()
  (do* ((requirements (generate-value-cost))
        (HY_Plan (sort (copy-list requirements) #'> :key #'(lambda (x) (/ (first x) (second x)))))
        (HY_Completed (list))
        (current_iter 1)
        (end_development nil)
        )
       ((or (> current_iter (globdef-num_iters gv)) end_development) (list (cumulativecost HY_Completed #'sumvalue) (cumulativecost HY_Completed #'sumcost)))

    (if (= current_iter 1)
        (progn
          ;(print requirements)
          ;(print PB_Plan)
        ))
    (if (> current_iter (globdef-min_iters gv))
        (setf end_development (randbin1 (globdef-end_dev_prob gv)))
        )

    (setf HY_Plan (sort (copy-list HY_Plan) #'> :key #'(lambda (x) (/ (first x) (second x)))))
    ;(print "iter")
    ;(print current_iter)
    (do* ((HY_RequirementCompleted)
          (HY_TurningPoint (float (/  (sumvalue HY_Plan) (sumcost HY_Plan))))
          )
        ((or  (= 0 (length HY_Plan)) (< (/ (first (first HY_Plan)) (second (first HY_Plan))) HY_TurningPoint)))
      (setf HY_RequirementCompleted (pop HY_Plan))
      ;(print PB_RequirementCompleted)
      (setf HY_Completed (append HY_Completed (list HY_RequirementCompleted)))
      )
    ;put your code here
    (incf current_iter)
    ;(print "Plan before Update")
    ;(print HY_Plan)
    (setf HY_Plan (updatevalues HY_Plan))
    (setf HY_Plan (remove-if #'(lambda (x) (if (<= (car x) 0)
                                               t
                                               nil
                                               ))
                             HY_Plan))
    (setf HY_Plan (addnewrequirements HY_Plan))
    (if (= (length HY_Plan) 0)
        (setf end_development t)
        )
    ;(print "Plan after Update")
    ;(print HY_Plan)
    )
  )


(defun runhysim_old(end_development_cache)
  (do* ((requirements (generate-value-cost))
	(HY_TotalCost (sumcost requirements))
        (HY_Plan (propersort (copy-list requirements) #'>  #'(lambda (x) (/ (req-req_value x) (req-req_cost x)))))
        (HY_Completed (list))
        (current_iter 1)
        (end_development nil)
	(end_development_list (copy-list end_development_cache))
        )
       ((or (> current_iter (globdef-num_iters gv)) end_development) (list (cumulativecost HY_Completed #'sumvalue) (cumulativecost HY_Completed #'sumcost)))

    (if (= current_iter 1)
        (progn
          ;(print requirements)
          ;(print PB_Plan)
        ))
    (if (> current_iter (globdef-min_iters gv))
        (setf end_development (pop end_development_list))
        )

    ;(setf HY_Plan (sort (copy-list HY_Plan) #'> :key #'(lambda (x) (/ (first x) (second x)))))
    ;(print "iter")
    ;(print current_iter)
    (do* ((HY_RequirementCompleted)
          (HY_TurningPoint (float (/  (sumvalue HY_Plan) (sumcost HY_Plan))))
          )
	 ((or (= 0 (length (remove-if #'(lambda (x) (or (null (req-req_active x))
                                                        (< (/ (req-req_value x) (req-req_cost x)) HY_TurningPoint))) HY_Plan)))
              (> (+ (req-req_cost (car HY_Plan)) (sumcost HY_Completed)) (/ (* HY_TotalCost current_iter) (globdef-num_iters gv)))
              ))
        ;((or  (= 0 (length HY_Plan)) (< (/ (first (first HY_Plan)) (second (first HY_Plan))) HY_TurningPoint)))
      
      (do* ((HY_RequirementCheck)
	    (found nil)
	    (i 0)
	    )
	   ((or (equal (nth i (remove-if #'(lambda (x) (null (req-req_active x))) HY_Plan)) nil) found)
	    )
	(setf HY_RequirementCheck (nth i HY_Plan))
	;(print HY_RequirementCheck)
        ;(print i)
	(if (>= (/ (req-req_value HY_RequirementCheck) (req-req_cost HY_RequirementCheck)) HY_TurningPoint)
	    (progn
	      (setf HY_RequirementCompleted HY_RequirementCheck)
	      (setf HY_Plan (remove-nth i HY_Plan))
	      (setf (req-req_satisfied HY_RequirementCompleted) t)
	      (setf (req-req_satisfied_in_iter HY_RequirementCompleted) current_iter)
	      (setf HY_Completed (append HY_Completed (list HY_RequirementCompleted)))
	      (setf found t)
	      )
	    )
	(incf i)
	)

      ;(print 'done)
      ;(setf HY_RequirementCompleted (pop HY_Plan))
      ;(print PB_RequirementCompleted)
      ;(setf (req-req_satisfied HY_RequirementCompleted) t)
      ;(setf (req-req_satisfied_in_iter HY_RequirementCompleted) current_iter)
      ;(setf HY_Completed (append HY_Completed (list HY_RequirementCompleted)))
      )
    ;put your code here
   
    ;(print "Plan before Update")
    ;(print HY_Plan)
    (setf HY_Plan (updatevalues HY_Plan))
    (setf HY_Plan (remove-if #'(lambda (x) (if (<= (req-req_value x) 0)
                                               t
                                               nil
                                               ))
                             HY_Plan))
    (setf HY_Plan (addnewrequirements HY_Plan current_iter))
    (if (= 0 (length (remove-if #'(lambda (x) (null (req-req_active x))) HY_Plan)))
        (setf end_development t)
        )
    ;(print "Plan after Update")
    ;(print HY_Plan)
    (incf current_iter)
    )
  )
  
(defun runhysim_v2_old (end_development_cache)
  (do* ((requirements (generate-value-cost))
	(HY_TotalCost (sumcost requirements))
        (HY_Plan (propersort (copy-list requirements) #'>  #'(lambda (x) (/ (req-req_value x) (req-req_cost x)))))
        (HY_Completed (list))
        (current_iter 1)
        (end_development nil)
        (cumCost (list 0))
        (cumValue (list 0))
        (cumCostInIteration 0)
	(end_development_list (copy-list end_development_cache))
        )
       ((or (> current_iter (globdef-num_iters gv)) end_development) (list cumValue cumCost))

       (setf cumCostInIteration 0)
       ;(print (cumulativecost HY_Completed #'sumvalue))
       ;(print cumValue)
    (if (= current_iter 1)
        (progn
          ;(print requirements)
          ;(print PB_Plan)
        ))
    (if (> current_iter (globdef-min_iters gv))
        (setf end_development (pop end_development_list))
        )

    ;(setf HY_Plan (sort (copy-list HY_Plan) #'> :key #'(lambda (x) (/ (first x) (second x)))))
    ;(print "iter")
    ;(print current_iter)
    (do* ((HY_RequirementCompleted)
          (HY_TurningPoint (float (/  (sumvalue HY_Plan) (sumcost HY_Plan))))          
          )
	 ((or (= 0 (length (remove-if #'(lambda (x) (or (null (req-req_active x))
                                                        (< (/ (req-req_value x) (req-req_cost x)) HY_TurningPoint))) HY_Plan)))
              (> (+ (req-req_cost (car HY_Plan)) (sumcost HY_Completed)) (/ (* HY_TotalCost current_iter) (globdef-num_iters gv))))
              (setf cumCost (append cumCost (list (+ (apply '+ (last cumCost)) (float (- (/ HY_TotalCost (globdef-num_iters gv)) cumCostInIteration))))))
              (setf cumValue (append cumValue (last cumValue)))
              )
        ;((or  (= 0 (length HY_Plan)) (< (/ (first (first HY_Plan)) (second (first HY_Plan))) HY_TurningPoint)))    
      (do* ((HY_RequirementCheck)
	    (found nil)
	    (i 0)
	    )
	   ((or (equal (nth i (remove-if #'(lambda (x) (null (req-req_active x))) HY_Plan)) nil) found)
	    )
	(setf HY_RequirementCheck (nth i HY_Plan))
	;(print HY_RequirementCheck)
        ;(print i)
	(if (>= (/ (req-req_value HY_RequirementCheck) (req-req_cost HY_RequirementCheck)) HY_TurningPoint)
	    (progn
	      (setf HY_RequirementCompleted HY_RequirementCheck)
	      (setf HY_Plan (remove-nth i HY_Plan))
	      (setf (req-req_satisfied HY_RequirementCompleted) t)
	      (setf (req-req_satisfied_in_iter HY_RequirementCompleted) current_iter)
	      (setf HY_Completed (append HY_Completed (list HY_RequirementCompleted)))
	      (setf found t)
        ; v2
        (setf cumCost (append cumCost (list (+ (apply '+ (last cumCost)) (req-req_cost HY_RequirementCompleted)))))
        (setf cumValue (append cumValue (list (+ (apply '+ (last cumValue)) (req-req_value HY_RequirementCompleted)))))
        (setf cumCostInIteration (+ cumCostInIteration (req-req_cost HY_RequirementCompleted)))
        ;(setf cumCost (req-req_cost HY_RequirementCompleted))
        ;(print cumCostInIteration)
	      )
      ; v2 add cost anyway to account for thumb twiddling
      

	    )
	(incf i)
	)
  

      ;(print 'done)
      ;(setf HY_RequirementCompleted (pop HY_Plan))
      ;(print PB_RequirementCompleted)
      ;(setf (req-req_satisfied HY_RequirementCompleted) t)
      ;(setf (req-req_satisfied_in_iter HY_RequirementCompleted) current_iter)
      ;(setf HY_Completed (append HY_Completed (list HY_RequirementCompleted)))
      )
    ;put your code here
   
   ;(print (float (/ HY_TotalCost (globdef-num_iters gv))))
   ;(print cumCostInIteration)
   
    ;(print "Plan before Update")
    ;(print HY_Plan)
    (setf HY_Plan (updatevalues HY_Plan))
    (setf HY_Plan (remove-if #'(lambda (x) (if (<= (req-req_value x) 0)
                                               t
                                               nil
                                               ))
                             HY_Plan))
    (setf HY_Plan (addnewrequirements HY_Plan current_iter))
    (if (= 0 (length (remove-if #'(lambda (x) (null (req-req_active x))) HY_Plan)))
        (setf end_development t)
        )
    ;(print "Plan after Update")
    ;(print HY_Plan)
    (incf current_iter)
    )
  )
  
(defun runhysim_v2(end_development_cache)
  (do* ((requirements (generate-value-cost))        
        (HY_TotalCost (sumcost requirements))
;        (requirements (retrieve-initial-requirements requirementsi))        
        (HY_Plan (propersort (copy-list requirements) #'>  #'(lambda (x) (/ (req-req_value x) (req-req_cost x)))))
        ;(HY_Plan (getPlan requirements))
        ;(HY_Heap (getHeap requirements))
        (HY_Completed (list))
        (current_iter 1)
        (end_development nil)
        (cumCost (list 0))
        (cumValue (list 0))
        (cumCostInIteration 0)
	(end_development_list (copy-list end_development_cache))
        )
       ((or (> current_iter (globdef-num_iters gv)) end_development) (list cumValue cumCost))

       (setf cumCostInIteration 0)
       ; (print "PLAN-----------")
       ; (print (printValueCost HY_Plan))
       ; (print (printValueCost HY_Plan nil))
       ; (print "HEAP-----------")
       ; (print (printValueCost HY_Heap))
       ; (print (printValueCost HY_Heap nil))
       ;(print (cumulativecost HY_Completed #'sumvalue))
       ;(print cumValue)
    (if (= current_iter 1)
        (progn
          ;(print requirements)
          ;(print PB_Plan)
        ))
    (if (> current_iter (globdef-min_iters gv))
        (setf end_development (pop end_development_list))
        )
        
    (setf HY_Plan (propersort (copy-list HY_Plan) #'> #'(lambda (x) (/ (req-req_value x) (req-req_cost x)))))

    ;(setf HY_Plan (sort (copy-list HY_Plan) #'> :key #'(lambda (x) (/ (first x) (second x)))))
    ;(print "iter")
    ;(print current_iter)
    (do* ((HY_RequirementCompleted)
          (HY_TurningPoint (float (/  (sumvalue HY_Plan) (sumcost HY_Plan))))          
          )
	 ((or (= 0 (length (remove-if #'(lambda (x) (or (null (req-req_active x))
                                                        (< (/ (req-req_value x) (req-req_cost x)) HY_TurningPoint))) HY_Plan)))
              (> (+ (req-req_cost (car HY_Plan)) (sumcost HY_Completed)) (/ (* HY_TotalCost current_iter) (globdef-num_iters gv)))
              )
              (setf cumCost (append cumCost (list (+ (apply '+ (last cumCost)) (float (- (/ HY_TotalCost (globdef-num_iters gv)) cumCostInIteration))))))
              (setf cumValue (append cumValue (last cumValue)))
              )
        ;((or  (= 0 (length HY_Plan)) (< (/ (first (first HY_Plan)) (second (first HY_Plan))) HY_TurningPoint)))    
           
      ; (print "TP--------------------")
      ; (print HY_TurningPoint)
      (do* ((HY_RequirementCheck)
	    (found nil)
	    (i 0)
	    )
	   ((or (equal (nth i (remove-if #'(lambda (x) (null (req-req_active x))) HY_Plan)) nil) found)
	    )
	(setf HY_RequirementCheck (nth i HY_Plan))
	;(print HY_RequirementCheck)
        ;(print i)
	(if (>= (/ (req-req_value HY_RequirementCheck) (req-req_cost HY_RequirementCheck)) HY_TurningPoint)
	    (progn
	      (setf HY_RequirementCompleted HY_RequirementCheck)
	      (setf HY_Plan (remove-nth i HY_Plan))
	      (setf (req-req_satisfied HY_RequirementCompleted) t)
	      (setf (req-req_satisfied_in_iter HY_RequirementCompleted) current_iter)
	      (setf HY_Completed (append HY_Completed (list HY_RequirementCompleted)))
	      (setf found t)
        ; v2
        (setf cumCost (append cumCost (list (+ (apply '+ (last cumCost)) (req-req_cost HY_RequirementCompleted)))))
        (setf cumValue (append cumValue (list (+ (apply '+ (last cumValue)) (req-req_value HY_RequirementCompleted)))))
        (setf cumCostInIteration (+ cumCostInIteration (req-req_cost HY_RequirementCompleted)))
        ;(setf cumCost (req-req_cost HY_RequirementCompleted))
        ;(print cumCostInIteration)
	      )
      ; v2 add cost anyway to account for thumb twiddling
      

	    )
	(incf i)
	)
  

      ;(print 'done)
      ;(setf HY_RequirementCompleted (pop HY_Plan))
      ;(print PB_RequirementCompleted)
      ;(setf (req-req_satisfied HY_RequirementCompleted) t)
      ;(setf (req-req_satisfied_in_iter HY_RequirementCompleted) current_iter)
      ;(setf HY_Completed (append HY_Completed (list HY_RequirementCompleted)))
      )
    ;put your code here
   
   ;(print (float (/ HY_TotalCost (globdef-num_iters gv))))
   ;(print cumCostInIteration)
   
    ;(print "Plan before Update")
    ;(print HY_Plan)
    
      (setf HY_Plan (updatevalues HY_Plan))
      ;(setf HY_Heap (updatevalues HY_Heap))
      (setf HY_Completed (updatevalues HY_Completed))  
      
      (setf HY_Plan (remove-if #'(lambda (x) (if (<= (req-req_value x) 0)
                                                 t
                                                 nil
                                                 ))
                               HY_Plan))
      ; (setf HY_Heap (remove-if #'(lambda (x) (if (<= (req-req_value x) 0)
                                                 ; t
                                                 ; nil
                                                 ; ))
                               ; HY_Heap))

      ; (setf HY_Heap (addnewrequirements HY_Heap current_iter))
      
      ; take a poission number of reqs from heap and add to plan
    ; (let ((pRandNum (pRandom (globdef-ave_unimpl_req_per_iter gv))))

      ; ; append some poission number of reqs from heap to plan
      ; (if (> pRandNum (length (remove-if #'(lambda (x) (null (req-req_active x))) HY_Heap)))
          ; (setf pRandNum (length (remove-if #'(lambda (x) (null (req-req_active x))) HY_Heap)))
          ; )
      ; (setf HY_Plan (append HY_Plan (car (split-list pRandNum HY_Heap))))
      ; ;(print "debug 3.1")
      ; ; set new heap
      ; (setf HY_Heap (cdr (split-list pRandNum HY_Heap)))
      ; )   
    
    

    (if (= 0 (length (remove-if #'(lambda (x) (null (req-req_active x))) HY_Plan)))
        (setf end_development t)
        )
    ;(print "Plan after Update")
    ;(print HY_Plan)
    (incf current_iter)
    )
  )
  
(defun runhysim(end_development_cache)
  (do* ((requirements (generate-value-cost))        
        (HY_TotalCost (sumcost requirements))
        ;(requirements (retrieve-initial-requirements requirementsi))        
        (HY_Plan (propersort (copy-list requirements) #'>  #'(lambda (x) (/ (req-req_value x) (req-req_cost x)))))
        ;(HY_Plan (getPlan requirements))
        ;(HY_Heap (getHeap requirements))
        (HY_Completed (list))
        (current_iter 1)
        (end_development nil)
        
        (cumCost (list 0))
        (cumValue (list 0))
        (cumCostInIteration 0)
        (end_development_list (copy-list end_development_cache))
        (end_development_iter nil)
        (HY_TotalCost_Adj nil)
        )
       (
        (or (> current_iter (globdef-num_iters gv)) end_development) 
        (list (cumulativecost HY_Completed #'sumvalue) (cumulativecost HY_Completed #'sumcost))
       )
       
      (if (= current_iter 1)
        (progn
          (if (null (position t end_development_list))
            (setf end_development_iter (globdef-num_iters gv))        
            (setf end_development_iter (+ (position t end_development_list) 2))
          )
          (setf HY_TotalCost_Adj (* HY_TotalCost (/ end_development_iter (globdef-num_iters gv))))
        )
      )
      
      ; (print "HY---------")
    ; (if (> (length HY_Completed) 0)
      ; (progn
        ; (format t "~%~s/~s~% " (req-req_value (first HY_Completed)) (req-req_cost (first HY_Completed)))
        ; (format t "~s~% " (req-req_future_values (first HY_Completed)))
      ; )
    ; )
       
       ; (format t "HY_TotalCost = ~s~%" HY_TotalCost)
       ; (format t "HY_TotalCost = ~s~%" HY_TotalCost)

       (setf cumCostInIteration 0)
       ; (print "PLAN-----------")
       ; (print (printValueCost HY_Plan))
       ; (print (printValueCost HY_Plan nil))
       ; (print "HEAP-----------")
       ; (print (printValueCost HY_Heap))
       ; (print (printValueCost HY_Heap nil))
       ;(print (cumulativecost HY_Completed #'sumvalue))
       ;(print cumValue)
    (if (= current_iter 1)
        (progn
          ;(print requirements)
          ;(print PB_Plan)
        ))
    (if (> current_iter (globdef-min_iters gv))
        (setf end_development (pop end_development_list))
        )  
        
    (setf HY_Plan (propersort (copy-list HY_Plan) #'> #'(lambda (x) (/ (req-req_value x) (req-req_cost x)))))

    ;(setf HY_Plan (sort (copy-list HY_Plan) #'> :key #'(lambda (x) (/ (first x) (second x)))))
    ;(print "iter")
    ;(print current_iter)
    (do* ((HY_RequirementCompleted)
          (HY_TurningPoint (float (/  (sumvalue HY_Plan) (sumcost HY_Plan))))          
          )
          ((or (= 0 (length (remove-if #'(lambda (x) (or (null (req-req_active x))
                                                        (< (/ (req-req_value x) (req-req_cost x)) HY_TurningPoint))) HY_Plan)))
              (> (sumcost HY_Completed) HY_TotalCost_Adj)
              ;(> (+ (req-req_cost (car HY_Plan)) (sumcost HY_Completed)) (/ (* HY_TotalCost current_iter) (globdef-num_iters gv)))
              )
              
          )
        ;((or  (= 0 (length HY_Plan)) (< (/ (first (first HY_Plan)) (second (first HY_Plan))) HY_TurningPoint)))    
           
      ; (print "TP--------------------")
      ; (print HY_TurningPoint)
      (do* ((HY_RequirementCheck)
          (found nil)
          (i 0)
          )
         ((or (equal (nth i (remove-if #'(lambda (x) (null (req-req_active x))) HY_Plan)) nil) found)
          )
        (setf HY_RequirementCheck (nth i HY_Plan))
        ;(print HY_RequirementCheck)
              ;(print i)
        (if (>= (/ (req-req_value HY_RequirementCheck) (req-req_cost HY_RequirementCheck)) HY_TurningPoint)
            (progn
              (setf HY_RequirementCompleted HY_RequirementCheck)
              (setf HY_Plan (remove-nth i HY_Plan))
              (setf (req-req_satisfied HY_RequirementCompleted) t)
              (setf (req-req_satisfied_in_iter HY_RequirementCompleted) current_iter)
              (setf HY_Completed (append HY_Completed (list HY_RequirementCompleted)))
              (setf found t)
              ; v2
              (setf cumCost (append cumCost (list (+ (apply '+ (last cumCost)) (req-req_cost HY_RequirementCompleted)))))
              (setf cumValue (append cumValue (list (+ (apply '+ (last cumValue)) (req-req_value HY_RequirementCompleted)))))
              (setf cumCostInIteration (+ cumCostInIteration (req-req_cost HY_RequirementCompleted)))
              ;(setf cumCost (req-req_cost HY_RequirementCompleted))
              ;(print cumCostInIteration)
              )
            ; v2 add cost anyway to account for thumb twiddling
            

        )        
        (incf i)
      )  

      ;(print 'done)
      ;(setf HY_RequirementCompleted (pop HY_Plan))
      ;(print PB_RequirementCompleted)
      ;(setf (req-req_satisfied HY_RequirementCompleted) t)
      ;(setf (req-req_satisfied_in_iter HY_RequirementCompleted) current_iter)
      ;(setf HY_Completed (append HY_Completed (list HY_RequirementCompleted)))
      
    )
      
      
      
      
    ;put your code here
   
   ;(print (float (/ HY_TotalCost (globdef-num_iters gv))))
   ;(print cumCostInIteration)
   
    ;(print "Plan before Update")
    ;(print HY_Plan)
    
      (setf HY_Plan (updatevalues HY_Plan))
      ;(setf HY_Heap (updatevalues HY_Heap))
      (setf HY_Completed (updatevalues HY_Completed))      
      
      (setf HY_Plan (remove-if #'(lambda (x) (if (<= (req-req_value x) 0)
                                                 t
                                                 nil
                                                 ))
                               HY_Plan))      
      ; (setf HY_Heap (remove-if #'(lambda (x) (if (<= (req-req_value x) 0)
                                                 ; t
                                                 ; nil
                                                 ; ))
                               ; HY_Heap))
      (setf HY_Completed (remove-if #'(lambda (x) (if (<= (req-req_value x) 0)
                                                 t
                                                 nil
                                                 ))
                               HY_Completed))                         
                               
      ; ; set completed values to 0 if less than 0
      ; (dolist (compReq HY_Completed)
        ; (if (< (req-req_value compReq) 0)
          ; (setf (req-req_value compReq) 0)
        ; )
      ; )

       (setf HY_Plan (addnewrequirements HY_Plan current_iter))
      
      ; ; take a poission number of reqs from heap and add to plan
    ; (let ((pRandNum (pRandom (globdef-ave_unimpl_req_per_iter gv))))

      ; ; append some poission number of reqs from heap to plan
      ; (if (> pRandNum (length (remove-if #'(lambda (x) (null (req-req_active x))) HY_Heap)))
          ; (setf pRandNum (length (remove-if #'(lambda (x) (null (req-req_active x))) HY_Heap)))
          ; )
      ; (setf HY_Plan (append HY_Plan (car (split-list pRandNum HY_Heap))))
      ; ;(print "debug 3.1")
      ; ; set new heap
      ; (setf HY_Heap (cdr (split-list pRandNum HY_Heap)))
      ; )   
    
    

    (if (= 0 (length (remove-if #'(lambda (x) (null (req-req_active x))) HY_Plan)))
        (setf end_development t)
        )

    ; don't set end_develpment time because we need to update values
    ;(if (not (null HY_Completed))
      ; (if (> (sumcost HY_Completed) HY_TotalCost_Adj)
        ; (setf end_development t)
      ; )
    ;)
    
    ;(print "Plan after Update")
    ;(print HY_Plan)
    (incf current_iter)
    )
  )

; (defun printValueCost (lst &optional (isValue t))
  ; (let ((val (list)))
    ; (dotimes (l lst)
      ; (if isValue
        ; (setf val (append val (list (req-req_value l))))
        ; (setf val (append val (list (req-req_cost l))))
      ; )
    ; )
    ; (print val)
  ; )
; )