(defun generate-value-cost(&optional (numofreqs (globdef-num_reqs gv)))
  (let ((x  nil) (i 0))
    (progn
      (for i 0 (- numofreqs 1)
        ;(setf x (append (list (list (random-between-int (globdef-min_value gv) (globdef-max_value gv)) (random-between-int (globdef-min_cost gv) (globdef-max_cost gv)))) x))
        (setf x (append (list (make-req :req_value (random-between-int (globdef-min_value gv) (globdef-max_value gv)) :req_cost (random-between-int (globdef-min_cost gv) (globdef-max_cost gv)) :req_future_values (generate-value-changes) :req_active t)) x))
        )
      (for j 1 (- (globdef-num_iters gv) 1)
        (for k 0 (- (pRandom (globdef-ave_new_req_per_iter gv)) 1)
          (setf x (append x (list (make-req :req_value (random-between-int (globdef-min_value gv) (globdef-max_value gv)) :req_cost (random-between-int (globdef-min_cost gv) (globdef-max_cost gv)) :req_future_values (generate-value-changes) :req_active nil :req_activate_at_iter j))))
          )
        )
      x)
    )
 )

(defun generate-value-changes(&optional (numofchanges (globdef-num_iters gv)) (sigma (globdef-req_value_sigma gv)))
  (let ((x nil) (i 0))
    (for i 0 (- numofchanges 1)
      (setf x (append x (list (randnorm 0 (* (globdef-max_value gv) sigma)))))
      )
    x
    )
  )

(defun generate-end-development(&optional (numofresults (globdef-num_iters gv)) (probabilitydist (globdef-end_dev_prob gv)))
  (let ((x nil) (i 0))
    (for i 0 (- numofresults 1)
      (setf x (append x (list (randbin1 probabilitydist))))
      )
    x
    )
  )

;(defun sumvalue(valuecost &optional start end)
 ; (if (null start)
      ;(setf start 0)
  ;)
  ;(eval (append '(+) (mapcar #'(lambda (x) (req-req_value x)) (subseq valuecost start end))))
  ;)

(defun sumvalue(valuecost &optional start end (activeOnly t))
  (if (null start)
      (setf start 0)
     )
  (if (null activeOnly)
      (eval (append '(+) (mapcar #'(lambda (x) (req-req_value x)) (subseq valuecost start end))))
      (eval (append '(+) (mapcar #'(lambda (x) (if(null (req-req_active x))
                                                  0
                                                  (req-req_value x))) (subseq valuecost start end))))
     )
  )

(defun sumcost(valuecost &optional start end (activeOnly t))
  (if (null start)
      (setf start 0)
     )
  (if (null activeOnly)
      (eval (append '(+) (mapcar #'(lambda (x) (req-req_cost x)) (subseq valuecost start end))))
      (eval (append '(+) (mapcar #'(lambda (x) (if(null (req-req_active x))
                                                  0
                                                  (req-req_cost x))) (subseq valuecost start end))))
     )
  )

(defun cumulativecost(valuecosts retfn &optional (currentstart 0) (currentend 0))
  (if (= currentend (+ (length valuecosts) 1))
      nil
      (append (list (funcall retfn valuecosts currentstart currentend)) (cumulativecost valuecosts retfn currentstart (+ currentend 1)))
      )
  )