(ns code.data.data
  (:use (incanter core stats io)))
  
(def incanter-home (System/getProperty "incanter.home")) 

;---------------------------------------------------------------
; Defect Data
;---------------------------------------------------------------

(def ant13 (read-dataset 
                 (str incanter-home "data/defect/ant-1.3.csv")
                 :delim \tab
                 :header true))
(def ant13-header (apply vector (map str (:column-names ant13))))
(def ant13 (to-matrix ant13))

(def ant14 (read-dataset 
                 (str incanter-home "data/defect/ant-1.4.csv")
                 :delim \tab
                 :header true))
(def ant14-header (apply vector (map str (:column-names ant14))))
(def ant14 (to-matrix ant14))

(def ant15 (read-dataset 
                 (str incanter-home "data/defect/ant-1.5.csv")
                 :delim \tab
                 :header true))
(def ant15-header (apply vector (map str (:column-names ant15))))
(def ant15 (to-matrix ant15))

(def ant16 (read-dataset 
                 (str incanter-home "data/defect/ant-1.6.csv")
                 :delim \tab
                 :header true))
(def ant16-header (apply vector (map str (:column-names ant16))))
(def ant16 (to-matrix ant16))

(def ant17 (read-dataset 
                 (str incanter-home "data/defect/ant-1.7.csv")
                 :delim \tab
                 :header true))
(def ant17-header (apply vector (map str (:column-names ant17))))
(def ant17 (to-matrix ant17))

(def arc (read-dataset 
                 (str incanter-home "data/defect/arc.csv")
                 :delim \tab
                 :header true))
(def arc-header (apply vector (map str (:column-names arc))))                 
(def arc (to-matrix arc))

(def berek (read-dataset 
                 (str incanter-home "data/defect/berek.csv")
                 :delim \tab
                 :header true))
(def berek-header (apply vector (map str (:column-names berek))))
(def berek (to-matrix berek))

(def camel10 (read-dataset 
                 (str incanter-home "data/defect/camel-1.0.csv")
                 :delim \tab
                 :header true))
(def camel10-header (apply vector (map str (:column-names camel10))))                 
(def camel10 (to-matrix camel10))

(def camel12 (read-dataset 
                 (str incanter-home "data/defect/camel-1.2.csv")
                 :delim \tab
                 :header true))
(def camel12-header (apply vector (map str (:column-names camel12))))                 
(def camel12 (to-matrix camel12))

(def camel14 (read-dataset 
                 (str incanter-home "data/defect/camel-1.4.csv")
                 :delim \tab
                 :header true))
(def camel14-header (apply vector (map str (:column-names camel14))))                 
(def camel14 (to-matrix camel14))

(def camel16 (read-dataset 
                 (str incanter-home "data/defect/camel-1.6.csv")
                 :delim \tab
                 :header true))
(def camel16-header (apply vector (map str (:column-names camel16))))                 
(def camel16 (to-matrix camel16))

(def ckjm (read-dataset 
                 (str incanter-home "data/defect/ckjm.csv")
                 :delim \tab
                 :header true))
(def ckjm-header (apply vector (map str (:column-names ckjm))))
(def ckjm (to-matrix ckjm))

(def e-learning (read-dataset 
                 (str incanter-home "data/defect/e-learning.csv")
                 :delim \tab
                 :header true))
(def e-learning-header (apply vector (map str (:column-names e-learning))))
(def e-learning (to-matrix e-learning))

(def forrest06 (read-dataset 
                 (str incanter-home "data/defect/forrest-0.6.csv")
                 :delim \tab
                 :header true))
(def forrest06-header (apply vector (map str (:column-names forrest06))))
(def forrest06 (to-matrix forrest06))

(def forrest07 (read-dataset 
                 (str incanter-home "data/defect/forrest-0.7.csv")
                 :delim \tab
                 :header true))
(def forrest07-header (apply vector (map str (:column-names forrest07))))
(def forrest07 (to-matrix forrest07))

(def forrest08 (read-dataset 
                 (str incanter-home "data/defect/forrest-0.8.csv")
                 :delim \tab
                 :header true))
(def forrest08-header (apply vector (map str (:column-names forrest08))))
(def forrest08 (to-matrix forrest08))

(def intercafe (read-dataset 
                 (str incanter-home "data/defect/intercafe.csv")
                 :delim \tab
                 :header true))
(def intercafe-header (apply vector (map str (:column-names intercafe))))
(def intercafe (to-matrix intercafe))

(def ivy11 (read-dataset 
                 (str incanter-home "data/defect/ivy-1.1.csv")
                 :delim \tab
                 :header true))
(def ivy11-header (apply vector (map str (:column-names ivy11))))
(def ivy11 (to-matrix ivy11))

(def ivy14 (read-dataset 
                 (str incanter-home "data/defect/ivy-1.4.csv")
                 :delim \tab
                 :header true))
(def ivy14-header (apply vector (map str (:column-names ivy14))))
(def ivy14 (to-matrix ivy14))

(def ivy20 (read-dataset 
                 (str incanter-home "data/defect/ivy-2.0.csv")
                 :delim \tab
                 :header true))
(def ivy20-header (apply vector (map str (:column-names ivy20))))
(def ivy20 (to-matrix ivy20))

(def jedit32 (read-dataset 
                 (str incanter-home "data/defect/jedit-3.2.csv")
                 :delim \tab
                 :header true))
(def jedit32-header (apply vector (map str (:column-names jedit32))))
(def jedit32 (to-matrix jedit32))

(def jedit40 (read-dataset 
                 (str incanter-home "data/defect/jedit-4.0.csv")
                 :delim \tab
                 :header true))
(def jedit40-header (apply vector (map str (:column-names jedit40))))
(def jedit40 (to-matrix jedit40))

(def jedit41 (read-dataset 
                 (str incanter-home "data/defect/jedit-4.1.csv")
                 :delim \tab
                 :header true))
(def jedit41-header (apply vector (map str (:column-names jedit41))))
(def jedit41 (to-matrix jedit41))

(def jedit42 (read-dataset 
                 (str incanter-home "data/defect/jedit-4.2.csv")
                 :delim \tab
                 :header true))
(def jedit42-header (apply vector (map str (:column-names jedit42))))
(def jedit42 (to-matrix jedit42))

(def jedit43 (read-dataset 
                 (str incanter-home "data/defect/jedit-4.3.csv")
                 :delim \tab
                 :header true))
(def jedit43-header (apply vector (map str (:column-names jedit43))))
(def jedit43 (to-matrix jedit43))

(def kalkulator (read-dataset 
                 (str incanter-home "data/defect/kalkulator.csv")
                 :delim \tab
                 :header true))
(def kalkulator-header (apply vector (map str (:column-names kalkulator))))
(def kalkulator (to-matrix kalkulator))

(def log4j10 (read-dataset 
                 (str incanter-home "data/defect/log4j-1.0.csv")
                 :delim \tab
                 :header true))
(def log4j10-header (apply vector (map str (:column-names log4j10))))
(def log4j10 (to-matrix log4j10))

(def log4j11 (read-dataset 
                 (str incanter-home "data/defect/log4j-1.1.csv")
                 :delim \tab
                 :header true))
(def log4j11-header (apply vector (map str (:column-names log4j11))))
(def log4j11 (to-matrix log4j11))

(def log4j12 (read-dataset 
                 (str incanter-home "data/defect/log4j-1.2.csv")
                 :delim \tab
                 :header true))
(def log4j12-header (apply vector (map str (:column-names log4j12))))
(def log4j12 (to-matrix log4j12))

(def lucene20 (read-dataset 
                 (str incanter-home "data/defect/lucene-2.0.csv")
                 :delim \tab
                 :header true))
(def lucene20-header (apply vector (map str (:column-names lucene20))))
(def lucene20 (to-matrix lucene20))

(def lucene22 (read-dataset 
                 (str incanter-home "data/defect/lucene-2.2.csv")
                 :delim \tab
                 :header true))
(def lucene22-header (apply vector (map str (:column-names lucene22))))
(def lucene22 (to-matrix lucene22))

(def lucene24 (read-dataset 
                 (str incanter-home "data/defect/lucene-2.4.csv")
                 :delim \tab
                 :header true))
(def lucene24-header (apply vector (map str (:column-names lucene24))))
(def lucene24 (to-matrix lucene24))

(def nier (read-dataset 
                 (str incanter-home "data/defect/nieruchomosci.csv")
                 :delim \tab
                 :header true))
(def nier-header (apply vector (map str (:column-names nier))))                 
(def nier (to-matrix nier))

(def pbeans1 (read-dataset 
                 (str incanter-home "data/defect/pbeans1.csv")
                 :delim \tab
                 :header true))
(def pbeans1-header (apply vector (map str (:column-names pbeans1))))                 
(def pbeans1 (to-matrix pbeans1))

(def pbeans2 (read-dataset 
                 (str incanter-home "data/defect/pbeans2.csv")
                 :delim \tab
                 :header true))
(def pbeans2-header (apply vector (map str (:column-names pbeans2))))                 
(def pbeans2 (to-matrix pbeans2))

(def pdf (read-dataset 
                 (str incanter-home "data/defect/pdftranslator.csv")
                 :delim \tab
                 :header true))
(def pdf-header (apply vector (map str (:column-names pdf))))                 
(def pdf (to-matrix pdf))

(def poi15 (read-dataset 
                 (str incanter-home "data/defect/poi-1.5.csv")
                 :delim \tab
                 :header true))
(def poi15-header (apply vector (map str (:column-names poi15))))                 
(def poi15 (to-matrix poi15))

(def poi20 (read-dataset 
                 (str incanter-home "data/defect/poi-2.0.csv")
                 :delim \tab
                 :header true))
(def poi20-header (apply vector (map str (:column-names poi20))))                 
(def poi20 (to-matrix poi20))

(def poi25 (read-dataset 
                 (str incanter-home "data/defect/poi-2.5.csv")
                 :delim \tab
                 :header true))
(def poi25-header (apply vector (map str (:column-names poi25))))                 
(def poi25 (to-matrix poi25))

(def poi30 (read-dataset 
                 (str incanter-home "data/defect/poi-3.0.csv")
                 :delim \tab
                 :header true))
(def poi30-header (apply vector (map str (:column-names poi30))))                 
(def poi30 (to-matrix poi30))

(def redaktor (read-dataset 
                 (str incanter-home "data/defect/redaktor.csv")
                 :delim \tab
                 :header true))
(def redaktor-header (apply vector (map str (:column-names redaktor))))                 
(def redaktor (to-matrix redaktor))

(def serapion (read-dataset 
                 (str incanter-home "data/defect/serapion.csv")
                 :delim \tab
                 :header true))
(def serapion-header (apply vector (map str (:column-names serapion))))
(def serapion (to-matrix serapion))

(def skarbonka (read-dataset 
                 (str incanter-home "data/defect/skarbonka.csv")
                 :delim \tab
                 :header true))
(def skarbonka-header (apply vector (map str (:column-names skarbonka))))
(def skarbonka (to-matrix skarbonka))

(def sklebagd (read-dataset 
                 (str incanter-home "data/defect/sklebagd.csv")
                 :delim \tab
                 :header true))
(def sklebagd-header (apply vector (map str (:column-names sklebagd))))
(def sklebagd (to-matrix sklebagd))

(def synapse10 (read-dataset 
                 (str incanter-home "data/defect/synapse-1.0.csv")
                 :delim \tab
                 :header true))
(def synapse10-header (apply vector (map str (:column-names synapse10))))
(def synapse10 (to-matrix synapse10))

(def synapse11 (read-dataset 
                 (str incanter-home "data/defect/synapse-1.1.csv")
                 :delim \tab
                 :header true))
(def synapse11-header (apply vector (map str (:column-names synapse11))))
(def synapse11 (to-matrix synapse11))

(def synapse12 (read-dataset 
                 (str incanter-home "data/defect/synapse-1.2.csv")
                 :delim \tab
                 :header true))
(def synapse12-header (apply vector (map str (:column-names synapse12))))
(def synapse12 (to-matrix synapse12))

(def systemdata (read-dataset 
                 (str incanter-home "data/defect/systemdata.csv")
                 :delim \tab
                 :header true))
(def systemdata-header (apply vector (map str (:column-names systemdata))))
(def systemdata (to-matrix systemdata))

(def szybkafucha (read-dataset 
                 (str incanter-home "data/defect/szybkafucha.csv")
                 :delim \tab
                 :header true))
(def szybkafucha-header (apply vector (map str (:column-names szybkafucha))))
(def szybkafucha (to-matrix szybkafucha))

(def termoproject (read-dataset 
                 (str incanter-home "data/defect/termoproject.csv")
                 :delim \tab
                 :header true))
(def termoproject-header (apply vector (map str (:column-names termoproject))))
(def termoproject (to-matrix termoproject))

(def tomcat (read-dataset 
                 (str incanter-home "data/defect/tomcat.csv")
                 :delim \,
                 :header true))
(def tomcat-header (apply vector (map str (:column-names tomcat))))
(def tomcat (to-matrix tomcat))

(def velocity14 (read-dataset 
                 (str incanter-home "data/defect/velocity-1.4.csv")
                 :delim \tab
                 :header true))
(def velocity14-header (apply vector (map str (:column-names velocity14))))                 
(def velocity14 (to-matrix velocity14))

(def velocity15 (read-dataset 
                 (str incanter-home "data/defect/velocity-1.5.csv")
                 :delim \tab
                 :header true))
(def velocity15-header (apply vector (map str (:column-names velocity15))))                 
(def velocity15 (to-matrix velocity15))

(def velocity16 (read-dataset 
                 (str incanter-home "data/defect/velocity-1.6.csv")
                 :delim \tab
                 :header true))
(def velocity16-header (apply vector (map str (:column-names velocity16))))                 
(def velocity16 (to-matrix velocity16))

(def workflow (read-dataset 
                 (str incanter-home "data/defect/workflow.csv")
                 :delim \tab
                 :header true))
(def workflow-header (apply vector (map str (:column-names workflow))))                 
(def workflow (to-matrix workflow))

(def wsp (read-dataset 
                 (str incanter-home "data/defect/wspomaganiepi.csv")
                 :delim \tab
                 :header true))
(def wsp-header (apply vector (map str (:column-names wsp))))
(def wsp (to-matrix wsp))

(def xalan24 (read-dataset 
                 (str incanter-home "data/defect/xalan-2.4.csv")
                 :delim \tab
                 :header true))
(def xalan24-header (apply vector (map str (:column-names xalan24))))                 
(def xalan24 (to-matrix xalan24))

(def xalan25 (read-dataset 
                 (str incanter-home "data/defect/xalan-2.5.csv")
                 :delim \tab
                 :header true))
(def xalan25-header (apply vector (map str (:column-names xalan25))))                 
(def xalan25 (to-matrix xalan25))

(def xalan26 (read-dataset 
                 (str incanter-home "data/defect/xalan-2.6.csv")
                 :delim \tab
                 :header true))
(def xalan26-header (apply vector (map str (:column-names xalan26))))                 
(def xalan26 (to-matrix xalan26))

(def xalan27 (read-dataset 
                 (str incanter-home "data/defect/xalan-2.7.csv")
                 :delim \tab
                 :header true))
(def xalan27-header (apply vector (map str (:column-names xalan27))))                 
(def xalan27 (to-matrix xalan27))

(def xerces (read-dataset 
                 (str incanter-home "data/defect/xerces-init.csv") 
                 :delim \tab
                 :header true))
(def xerces-header (apply vector (map str (:column-names xerces))))                 
(def xerces (to-matrix xerces))

(def xerces12 (read-dataset 
                 (str incanter-home "data/defect/xerces-1.2.csv") 
                 :delim \tab
                 :header true))
(def xerces12-header (apply vector (map str (:column-names xerces12))))                 
(def xerces12 (to-matrix xerces12))

(def xerces13 (read-dataset 
                 (str incanter-home "data/defect/xerces-1.3.csv") 
                 :delim \tab
                 :header true))
(def xerces13-header (apply vector (map str (:column-names xerces13))))                 
(def xerces13 (to-matrix xerces13))

(def xerces14 (read-dataset 
                 (str incanter-home "data/defect/xerces-1.4.csv") 
                 :delim \tab
                 :header true))
(def xerces14-header (apply vector (map str (:column-names xerces14))))                 
(def xerces14 (to-matrix xerces14))

(def zuzel (read-dataset 
                 (str incanter-home "data/defect/zuzel.csv")
                 :delim \tab
                 :header true))
(def zuzel-header (apply vector (map str (:column-names zuzel))))
(def zuzel (to-matrix zuzel))