(def *col* -1)
(def *projection-matrix* [])
(def *pivots* [])
(declare ChooseObjects ProjectVals) 

(defn FastMap ;[dataset k fnc]
  ([dataset k] (FastMap dataset k EuclideanDistance1))
  ([dataset k fnc] 
     (let [rand-data dataset
	   optdata   (Transpose (reverse (pop (reverse (Transpose rand-data)))))
	   score     (peek (reverse (Transpose rand-data)))]
       (if (<= k 0)
	 (let [result *projection-matrix*
	       pivot-result *pivots*]
	   (def *projection-matrix* [])
	   (def *pivots* [])
	   (def *col* -1)
         ; (Transpose result))
	 (Transpose (conj result score)))
	 (and (def *col* (inc *col*))
	      (let [pivots (ChooseObjects optdata fnc )
		    proj-vals (ProjectVals pivots optdata fnc)]
		(def *pivots* (conj *pivots* pivots))
		(def *projection-matrix* (conj *projection-matrix* proj-vals))
		(FastMap rand-data (- k 1) ProjectionED)))))))
	  
; ChooseObjects
(defn FarPoint [Oi xi dataset fnc col]
  (take 2
	(last
	 (sort-by
	  last
	  (map 
	   #(list (FindPos %1 dataset -1) %1 (fnc [Oi %1 xi %2])) 
	   dataset col))))) 

(defn ChooseObjects [dataset fnc ]
  (let [length    (count dataset)
	counter   (Math/round (rand (- length 1))); is now k
	initialPM (repeat (count dataset) 0)
	emptyPM?  (= (not-empty *projection-matrix*) nil)
	col       (if emptyPM? initialPM (nth *projection-matrix* (dec *col*))) 
	pivot1    (FarPoint (nth dataset counter) (nth col counter) dataset fnc col)
	pivot2    (FarPoint (second pivot1) (nth col (first pivot1)) dataset fnc col)]
    [pivot1 pivot2]))

; Get xi from eqn
(defn ProjectVal [pivots Oi proj-pivots xi fnc]
  (let [distance-a (Math/pow 
		    (fnc [(second (first pivots)) Oi (first proj-pivots) xi]) 2)
	distance-b (Math/pow 
		    (fnc [(second (second pivots)) Oi (second proj-pivots) xi]) 2)
	distance-c (Math/pow 
		    (fnc [(second (first pivots)) (second (second pivots)) 
				  (first proj-pivots) (second proj-pivots)]) 2)]
    (/ (- (+ distance-a distance-c) distance-b) (* 2 distance-c))))

(defn ProjectVals [pivots dataset fnc]    
  (let [col (if (= (not-empty *projection-matrix*) nil) 
	      (repeat (count dataset) 0) (nth *projection-matrix* (dec *col*))) 
	proj-pivots (list (nth col (first (first pivots)))
			  (nth col (first (second pivots))))]
    (map #(ProjectVal pivots %1 proj-pivots %2 fnc) dataset col)))