diff --git a/ID3Tree.cpp b/ID3Tree.cpp
new file mode 100644
index 0000000..d727f83
--- /dev/null
+++ b/ID3Tree.cpp
@@ -0,0 +1,435 @@
+/***
+决策树，ID3,C4.5,树回归
+
+考虑
+
+1信息增益，信息增益率，最小均方差(树回归中又有值回归和模型回归)
+2属性类型（double，string）连续值和缺损值
+3剪枝
+**/
+
+
+
+#include <iostream>
+#include <stdlib.h>
+#include <string>
+#include <math.h>
+#include <fstream>
+#include <sstream>
+#include <stack>
+#define MAX_SIZE_OF_TRAINING_SET 100
+#define ATTR_NUM 5
+#define JC_ATTR_KIND 10
+#define FET_ATTR_KIND 10
+using namespace std;
+struct data
+{
+    int id;
+    string attr[ATTR_NUM];//用于字符串属性
+    double attr_double[ATTR_NUM];//用于数值型属性
+    data *next;
+};
+struct matrixTree
+{
+    int id;
+    int splitfet;
+    string fetvalue;
+    string jc_attr;
+    int len;
+    int kind;
+    int parent;
+    matrixTree *next;
+    struct data *data;//可用于记录data的指针头
+};
+matrixTree matrixtree[MAX_SIZE_OF_TRAINING_SET];//用作存储后序遍历生成树的序列
+stack<matrixTree> s;
+int node=0;//用作存储后序遍历生成树的序列数组的下标
+int fetflag[ATTR_NUM]= {0,0,0,0,0}; //初始化为0,最后一个用于统计还剩多少特征未使用
+// 计算划分后子集的信息熵，该信息熵由子集中决策属性出现的概率决定
+string* getkindattr(data *dataSet,int axis)
+{
+    int i,j,kind=0;
+    data *p;
+    p=dataSet->next;
+    string attr_kind_sum[JC_ATTR_KIND];
+    string *att=new string[JC_ATTR_KIND];
+    for(i=0; p!=NULL; i++)
+    {
+        for(j=0; j<kind; j++)
+        {
+            if(p->attr[axis]==attr_kind_sum[j])
+            {
+                break;
+            }
+        }
+        if(j==kind)
+        {
+            attr_kind_sum[kind]=p->attr[axis];
+            kind++;
+        }
+        p=p->next;
+    }
+    attr_kind_sum[kind]="0";
+    i=0;
+    while(attr_kind_sum[i]!="0")
+    {
+        att[i]=attr_kind_sum[i];
+        i++;
+    }
+    att[i]="0";
+    //检查得到当前特征所有可能的取值是否正确
+    /*
+    for(i=0; attr_kind_sum[i]!="0"; i++)
+    {
+        cout<<attr_kind_sum[i]<<"  ";
+    }
+    cout<<endl;*/
+    return att;
+}
+
+double calcShannonEnt(data *dataSet)
+{
+    int i,j;
+    double len=0;
+    data *p;
+    p=dataSet->next;
+    string *jc_attr_kind=(string *)malloc(sizeof(string)*JC_ATTR_KIND);
+    jc_attr_kind=getkindattr(dataSet,ATTR_NUM-1);
+    double jc_attr_kind_sum[JC_ATTR_KIND];
+    double prob=0;
+    double shannoEnt=0;
+    for(i=0; i<JC_ATTR_KIND; i++)
+    {
+        jc_attr_kind_sum[i]=0;
+    }
+    for(i=0; p!=NULL; i++)
+    {
+        for(j=0; jc_attr_kind[j]!="0"; j++)
+        {
+            if(p->attr[ATTR_NUM-1]==jc_attr_kind[j])//初始化为0记得
+            {
+                jc_attr_kind_sum[j]++;
+            }
+        }
+        len++;
+        p=p->next;
+    }
+    //统计该子数据集上的所有样本的决策属性以及不同决策属性上样本数
+    for(i=0; jc_attr_kind[i]!="0"; i++)
+    {
+        cout<<"subdatasetLen="<<len<<"   "<<jc_attr_kind[i]<<"="<<jc_attr_kind_sum[i]<<endl;
+    }
+    for(i=0; i<JC_ATTR_KIND; i++)
+    {
+        if(jc_attr_kind_sum[i]!=0)
+        {
+            prob=jc_attr_kind_sum[i]/len;
+            shannoEnt-=prob*log(prob);
+        }
+    }
+    //检测信息熵计算是否正确
+    cout<<"shannoEnt="<<shannoEnt<<endl;
+    return shannoEnt;
+}
+
+data* splitDataSet(data *dataSet,int axis,string value)
+{
+    data *subDataSet;//=(data *)malloc(sizeof(data)*MAX_SIZE_OF_TRAINING_SET);
+    subDataSet=new data;
+    subDataSet->next=NULL;
+    data *q=subDataSet;
+    data  *p;
+    data *datatmp;
+    p=dataSet->next;
+    int i,j,k;
+    for(i=0; p!=NULL; i++)
+    {
+        if(p->attr[axis]==value)
+        {
+            datatmp=new data;
+            datatmp->next=NULL;
+            datatmp->id=p->id;
+            for(k=0; k<ATTR_NUM; k++)
+                datatmp->attr[k]=p->attr[k];
+            q->next=datatmp;
+            q=q->next;
+        }
+        p=p->next;
+    }
+    q=subDataSet->next;
+    cout<<"value="<<value;
+    while(q!=NULL)
+    {
+        cout<<" "<<q->id;
+        q=q->next;
+    }
+    cout<<endl;
+    return subDataSet;
+}
+
+int chooseBestFectureTosplit(data *dataSet,double minInfoGain,int minLen)
+{
+    int i,j,k;
+    double baseEnt=calcShannonEnt(dataSet);
+    double newEnt=0;
+    double bestInfoGain=0;
+    int bestFeature=-1;
+    double infoGain=0;
+    double splitInfo=0;
+    double gainRatio=0;
+    double prob=0;
+    double len=0;
+    data *subDataSet;
+    data *p;
+    p=dataSet->next;
+    string *fet_attr_kind[ATTR_NUM-1];
+    int *fet_attr_kind_sum[ATTR_NUM-1];//初始化为0记得
+    for(i=0; i<ATTR_NUM-1; i++)
+    {
+        if(fetflag[i]!=1)
+        {
+            fet_attr_kind_sum[i]=(int *)malloc(sizeof(int)*FET_ATTR_KIND);
+            fet_attr_kind[i]=(string *)malloc(sizeof(string)*FET_ATTR_KIND);
+            fet_attr_kind[i]=getkindattr(dataSet,i);
+            for(j=0; j<FET_ATTR_KIND; j++)
+                fet_attr_kind_sum[i][j]=0;
+        }
+    }
+    for(i=0; p!=NULL; i++)
+    {
+        for(j=0; j<ATTR_NUM-1; j++)
+        {
+            if(fetflag[j]!=1)
+            {
+                for(k=0; fet_attr_kind[j][k]!="0"; k++)
+                {
+                    if(p->attr[j]==fet_attr_kind[j][k])
+                    {
+                        fet_attr_kind_sum[j][k]++;
+                    }
+                }
+            }
+        }
+        len++;
+        p=p->next;
+    }
+    for(i=0; i<ATTR_NUM-1; i++)
+    {
+        if(fetflag[i]!=1)
+        {
+            newEnt=0;
+            splitInfo=0;
+            gainRatio=0;
+            for(j=0; fet_attr_kind[i][j]!="0"; j++)
+            {
+                subDataSet=splitDataSet(dataSet,i,fet_attr_kind[i][j]);
+                int sublen=0;
+                p=subDataSet->next;
+                while(p!=NULL)
+                {
+                    sublen++;
+                    p=p->next;
+                }
+                if(sublen<minLen)
+                {
+                    newEnt=100;//结束本次循环后，把此次的信息熵置为MAX，即不选择该属性
+                    break;//预剪枝操作
+                }
+                prob=fet_attr_kind_sum[i][j]/len;
+                splitInfo+=(-log(prob)*prob);//计算信息增益率的分母
+                cout<<"splitInfo="<<splitInfo<<endl;
+                newEnt+=prob*calcShannonEnt(subDataSet);
+            }
+            //gainRatio=newEnt/splitInfo;//计算信息增益率
+            infoGain=baseEnt-newEnt;
+            cout<<"newEnt="<<newEnt<<endl;
+            cout<<"fet="<<i<<"infogain="<<infoGain<<endl;
+            if(infoGain>bestInfoGain&&infoGain>minInfoGain)//信息增益必须大于阈值，才考虑用于属性分裂
+            {
+                bestInfoGain=infoGain;
+                bestFeature=i;
+            }
+        }
+    }
+    cout<<"bestFet="<<bestFeature<<endl;
+    return bestFeature;
+}
+matrixTree dataToTree(data *dataSet,int bbestFet)
+{
+    int i,j,k;
+    int signalflag=1;
+    int len=0;
+    int bestFet=0;
+    data *p;
+    p=dataSet->next;
+    string fet_attr_kind[ATTR_NUM-1][FET_ATTR_KIND];
+    int fet_attr_kind_sum[ATTR_NUM-1][FET_ATTR_KIND];//初始化为0记得
+    for(i=0; p!=NULL; i++)
+    {
+        if(p->attr[ATTR_NUM-1]!=dataSet->next->attr[ATTR_NUM-1])
+        {
+            signalflag=0;
+        }
+        len++;
+        p=p->next;
+    }
+    if(signalflag||len==1)//只有一类样本
+    {
+        matrixtree[node].jc_attr=dataSet->next->attr[ATTR_NUM-1];//data->next指向当前样本集第一样本
+        matrixtree[node].splitfet=-1;
+        matrixtree[node].fetvalue=dataSet->next->attr[bbestFet];
+        matrixtree[node].parent=bbestFet;
+        matrixtree[node].len=len;
+        matrixtree[node].id=node;
+        node++;
+        return matrixtree[node];
+    }
+    fetflag[ATTR_NUM-1]=0;
+    for(i=0; i<ATTR_NUM-1; i++)
+        fetflag[ATTR_NUM-1]+=fetflag[i];
+    //cout<<"fetflaglast="<<fetflag[ATTR_NUM-1]<<endl;
+    if(fetflag[ATTR_NUM-1]==ATTR_NUM-1)//所有属性都使用完了
+    {
+        matrixtree[node].jc_attr=dataSet->next->attr[ATTR_NUM-1];
+        matrixtree[node].splitfet=-1;
+        matrixtree[node].fetvalue=dataSet->next->attr[bbestFet];
+        matrixtree[node].parent=bbestFet;
+        matrixtree[node].len=len;
+        matrixtree[node].id=node;
+        //cout<<"fetflag=1   "<<matrixtree[node].jc_attr<<endl;
+        node++;
+        return matrixtree[node];
+    }
+    bestFet=chooseBestFectureTosplit(dataSet,0.01,2);
+    if(bestFet==-1)//如果最大的信息增益小于预设的最小信息增益或者是子树中样本数小于预设的最小数也返回
+    {
+        matrixtree[node].jc_attr=dataSet->next->attr[ATTR_NUM-1];
+        matrixtree[node].splitfet=-1;
+        matrixtree[node].fetvalue=dataSet->next->attr[bbestFet];
+        matrixtree[node].parent=bbestFet;
+        matrixtree[node].len=len;
+        matrixtree[node].id=node;
+        //cout<<"fetflag=1   "<<matrixtree[node].jc_attr<<endl;
+        node++;
+        return matrixtree[node];
+    }
+    fetflag[bestFet]=1;//选出最好的分裂属性之后，在返回分裂之前，不必再考虑用该属性进行分裂
+    string *attr_kind_sum=getkindattr(dataSet,bestFet);//获得当前分裂属性有多少种取值
+    for(i=0; attr_kind_sum[i]!="0"; i++);
+    int kind=i;//用于记录当前分裂属性有多少种取值
+    for(j=0; j<kind; j++)//分裂后的子集按序建树，同样也可以先对样本多的子集先进行建树，方便决策的时候能更大概率的先找到匹配的
+    {
+        matrixtree[node]=dataToTree(splitDataSet(dataSet,bestFet,attr_kind_sum[j]),bestFet);
+    }
+    fetflag[bestFet]=0;//每次返回上一节点时，把之前分裂的属性从新回收，可以用作下次分裂
+    matrixtree[node].splitfet=bestFet;
+    matrixtree[node].fetvalue=dataSet->next->attr[bbestFet];
+    matrixtree[node].parent=bbestFet;
+    matrixtree[node].jc_attr="-1";
+    matrixtree[node].len=len;
+    matrixtree[node].kind=kind;
+    matrixtree[node].id=node;
+    node++;
+    return matrixtree[node];
+}
+void loadData(data *dataSet)
+{
+    ifstream infile;
+    string tmpstrline;
+    string tmpstr;
+    data *p;
+    p=dataSet;
+    data *datatmp;
+    infile.open("data\\id3.txt",ios::in);
+    int i=0,j=0,yblen=0,fetlen=0;
+    while(!infile.eof()&&i<MAX_SIZE_OF_TRAINING_SET)
+    {
+        j=0;
+        getline(infile,tmpstrline,'\n');//读取文件中一行的数据，保存为string类型
+        stringstream input(tmpstrline);
+        if(tmpstrline!="\0")////由于读取文件结束符同样会继续该操作
+        {
+            datatmp=new data;
+            datatmp->id=i;
+            datatmp->next=NULL;
+            while(input>>tmpstr)
+            {
+                datatmp->attr[j]=tmpstr;
+                j++;
+                fetlen=j;
+            }
+            i++;
+            p->next=datatmp;
+            p=p->next;
+        }
+    }
+    //检测数据加载是否正确
+    /*
+    yblen=i;
+    p=dataSet->next;
+    for(i=0; p!=NULL; i++)
+    {
+        for(j=0; j<fetlen; j++)
+        {
+            cout<<p->attr[j]<<"  ";
+        }
+        p=p->next;
+        cout<<endl;
+    }*/
+}
+int createTree()
+{
+    int i,j;
+    int len;
+    matrixTree *child;
+    matrixTree *p;
+    for(i=0;i<node;i++)
+    {
+        if(matrixtree[i].splitfet==-1)
+        {
+            s.push(matrixtree[i]);
+        }
+        else
+        {
+            len=matrixtree[i].len;
+            p=&matrixtree[i];
+            while((len))
+            {
+                len-=s.top().len;
+                child=new matrixTree;
+                *child=s.top();
+                s.pop();
+                p->next=child;
+                p=p->next;
+            }
+            s.push(matrixtree[i]);
+        }
+    }
+    s.pop();
+    return 0;
+}
+int main()
+{
+    data *dataSet=new data;
+    dataSet->next=NULL;
+    loadData(dataSet);
+    dataToTree(dataSet,0);//初值很重要，当返回到根节点时，如取-1，则会无法访问根节点上的属性特征值
+    //createTree();
+    //第二个参数的取值即表示根节点的父节点
+    for(int i=0; i<node; i++)
+        cout<<"node="<<i<<"  splitfet="<<matrixtree[i].splitfet<<"  "<<"jc_attr="\
+        <<matrixtree[i].jc_attr<<"  "<<"len="<<matrixtree[i].len<<"  parent="<<matrixtree[i].parent<<"  value="<<matrixtree[i].fetvalue<<endl;
+    createTree();
+    matrixTree *p;
+    for(int i=0;i<node;i++)
+    {
+        p=&matrixtree[i];
+        while(p!=NULL)
+        {
+            cout<<p->id<<"  ";
+            p=p->next;
+        }
+        cout<<endl;
+    }
+    return 0;
+}
diff --git a/MDP.cpp b/MDP.cpp
new file mode 100644
index 0000000..c087463
--- /dev/null
+++ b/MDP.cpp
@@ -0,0 +1,224 @@
+/***
+马尔科夫决策过程值迭代，关键在于第一次迭代要例外，
+因为目标状态是一个终止状态，放到迭代循环里面会出现
+临近的状态回报函数无限的，发散。
+迭代过程采用的是异步迭代，即每一次内层循环找到更优的
+回报就立即更新最大回报，以便与之相邻的状态能立即更新到最优
+*/
+
+/****
+值迭代
+同步更新
+12*12*7
+
+*/
+
+
+#include <iostream>
+using namespace std;
+#define size 12
+int main()
+{
+    int matrix[size][size]=
+    {
+        {0,1,0,0,1,0,0,0,0,0,0,0},
+        {1,0,1,0,0,0,0,0,0,0,0,0},
+        {0,1,0,1,0,0,1,0,0,0,0,0},
+        {0,0,0,0,0,0,0,0,0,0,0,0},
+        {1,0,0,0,0,0,0,0,1,0,0,0},
+        {0,0,0,0,0,0,0,0,0,0,0,0},
+        {0,0,1,0,0,0,0,1,0,0,1,0},
+        {0,0,0,0,0,0,0,0,0,0,0,0},
+        {0,0,0,0,1,0,0,0,0,1,0,0},
+        {0,0,0,0,0,0,0,0,1,0,1,0},
+        {0,0,0,0,0,0,1,0,0,1,0,1},
+        {0,0,0,0,0,0,0,1,0,0,1,0}
+    };
+    double reward[size]=
+    {
+        -0.02,-0.02,-0.02,1,
+        -0.02,0,-0.02,-1,
+        -0.02,-0.02,-0.02,-0.02
+    };
+    double maxreward[size]= {0,0,0,0,0,0,0,0,0,0,0,0};
+    int action[size]= {4,0,1,-1,8,-1,10,-1,9,8,9,10}; //上右下左{1,2,3,4}
+    int i=0,j=0,count=0;
+    bool flag=0;
+    for(i=0;i<size;i++)
+        maxreward[i]=reward[i];
+    while(!flag)
+    {
+        flag=1;
+        for(i=0; i<size; i++)
+        {
+            if(action[i]>0||action[i]==0)
+                maxreward[i]=reward[i]+maxreward[action[i]];
+            else
+                maxreward[i]=reward[i];
+        }//放到这意味着同步更新，count=1008是12*12的7倍，即扫了7遍
+        for(i=0; i<size; i++)//对每一个状态求最大的V(s)
+        {
+            for(j=0; j<size; j++)//策略迭代的话这里其实可以换做扫一遍策略集，这也就是和值迭代不同的地方
+            {
+                //cout<<"i="<<i<<"  "<<maxreward[i]<<"  "<<endl;
+                if(matrix[i][j]==1&&maxreward[j]>maxreward[i]-reward[i]+0.0001)//更新累积回报
+                {
+                    action[i]=j;
+                    //if(action[i]>0||action[i]==0)
+                        //maxreward[i]=reward[i]+maxreward[action[i]];//放到这是异步更新，
+                    //else
+                      //  maxreward[i]=reward[i];
+                    flag=0;//当累积回报不再更新，即不进入该if，那么就结束迭代
+                }
+                count++;
+            }
+        }
+    }
+    for(i=0; i<size; i++)
+    {
+        cout<<action[i]+1<<"    ";
+    }
+    cout<<endl;
+    for(i=0; i<size; i++)
+    {
+        cout<<maxreward[i]<<"  ";
+    }
+    cout<<endl<<"count="<<count<<endl;
+    return 0;
+}
+
+
+/*
+值迭代 异步更新 12*12*4
+*/
+/*
+#include <iostream>
+using namespace std;
+#define size 12
+int main()
+{
+    int matrix[size][size]=
+    {
+        {0,1,0,0,1,0,0,0,0,0,0,0},
+        {1,0,1,0,0,0,0,0,0,0,0,0},
+        {0,1,0,1,0,0,1,0,0,0,0,0},
+        {0,0,0,0,0,0,0,0,0,0,0,0},
+        {1,0,0,0,0,0,0,0,1,0,0,0},
+        {0,0,0,0,0,0,0,0,0,0,0,0},
+        {0,0,1,0,0,0,0,1,0,0,1,0},
+        {0,0,0,0,0,0,0,0,0,0,0,0},
+        {0,0,0,0,1,0,0,0,0,1,0,0},
+        {0,0,0,0,0,0,0,0,1,0,1,0},
+        {0,0,0,0,0,0,1,0,0,1,0,1},
+        {0,0,0,0,0,0,0,1,0,0,1,0}
+    };
+    double reward[size]=
+    {
+        -0.02,-0.02,-0.02,1,
+        -0.02,0,-0.02,-1,
+        -0.02,-0.02,-0.02,-0.02
+    };
+    double maxreward[size]= {0,0,0,0,0,0,0,0,0,0,0,0};
+    //double sumreward[size]={0,0,0,0,0,0,0,0,0,0,0,0};
+    int i=0,j=0,count=0;
+    bool flag=0;
+    for(i=0; i<size; i++)
+        maxreward[i]=reward[i];
+    while(!flag)
+    {
+        flag=1;
+        for(i=0; i<size; i++)//对每一个状态求最大的V(s)
+        {
+            for(j=0; j<size; j++) //由于不是策略迭代，只能遍历所有的状态，找出能到的，且更优的
+            {
+                if(matrix[i][j]==1&&maxreward[j]>maxreward[i]-reward[i]+0.0001)//double类型比较大小的偏差，加上一个小数作为精度
+                {
+                    maxreward[i]=reward[i]+maxreward[j];//异步更新
+                    flag=0;
+                }
+                count++;
+            }
+        }
+    }
+    for(i=0; i<size; i++)
+        cout<<maxreward[i]<<"  ";
+    cout<<endl<<"count="<<count<<endl;
+    return 0;
+}
+*/
+
+/***
+
+策略迭代+异步更新
+
+12*4*4
+*/
+/*
+#include <iostream>
+using namespace std;
+#define size 12
+#define ACTION 4
+int main()
+{
+    int matrix[size][size]=
+    {
+        {0,1,0,0,1,0,0,0,0,0,0,0},
+        {1,0,1,0,0,0,0,0,0,0,0,0},
+        {0,1,0,1,0,0,1,0,0,0,0,0},
+        {0,0,0,0,0,0,0,0,0,0,0,0},
+        {1,0,0,0,0,0,0,0,1,0,0,0},
+        {0,0,0,0,0,0,0,0,0,0,0,0},
+        {0,0,1,0,0,0,0,1,0,0,1,0},
+        {0,0,0,0,0,0,0,0,0,0,0,0},
+        {0,0,0,0,1,0,0,0,0,1,0,0},
+        {0,0,0,0,0,0,0,0,1,0,1,0},
+        {0,0,0,0,0,0,1,0,0,1,0,1},
+        {0,0,0,0,0,0,0,1,0,0,1,0}
+    };
+    double reward[size]=
+    {
+        -0.02,-0.02,-0.02,1,
+        -0.02,0,-0.02,-1,
+        -0.02,-0.02,-0.02,-0.02
+    };
+    double maxreward[size]= {0,0,0,0,0,0,0,0,0,0,0,0};
+    int action[size]= {4,0,1,-1,8,-1,10,-1,9,8,9,10}; //上右下左{1,2,3,4}
+    int ac[ACTION]={-4,1,4,-1};
+    int i=0,j=0,count=0;
+    bool flag=0;
+        for(i=0;i<size;i++)
+        maxreward[i]=reward[i];
+    while(!flag)
+    {
+        flag=1;
+        for(i=0; i<size; i++)//对每一个状态求最大的V(s)
+        {
+            for(j=0; j<ACTION; j++)//策略迭代的话这里其实可以换做扫一遍策略集，这也就是和值迭代不同的地方
+            {
+                //cout<<"i="<<i<<"  "<<maxreward[i]<<"  "<<endl;
+                if(matrix[i][ac[j]+i]==1&&maxreward[ac[j]+i]>maxreward[i]-reward[i]+0.0001)
+                {
+                    action[i]=j;
+                    //if(reward[i]!=1&&reward[i]!=-1)
+                        maxreward[i]=reward[i]+maxreward[ac[j]+i];
+                    //else
+                    //    maxreward[i]=reward[i];
+                    flag=0;
+                }
+                count++;
+            }
+        }
+    }
+    for(i=0; i<size; i++)
+    {
+        cout<<action[i]+1<<"    ";
+    }
+    cout<<endl;
+    for(i=0; i<size; i++)
+    {
+        cout<<maxreward[i]<<"  ";
+    }
+    cout<<endl<<"count="<<count<<endl;
+    return 0;
+}
+*/
diff --git a/SVM.cpp b/SVM.cpp
new file mode 100644
index 0000000..37fe056
--- /dev/null
+++ b/SVM.cpp
@@ -0,0 +1,394 @@
+#include <iostream>
+#include <stdlib.h>
+#include <string>
+#include <math.h>
+#include "matrix.h"
+#include <fstream>
+#include <sstream>
+#include <stack>
+using namespace std;
+#define MAX 1000000
+#define MIN -100000
+//SMO参数结构体
+struct OS
+{
+    Matrix x;
+    Matrix y;
+    double C;
+    double soft;
+    int m;
+    Matrix alphas;
+    double b;
+    Matrix eCache;
+    Matrix kernel;
+    bool k;
+};
+//核函数的结构体
+struct kTup
+{
+    int type;//0,1
+    double arg;
+};
+class SMOP
+{
+    //非常值得注意的是svm中训练样本按列排列，即每一列是一个样本，所以导致w是行向量
+public:
+    OS os;
+public:
+    /**
+    根据参数，来生成不同的核函数
+    */
+    Matrix kernelTran(Matrix x,Matrix xOneCol,kTup ktup)
+    {
+        Matrix K;
+        K.initMatrix(&K,x.col,1);
+        Matrix xOneColT;
+        xOneColT.initMatrix(&xOneColT,xOneCol.row,xOneCol.col);
+        xOneColT.transposematrix(xOneCol,&xOneColT);
+        if(ktup.type==1)
+        {
+            K.multsmatrix(&K,x,xOneColT);
+        }
+        if(ktup.type==2)
+        {
+            //高斯核
+        }
+        return K;
+    }
+    /**
+    结构体OS的初始化，用于保存所以SMO算法中需要用到的参数
+    */
+    int initOs(Matrix x,Matrix y,double C,double soft,kTup ktup)
+    {
+        os.x.initMatrix(&os.x,x.col,x.row);
+        os.x.copy(x,&os.x);
+        os.y.initMatrix(&os.y,y.col,y.row);
+        os.y.copy(y,&os.y);
+        os.eCache.initMatrix(&os.eCache,x.col,2);
+        os.alphas.initMatrix(&os.alphas,x.col,1);
+
+        os.b=0;
+        os.C=C;
+        os.m=x.col;
+        os.kernel.initMatrix(&os.kernel,os.m,os.m);
+        os.soft=soft;
+        if(ktup.type!=0)
+        {
+            int i=0,j=0;
+            Matrix xOneCol;
+            xOneCol.initMatrix(&xOneCol,1,os.x.row);
+            Matrix kOneRow;
+            kOneRow.initMatrix(&kOneRow,os.m,1);
+            cout<<"-----------"<<endl;
+            for(i=0; i<os.m; i++)
+            {
+                xOneCol=xOneCol.getOneCol(x,i);
+                kOneRow=kernelTran(x,xOneCol,ktup);
+                for(j=0; j<os.m; j++)
+                    os.kernel.mat[j][i]=kOneRow.mat[j][0];
+            }
+            os.k=true;
+            return 0;
+        }
+        os.k=false;
+        return 0;
+    }
+    /**
+    上下限剪辑函数
+    */
+    double clipAlpha(double alpha,double L,double H)
+    {
+        if(alpha>H)
+            return H;
+        if(alpha<L)
+            return L;
+        return alpha;
+    }
+    /**
+    误差值的计算也是根据数学表达式来实现的
+
+    **/
+    double calcEk(int k)
+    {
+        Matrix ay;
+        ay.initMatrix(&ay,os.x.col,1);
+        int i;
+        for(i=0; i<os.m; i++)
+        {
+            ay.mat[i][0]=os.alphas.mat[i][0]*os.y.mat[i][0];
+        }
+        Matrix ayT;
+        ayT.initMatrix(&ayT,ay.row,ay.col);
+        ayT.transposematrix(ay,&ayT);
+        Matrix f;
+        f.initMatrix(&f,1,1);
+        if(!os.k)
+        {
+            Matrix ayTx;
+            ayTx.initMatrix(&ayTx,ayT.col,os.x.row);
+            ayTx.multsmatrix(&ayTx,ayT,os.x);
+
+            Matrix xOneCol;
+            xOneCol.initMatrix(&xOneCol,1,os.x.row);
+            xOneCol=xOneCol.getOneCol(os.x,k);
+
+            Matrix xOneColT;
+            xOneColT.initMatrix(&xOneColT,xOneCol.row,xOneCol.col);
+            xOneColT.transposematrix(xOneCol,&xOneColT);
+            f.multsmatrix(&f,ayTx,xOneColT);//值得商榷
+        }
+        else
+        {
+            Matrix kOneRow;
+            kOneRow.initMatrix(&kOneRow,os.m,1);
+            kOneRow=kOneRow.getOneRow(os.kernel,k);
+            f.multsmatrix(&f,ayT,kOneRow);//值得商榷
+        }
+        double fXK=f.mat[0][0]+os.b-os.y.mat[k][0];
+        return fXK;
+    }
+    ///更新误差矩阵
+    void updataEk(int k)
+    {
+        double Ek;
+        Ek=calcEk(k);//计算误差值
+        os.eCache.mat[k][0]=1;
+        os.eCache.mat[k][1]=Ek;
+    }
+    /**
+    对于第二个alpha的选择采用Ei-Ej的大小进行衡量，同时这里引用一个矩阵来保存不变的E，减少计算量
+    选择出合适第二个alpha2，对于第一次进来，保存误差值E的矩阵必然没有一个有效的，所以采用随机策略
+    随机选择策略其实可以任意选择，具体没有实现，而是采用等价方式实现，但需要注意数据越界问题
+    **/
+    int selectJ(int i,double Ei)
+    {
+        int maxK=-1;
+        double Ek;
+        double Ej;
+        double deltaE;
+        double maxDeltaE=0;
+        int k;
+        for(k=0; k<os.alphas.col; k++)
+        {
+            if(os.eCache.mat[k][0]==1&&k!=i)
+            {
+                Ek=calcEk(k);
+                deltaE=abs(Ei-Ek);
+                if(deltaE>maxDeltaE)
+                {
+                    maxK=k;
+                    maxDeltaE=deltaE;
+                    Ej=Ek;
+                }
+            }
+            //随机选择一个j, 理论上只有第一次时所有的ek都没计算过，所以任选一个即可
+            if(maxK==-1)
+            {
+                maxK=(i*2+1)%100;
+                Ej=calcEk(maxK);
+            }
+        }
+        return maxK;
+    }
+
+    /**
+    内层循环实现两个alpha的优化，由外层循环函数提供alpha1的可选集合（所有样本或者是支持向量），
+    遍历集合上的每一个alpha，对其进行判断是否违反KKT条件，如果违反则选为第一个alpha1，
+    同样调用selctJ函数来启发式选择使得alpha1改变最大的alpha2，
+    选择出合适ij之后，还得根据当前alpha1和alpha2来确定优化的上下限。
+    然后通过迭代公式，来计算alpha1和alpha2，计算的时候判断是否采用核方法。
+    并对计算结果进行上下限剪辑，最终确定优化后的alpha1和alpha2，同时对当前优化后结果对b也进行修改
+    考虑到每一次选择第二个alpha2时，都需要比较一个误差值，而这个误差值在每次优化过程中都只有对应修改alpha的误差值有变化
+    而其他的是不变的，所以用一个矩阵来保存有效的误差值。
+    */
+    int innerL(int i)
+    {
+        double Ei;
+        double Ej;
+        int j;
+        double alphaIOld;
+        double alphaJOld;
+        double L;
+        double H;
+        double eta;
+        int n;
+        double temp[3];//ii，jj，ij
+        double b1,b2;
+        if(os.y.mat[i][0]*(Ei-os.y.mat[i][0]*os.soft)<0&&os.alphas.mat[i][0]<os.C||os.y.mat[i][0]*(Ei-os.y.mat[i][0]*os.soft)>0&&os.alphas.mat[i][0]>0)
+        {
+            Ei=calcEk(i);
+            j=selectJ(i,Ei);
+            Ej=calcEk(j);
+            alphaIOld=os.alphas.mat[i][0];
+            alphaJOld=os.alphas.mat[j][0];
+            if(os.y.mat[i][0]!=os.y.mat[j][0])
+            {
+                L=max(0.0,os.alphas.mat[j][0]-os.alphas.mat[i][0]);
+                H=min(os.C,os.alphas.mat[j][0]-os.alphas.mat[i][0]+os.C);
+            }
+            else
+            {
+                L=max(0.0,os.alphas.mat[j][0]+os.alphas.mat[i][0]-os.C);
+                H=min(os.C,os.alphas.mat[j][0]+os.alphas.mat[i][0]);
+            }
+            if(L==H)
+            {
+                cout<<"l=h------------------"<<endl;
+                return 0;
+            }
+            if(!os.k)
+            {
+                temp[0]=0;
+                temp[1]=0;
+                temp[2]=0;
+                for(n=0; n<os.x.row; n++)
+                {
+                    temp[0]+=pow(os.x.mat[i][n],2);
+                    temp[1]+=pow(os.x.mat[j][n],2);
+                    temp[2]+=os.x.mat[i][n]*os.x.mat[j][n];
+                }
+            }
+            else
+            {
+                temp[0]=os.kernel.mat[i][i];
+                temp[1]=os.kernel.mat[j][j];
+                temp[2]=os.kernel.mat[i][j];
+                eta=temp[0]+temp[1]-2*temp[2];
+            }
+            eta=temp[0]+temp[1]-2*temp[2];
+            if(eta<0)
+            {
+                cout<<"eta<0-----------------"<<endl;
+                return 0;
+            }
+            os.alphas.mat[j][0]+=os.y.mat[j][0]*(Ei-Ej)/eta;
+            os.alphas.mat[j][0]=clipAlpha(os.alphas.mat[j][0],L,H);//对alpha进行剪辑
+            updataEk(j);//更新误差值
+            if(fabs(os.alphas.mat[j][0]-alphaJOld)<0.000001)
+            {
+                cout<<"j not moving enough---------------"<<endl;
+                return 0;
+            }
+            os.alphas.mat[i][0]+=os.y.mat[i][0]*os.y.mat[j][0]*(alphaJOld-os.alphas.mat[j][0]);
+            updataEk(i);//更新误差值
+
+            b1=os.b-Ei-os.y.mat[i][0]*(os.alphas.mat[i][0]-alphaIOld)*temp[0]-os.alphas.mat[j][0]*(os.alphas.mat[j][0]-alphaJOld)*temp[2];
+            b2=os.b-Ej-os.y.mat[i][0]*(os.alphas.mat[i][0]-alphaIOld)*temp[2]-os.alphas.mat[j][0]*(os.alphas.mat[j][0]-alphaJOld)*temp[1];
+            if(0<os.alphas.mat[i][0]&&os.C>os.alphas.mat[i][0])
+                os.b=b1;
+            else if(0<os.alphas.mat[j][0]&&os.C>os.alphas.mat[j][0])
+                os.b=b2;
+            else
+                os.b=(b1+b2)/2;
+            return 1;
+        }
+        cout<<"kkt--------------------------"<<endl;
+        return 0;
+    }
+
+    /**
+
+    SMO算法的入口函数，其主要功能是初始化SMO所有的参数到结构体OS
+    确定迭代结束标志，并在所有样本和支持向量上循环的选择合适alpha1，调用inner确定alpha1，
+    外层循环每一次是迭代优化一对alpha,内层循环才是正真实现迭代优化一对alpha
+    最后，对smo算法的实现进行检查，通过alpha求解出w，b，并在训练样本上比较其预测值与实际值的差异。
+    该办法只能检查SMO算法实现的正确性，不能检查SVM的性能。
+    */
+
+    int smoP(Matrix x,Matrix y,double C,double soft,int maxIter,kTup ktup)
+    {
+        int iter=0;
+        int i,j;
+        initOs(x,y,C,soft,ktup);///初始化OS结构体，OS结构体中定义了SMOP算法需要的大部分参数
+        bool entireSet=true;//标志用于判断当前迭代是针对所有alpha，还是针对0-C之间的部分alpha，这里其实第一个alpha的启发式选择，即选择落在支持向量上的点
+        int alphaPairsChanged=0;//该参数判断在确定第一个参数之后，是否能选择出符合要求的第二alpha，返回值为1表示能，0为不能
+        for(iter=0; iter<maxIter&&(alphaPairsChanged>0||entireSet); iter++)
+        {//循环结束标志为迭代次数已到预设值，或者是不能再继续优化（对于所有的支持向量上的点都找不到第二个alpha对第一个alpha进行优化后，重新再遍历所有的点寻找可优化的参数对）
+            //还是找不到则再次遍历支持向量上的点，这次必然也是找不到，才结束迭代
+            alphaPairsChanged=0;
+            if(entireSet)
+            {
+                for(i=0; i<os.m; i++)
+                {
+                    alphaPairsChanged+=innerL(i);
+                    cout<<"iter="<<iter<<"  i="<<i<<"  alphachanged="<<alphaPairsChanged<<endl;
+                }
+                iter++;
+            }
+            else
+            {
+                for(i=0; i<os.m; i++)
+                {
+                    if(os.alphas.mat[i][0]>0&&os.alphas.mat[i][0]<os.C)//只选择支持向量上的点
+                        continue;
+                    alphaPairsChanged+=innerL(i);
+                    cout<<"iter="<<iter<<"  i="<<i<<"  alphachanged="<<alphaPairsChanged<<endl;
+                }
+                iter++;
+            }
+            if(entireSet)
+                entireSet=false;
+            else if(alphaPairsChanged==0)
+                entireSet=true;
+        }
+        ///对SMO算法实现的正确性进行验证，输出预测值与实际值的差别，全为0表示在训练样本上预测全对
+        Matrix ay;
+        ay.initMatrix(&ay,os.x.col,1);
+        for(i=0; i<os.m; i++)
+        {
+            ay.mat[i][0]=os.alphas.mat[i][0]*os.y.mat[i][0];
+        }
+
+        Matrix xT;
+        xT.initMatrix(&xT,os.x.row,os.x.col);
+        xT.transposematrix(x,&xT);
+
+        Matrix w;
+        w.initMatrix(&w,os.x.row,1);
+        w.multsmatrix(&w,xT,ay);
+
+        Matrix label;
+        label.initMatrix(&label,os.x.col,1);
+        label.multsmatrix(&label,os.x,w);
+        cout<<os.b<<"  ";
+        for(i=0; i<os.x.row; i++)
+        {
+            cout<<w.mat[i][0]<<"  ";
+        }
+        cout<<endl;
+        ///验证训练样本数据，验证SVM实现的正确性
+        for(i=0; i<os.m; i++)
+        {
+            if((label.mat[i][0]+os.b)>0)
+                cout<<1-os.y.mat[i][0]<<endl;
+            else
+                cout<<-1-os.y.mat[i][0]<<endl;
+        }
+        return 0;
+    }
+
+};
+int main()
+{
+    ///加载数据文件保存到对象dtm的矩阵元素中
+    dataToMatrix dtm;
+    char file[20]="data\\svm.txt";
+    dtm.loadData(&dtm,file);
+
+    ///通过矩阵对象中的load函数初始化样本的特征和类别矩阵x,y
+    Matrix x;
+    x.loadMatrix(&x,dtm);
+    Matrix y;
+    y.initMatrix(&y,x.col,1);
+    y=y.getOneRow(x,x.row);
+    x.deleteOneRow(&x,x.row);
+
+    ///调用SMO函数求解SVM模型
+    cout<<"SVM"<<endl;
+    SMOP smop;
+    kTup ktup;//核函数的定义，其中type元素为0表示不适用核函数，非0分别对应不同的核函数
+    ktup.type=1;
+    ktup.arg=1.0;
+    smop.smoP(x,y,0.6,0.001,40,ktup);//
+    return 0;
+}
diff --git a/adaboost.cpp b/adaboost.cpp
new file mode 100644
index 0000000..55d4daf
--- /dev/null
+++ b/adaboost.cpp
@@ -0,0 +1,307 @@
+
+/***
+决策树，ID3,C4.5,树回归
+
+考虑
+
+1信息增益，信息增益率，最小均方差(树回归中又有值回归和模型回归)
+2属性类型（double，string）连续值和缺损值
+3剪枝
+**/
+
+/**
+注：由于一开始采用指针记录子集数据时不是修改指针指向原始数据指向，
+而是另外申请空间从新操作，这样会极大浪费内存，以及会带来不必要的复制操作
+*/
+
+#include <iostream>
+#include <stdlib.h>
+#include <string>
+#include <math.h>
+#include <fstream>
+#include <sstream>
+#include <stack>
+#define MAX_SIZE_OF_TRAINING_SET 100
+#define MAX_NUMIT 100
+#define ATTR_NUM 22
+#define MAX 1000000
+#define MIN -100000
+using namespace std;
+struct data
+{
+    int id;
+    string attr[ATTR_NUM];//用于字符串属性
+    double attr_double[ATTR_NUM];//用于数值型属性
+    double weight;
+    data *next;
+};
+struct twoSubData
+{
+    data *left;
+    data *right;
+};
+struct Stump
+{
+    double minErr;
+    int bestIndex;//表示最好的分类属性，当非叶子节点时，即表示分裂属性下标，否则为-1，表示为叶子节点标记
+    string ltOrgt;//用于表示是小于等于为-1，还是大于等于为-1
+    double threshVal;
+    struct twoSubData twosubdata;//可用于记录data的指针头
+    int predict[MAX_SIZE_OF_TRAINING_SET];
+    double alpha;
+};
+//matrixTree matrixtree[MAX_SIZE_OF_TRAINING_SET];//用作存储后序遍历生成树的序列
+int node=0;//用作存储后序遍历生成树的序列数组的下标
+int fetflag[ATTR_NUM]= {0,0,0,0,0}; //初始化为0,最后一个用于统计还剩多少特征未使用
+// 计算划分后子集的信息熵，该信息熵由子集中决策属性出现的概率决定
+
+void loadData(data *dataSet)
+{
+    ifstream infile;
+    string tmpstrline;
+    data *p;
+    p=dataSet;
+    data *datatmp;
+    infile.open("data\\adaboost.txt",ios::in);
+    int i=0,j=0,yblen=0,fetlen=0;
+    while(!infile.eof()&&i<MAX_SIZE_OF_TRAINING_SET)
+    {
+        j=0;
+        getline(infile,tmpstrline,'\n');//读取文件中一行的数据，保存为string类型
+        stringstream input(tmpstrline);
+        if(tmpstrline!="\0")////由于读取文件结束符同样会继续该操作
+        {
+            datatmp=new data;
+            datatmp->id=i;
+            datatmp->next=NULL;
+            while(input>>datatmp->attr_double[j])
+            {
+                j++;
+                fetlen=j;
+            }
+            i++;
+            p->next=datatmp;
+            p=p->next;
+        }
+    }
+    //检测数据加载是否正确
+    yblen=i;
+    p=dataSet->next;
+    for(i=0; p!=NULL; i++)
+    {
+        for(j=0; j<fetlen; j++)
+        {
+            cout<<p->attr_double[j]<<"  ";
+        }
+        p=p->next;
+        cout<<endl;
+    }
+}
+double* rangeSize(data *trainData,int axis)
+{
+    data *p;
+    double rangemin=MAX;
+    double rangemax=MIN;
+    double *range=(double *)malloc(sizeof(double)*2);
+    p=trainData->next;
+    while(p!=NULL)
+    {
+        if(p->attr_double[axis]>rangemax)
+            rangemax=p->attr_double[axis];
+        if(p->attr_double[axis]<rangemin)
+            rangemin=p->attr_double[axis];
+        p=p->next;
+    }
+    range[0]=rangemin;
+    range[1]=rangemax;
+    return range;
+}
+int* stumpClassify(data *trainData,int axis,double threshVal,string threshIneq)
+{
+    data *p;
+    p=trainData->next;
+    int *predict=new int[MAX_SIZE_OF_TRAINING_SET];
+    int i=0;
+    while(p!=NULL)
+    {
+        predict[i]=1;
+        if(threshIneq=="lt")
+            {if(p->attr_double[axis]<=threshVal)
+            predict[i]=-1;
+            }
+        else
+            {if(p->attr_double[axis]>threshVal)
+            predict[i]=-1;
+            }
+        p=p->next;
+        i++;
+    }
+    return predict;
+}
+Stump buildStump(data *dataSet,double *w)
+{
+    Stump sp;
+    int len;
+    int i,j,k,l;
+    twoSubData twosubdata;
+    twosubdata.left=new data;
+    twosubdata.right=new data;
+    twosubdata.left->next=NULL;
+    twosubdata.right->next=NULL;
+    data *left=twosubdata.left;//=(data *)malloc(sizeof(data)*MAX_SIZE_OF_TRAINING_SET);
+    data *right=twosubdata.right;
+    data *p;
+    data *datatmp;
+    int *predict=new int[MAX_SIZE_OF_TRAINING_SET];
+    double errArr[MAX_SIZE_OF_TRAINING_SET];
+    double weightError=0;
+    double threshVal;
+    double minErr=MAX;
+    double *range=(double *)malloc(sizeof(double)*2);
+    int numSteps=MAX_SIZE_OF_TRAINING_SET/10;
+    double stepSize;
+    double rangemin,rangemax;
+    string threshIneq[2]={"lt","gt"};
+    for(i=0; i<ATTR_NUM-1;i++)//属性
+    {
+        range=rangeSize(dataSet,i);
+        rangemin=range[0];
+        rangemax=range[1];
+        stepSize=(rangemax-rangemin)/numSteps;
+        for(j=0;j<=numSteps;j++)//其实是numstep+1步
+        {
+            threshVal=rangemin+stepSize*j;
+            for(k=0;k<2;k++)//大于小于
+            {
+                predict=stumpClassify(dataSet,i,threshVal,threshIneq[k]);
+                p=dataSet->next;
+                l=0;
+                weightError=0;
+                while(p!=NULL&&l<100)
+                {
+                    //cout<<predict[l]<<"&"<<p->attr_double[l]<<endl;
+                    errArr[l]=predict[l]-p->attr_double[ATTR_NUM-1]>0?(predict[l]-p->attr_double[ATTR_NUM-1])/2:-(predict[l]-p->attr_double[ATTR_NUM-1])/2;
+                    weightError+=errArr[l]*w[l];
+                    p=p->next;
+                    l++;
+                }
+                if(weightError<minErr)
+                {
+                    minErr=weightError;
+                    p=dataSet->next;
+                    left=twosubdata.left;
+                    right=twosubdata.right;
+                    l=0;
+                    while(p!=NULL)
+                    {
+                        sp.predict[l]=predict[l];
+                        datatmp=new data;//其实可以采用修改指针指向的方式来记录子集中的数据，而不是另外开辟空间
+                        datatmp->next=NULL;
+                        datatmp->id=p->id;
+                        int j=0;
+                        for(j=0; j<ATTR_NUM-1; j++)
+                            datatmp->attr_double[j]=p->attr_double[j];
+                        datatmp->attr_double[ATTR_NUM-1]=predict[l];
+                        if(predict[l]>0)
+                        {
+                            left->next=datatmp;
+                            left=left->next;
+                        }
+                        if(predict[l]<0)
+                        {
+                            right->next=datatmp;
+                            right=right->next;
+                        }
+                        p=p->next;
+                        l++;
+                    }
+                    sp.bestIndex=i;
+                    sp.minErr=minErr;
+                    sp.threshVal=threshVal;
+                    sp.twosubdata=twosubdata;
+                    sp.ltOrgt=threshIneq[k];
+                    cout<<"minErr="<<minErr<<endl;
+                    sp.alpha=0.5*log((1-minErr)/minErr);
+                }
+            }
+        }
+    }
+    return sp;
+}
+int adaBoostTrainDS(data *trainData,int numIt)
+{
+    Stump sp[MAX_NUMIT];
+    data *p;
+    p=trainData->next;
+    int i,j,k;
+    double len=0;
+    double w[MAX_SIZE_OF_TRAINING_SET];
+    double wSum=0;
+    double aggErr[MAX_SIZE_OF_TRAINING_SET];
+    double sumErr;
+    while(p!=NULL)
+    {
+        len++;
+        p=p->next;
+    }
+    for(i=0;i<len;i++)
+    {
+        w[i]=1.0/len;
+        //cout<<w[i]<<" ";
+    }
+    for(i=0;i<numIt;i++)
+    {
+        sumErr=0;
+        sp[i]=buildStump(trainData,w);
+        cout<<"alpha="<<sp[i].alpha<<endl;
+        p=trainData->next;
+        wSum=0;
+        for(j=0;j<len&&p!=NULL;j++)
+        {
+            w[j]=w[j]*(exp(-1*sp[i].alpha*(p->attr_double[ATTR_NUM-1]*sp[i].predict[j])));
+            wSum+=w[j];
+            p=p->next;
+        }
+        for(j=0;j<len;j++)
+        {
+            w[j]=w[j]/wSum;
+            aggErr[j]=0;
+        }
+        for(j=0;j<len;j++)
+        {
+            for(k=0;k<i;k++)
+                {
+                    aggErr[j]+=sp[k].alpha*(sp[k].predict[j]);
+                }
+            if(aggErr[j]>0)
+                aggErr[j]=1;
+            else
+                aggErr[j]=-1;
+        }
+        p=trainData->next;
+        for(j=0;j<len&&p!=NULL;j++)
+        {
+            sumErr+=(aggErr[j]-p->attr_double[ATTR_NUM-1])>0?(aggErr[j]-p->attr_double[ATTR_NUM-1])/2:-(aggErr[j]-p->attr_double[ATTR_NUM-1])/2;
+            p=p->next;
+        }
+        if(sumErr/len<0.01)
+        {
+            cout<<sumErr<<endl;
+            break;
+        }
+        cout<<"sumErr="<<sumErr/len<<endl;
+    }
+    for(i=0;i<50;i++)//50为投票器个数，但不一定是50，只会小于等于50
+    {
+        cout<<sp[i].alpha<<"   "<<sp[i].bestIndex<<"   "<<sp[i].threshVal<<"   "<<sp[i].ltOrgt<<"   "<<sp[i].minErr<<endl;
+    }
+    return 0;
+}
+int main()
+{
+    data *trainData=new data;
+    trainData->next=NULL;
+    loadData(trainData);
+    adaBoostTrainDS(trainData,50);
+    return 0;
+}
diff --git a/bayes.cpp b/bayes.cpp
new file mode 100644
index 0000000..2434cc7
--- /dev/null
+++ b/bayes.cpp
@@ -0,0 +1,341 @@
+#include <iostream>
+#include <stdio.h>
+#include <string>
+#include <math.h>
+#include <fstream>
+#include <sstream>
+#include <stack>
+#include "matrix.h"
+#define EMAILSUM 50 //非常特别的一个常量，适用范围有限
+#define FILE_MAX_NUM 99
+#define FILE_NAME_LEN 30
+#define FILE_WORD_LEN 1000
+#define CLASS_SUM 2
+#define VEC_LEN 1000
+using namespace std;
+
+struct Bayes
+{
+    Matrix pXY;
+    Matrix pY;
+    Matrix pX;
+};
+Bayes bayes;//保存bayes分类器所有的参数
+char file[CLASS_SUM][FILE_MAX_NUM][FILE_NAME_LEN];//加载数据的文件名
+
+/**
+生成单词字典
+*/
+dataToMatrix createVocabList(dataToMatrix *dtm)
+{
+    int i,j,k,vl;
+    int vec_len=0;
+    string dic[VEC_LEN];
+    Data *p;
+    for(k=0; k<EMAILSUM; k++)
+    {
+        for(i=0; i<dtm[k].col; i++)
+        {
+            p=dtm[k].dataSet->next;
+            for(j=0; j<dtm[k].row; j++)
+            {
+                for(vl=0; vl<vec_len; vl++)
+                {
+                    if(!p->attr_string[j].compare(dic[vl]))
+                        break;
+                }
+                if(vl==vec_len)
+                {
+                    dic[vec_len]=p->attr_string[j];
+                    vec_len++;
+                }
+            }
+            p=p->next;
+        }
+    }
+    dataToMatrix dicMat;
+    dicMat.dataSet=new Data;
+    dicMat.dataSet->next=NULL;
+    p=dicMat.dataSet;
+    Data *datatmp=new Data;
+    datatmp->next=NULL;
+    for(i=0; i<vec_len; i++)
+    {
+        datatmp->attr_string[i]=dic[i];
+    }
+    p->next=datatmp;
+    dicMat.col=1;
+    dicMat.row=vec_len;
+    cout<<"vec_len="<<vec_len<<endl;
+    return dicMat;
+}
+/**
+生成训练样本矩阵
+**/
+Matrix createFectVec(dataToMatrix *dtm,dataToMatrix dicMat)
+{
+    int i,j,k=0,vl;
+    Data *p;
+    Data *q;
+    q=dicMat.dataSet->next;//字典同样也是一行
+    Matrix vecX;
+    vecX.initMatrix(&vecX,EMAILSUM,dicMat.row);
+    for(k=0; k<EMAILSUM; k++)
+    {
+        for(i=0; i<dtm[k].col; i++)//只有一行
+        {
+            p=dtm[k].dataSet->next;
+            for(j=0; j<dtm[k].row; j++)
+            {
+                for(vl=0; vl<dicMat.row; vl++)
+                {
+                    if(!p->attr_string[j].compare(q->attr_string[vl]))
+                    {
+                        vecX.mat[k][vl]=1;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    /*
+    for(i=0;i<vecX.col;i++)
+    {
+        for(j=0;j<vecX.row;j++)
+            cout<<vecX.mat[i][j]<<"  ";
+        cout<<endl;
+    }*/
+    return vecX;
+}
+
+/**
+生成测试样本矩阵向量
+**/
+Matrix createTestVec(dataToMatrix testX,dataToMatrix dicMat)
+{
+    int i,j,vl;
+    Data *p;
+    Data *q;
+    p=testX.dataSet->next;
+    q=dicMat.dataSet->next;//字典同样也是一行
+    Matrix testVecX;
+    testVecX.initMatrix(&testVecX,testX.col,dicMat.row);
+    for(i=0; i<testX.col; i++)//只有一行
+    {
+        for(j=0; j<testX.row; j++)
+        {
+            for(vl=0; vl<dicMat.row; vl++)
+            {
+                if(!p->attr_string[j].compare(q->attr_string[vl]))
+                {
+                    testVecX.mat[0][vl]=1;
+                    break;
+                }
+            }
+        }
+    }
+    return testVecX;
+}
+
+/**
+训练函数的实现，注意对参数进行平滑处理
+**/
+int trainNB(Matrix vecX,Matrix vecY)
+{
+    bayes.pY.initMatrix(&bayes.pY,2,1);//两类初始化为2行的列向量
+    bayes.pX.initMatrix(&bayes.pX,1,vecX.row);
+    bayes.pXY.initMatrix(&bayes.pXY,2,vecX.row);
+
+    double dicY[CLASS_SUM]= {0,0};
+    int i,j,k,len=0;
+    for(k=0; k<CLASS_SUM; k++)
+    {
+        for(j=0; j<vecX.row; j++)
+        {
+            bayes.pXY.mat[k][j]=1;//平滑处理,默认出现一次，后期归一化时把特征向量的长度也考虑进去,这里的平滑是指每一类字典与整个字典的，未涉及测试
+            //样本中的未登入词
+            bayes.pX.mat[0][j]=0;
+        }
+    }
+    int wordsum=0;
+    for(i=0; i<vecX.col; i++)
+    {
+        if(vecY.mat[i][0]==1)
+        {
+            bayes.pY.mat[0][0]++;
+            for(j=0; j<vecX.row; j++)
+            {
+                bayes.pXY.mat[0][j]+=vecX.mat[i][j];
+                dicY[0]+=vecX.mat[i][j];
+                wordsum+=vecX.mat[i][j];
+                bayes.pX.mat[0][j]+=vecX.mat[i][j];
+            }
+        }
+        else
+        {
+            bayes.pY.mat[1][0]++;
+            for(j=0; j<vecX.row; j++)
+            {
+                bayes.pXY.mat[1][j]+=vecX.mat[i][j];
+                dicY[1]+=vecX.mat[i][j];
+                wordsum+=vecX.mat[i][j];
+                bayes.pX.mat[0][j]+=vecX.mat[i][j];
+            }
+        }
+    }
+    //计算出PY两类的概率
+    for(i=0; i<CLASS_SUM; i++)
+    {
+        bayes.pY.mat[i][0]/=vecX.col;
+    }
+
+    double s=0;
+    for(k=0; k<CLASS_SUM; k++)
+    {
+        for(i=0; i<vecX.row; i++)
+        {
+            bayes.pXY.mat[k][i]/=dicY[k]+vecX.row;
+            s+=bayes.pXY.mat[k][i];
+        }
+    }
+    double ss=0;
+    for(i=0; i<vecX.row; i++)
+    {
+        bayes.pX.mat[0][i]/=wordsum;//+vec_len;
+        ss+=bayes.pX.mat[0][i];
+    }
+    /*
+    cout<<"pY="<<bayes.pY.mat[0][0]<<endl;
+    cout<<"dicy"<<dicY[0]<<"  "<<dicY[1]<<endl;
+    cout<<"wordsum="<<wordsum<<endl;
+    cout<<"ss="<<ss<<endl;
+    cout<<"s="<<s<<endl;*/
+}
+
+/**
+分类决策函数
+**/
+int classifyNB(Matrix testVecX)
+{
+    double p0=1.0,p1=1.0;
+    int i,j;
+    for(i=0; i<testVecX.row ; i++)
+    {
+        if(testVecX.mat[0][i]!=0)
+        {
+            p0*=(bayes.pXY.mat[0][i]/bayes.pX.mat[0][i]);
+            p1*=(bayes.pXY.mat[1][i]/bayes.pX.mat[0][i]);
+            cout<<p0<<endl;
+            cout<<p1<<endl;
+        }
+    }
+    p0*=bayes.pY.mat[0][0];
+    p1*=bayes.pY.mat[1][0];
+    cout<<"p0="<<p0<<"&"<<"p1="<<p1<<endl;
+    if(p0<p1)
+        cout<<"class="<<1;
+    else
+        cout<<"class="<<0;
+    return 0;
+
+}
+
+/**
+    生成数据的文件名
+*/
+void getFileName()
+{
+    int i=0,j=0,k=0,l=0;
+    string path[2]= {"data\\email\\ham\\*.txt","data\\email\\spam\\*.txt"};
+    for(k=0; k<CLASS_SUM; k++)
+    {
+        for(i=0; i<25&&i<FILE_MAX_NUM; i++)
+        {
+            for(j=0,l=0; j<FILE_NAME_LEN; j++,l++)
+            {
+                if(path[k][j]!='*')
+                    file[k][i][j]=path[k][l];
+                else
+                {
+                    if((i+1)/10>0)
+                    {
+                        file[k][i][j]=48+((i+1)/10);
+                        file[k][i][j+1]=48+(i+1)%10;
+                        j++;
+                    }
+                    else
+                    {
+                        file[k][i][j]=48+i+1;
+                    }
+                }
+            }
+            //cout<<file[k][i]<<"  "<<i<<"  "<<i/10<<endl;
+        }
+    }
+}
+
+int main()
+{
+
+    int k,i,j;
+    getFileName();///调用训练数据文件名生成函数
+
+    /**
+    加载数据样本
+    **/
+    dataToMatrix dtm[EMAILSUM];
+    cout<<"loadData"<<endl;
+    cout<<"----------------------"<<endl;
+    for(k=0; k<CLASS_SUM; k++)
+    {
+        for(i=0; i<25&&i<FILE_MAX_NUM; i++)
+        {
+            dtm[25*k+i].loadData(&dtm[25*k+i],file[k][i],1);
+        }
+    }
+
+    dataToMatrix dicMat;// 字典
+    dicMat=createVocabList(dtm);
+    dicMat.print(dicMat);
+
+    /**
+    生成样本矩阵
+    **/
+    Matrix vecX;
+    vecX.initMatrix(&vecX,EMAILSUM,dicMat.row);
+    vecX=createFectVec(dtm,dicMat);
+
+    /**
+    生成样本标签
+    **/
+    Matrix vecY;
+    vecY.initMatrix(&vecY,EMAILSUM,1);
+    for(i=0; i<EMAILSUM; i++)
+    {
+        if(i<25)
+            vecY.mat[i][0]=1;
+        else
+            vecY.mat[i][0]=-1;
+    }
+
+    trainNB(vecX,vecY);///通过样本矩阵和标签矩阵调用参数求解函数求解bayes决策的参数
+
+    /**
+    生成测试样本
+    */
+    dataToMatrix dtmTest;
+    cout<<"loadData"<<endl;
+    cout<<"----------------------"<<endl;
+    char testfile[30]="data\\email\\test.txt";
+    dtmTest.loadData(&dtmTest,testfile,1);
+
+    /**
+    生成测试样本矩阵向量
+    **/
+    Matrix testVecX;
+    testVecX.initMatrix(&testVecX,1,dicMat.row);
+    testVecX=createTestVec(dtmTest,dicMat);
+    testVecX.print(testVecX);
+
+    classifyNB(testVecX);///分类决策
+}
diff --git a/cart.cpp b/cart.cpp
new file mode 100644
index 0000000..bb94cfe
--- /dev/null
+++ b/cart.cpp
@@ -0,0 +1,364 @@
+/***
+决策树，ID3,C4.5,树回归
+
+考虑
+
+1信息增益，信息增益率，最小均方差
+2属性类型（double，string）连续值和缺损值
+3剪枝
+**/
+
+
+
+#include <iostream>
+#include <stdlib.h>
+#include <string>
+#include <math.h>
+#include <fstream>
+#include <sstream>
+#define MAX_SIZE_OF_TRAINING_SET 1000
+#define ATTR_NUM 3
+#define MAX 1024000
+#define MIN 0.0000001
+using namespace std;
+struct data
+{
+    int id;
+    double attr_double[ATTR_NUM];//用于数值型属性
+    data *next;
+};
+struct twoSubData
+{
+    data *left;
+    data *right;
+};
+struct split
+{
+    int bestIndex;//表示最好的分类属性，当非叶子节点时，即表示分裂属性下标，否则为-1，表示为叶子节点标记
+    double value;//若为分裂节点，则表示分裂阈值，否则为叶子节点，用来记录叶子节点的均值
+};
+typedef struct bitnode
+{
+    struct bitnode *left;//小于等于阈值的左子树
+    struct bitnode *right;//大于阈值的右子树
+    int leafType;//叶子节点类型.0:值，1:模型
+    int feature;//只有非叶子节点才有分裂属性
+    double value;//叶子节点为值型,非叶子节点为阈值
+    int modle[ATTR_NUM];//叶子节点为model型
+    struct data *data;//可用于记录data的指针头
+    int len;//记录该结点子集的长度
+}bitnode,*bitree;
+twoSubData binSplitDataSet(data *dataSet,int axis,double value)
+{
+    twoSubData twosubdata;
+    twosubdata.left=new data;
+    twosubdata.right=new data;
+    twosubdata.left->next=NULL;
+    twosubdata.right->next=NULL;
+    data *left=twosubdata.left;//=(data *)malloc(sizeof(data)*MAX_SIZE_OF_TRAINING_SET);
+    data *right=twosubdata.right;
+    data *p;
+    data *datatmp;
+    p=dataSet->next;
+    int i,j,k;
+    for(i=0;p!=NULL;i++)
+    {
+        if(p->attr_double[axis]<=value)
+        {
+            datatmp=new data;
+            datatmp->next=NULL;
+            datatmp->id=p->id;
+            for(j=0;j<ATTR_NUM;j++)
+                datatmp->attr_double[j]=p->attr_double[j];
+            left->next=datatmp;
+            left=left->next;
+        }
+        else
+        {
+            datatmp=new data;
+            datatmp->next=NULL;
+            datatmp->id=p->id;
+            for(j=0;j<ATTR_NUM;j++)
+                datatmp->attr_double[j]=p->attr_double[j];
+            right->next=datatmp;
+            right=right->next;
+        }
+        p=p->next;
+    }
+    return twosubdata;
+}
+double mean(data *dataSet)
+{
+    int i;
+    double meanvalue=0;
+    double meanErr=0;
+    data *p;
+    p=dataSet->next;
+    for(i=0;p!=NULL;i++)
+    {
+        meanvalue+=p->attr_double[ATTR_NUM-1];
+        p=p->next;
+    }
+    meanvalue/=(i);//这里注意i即表示长度，因为i是从0开始算的，所以最后的加1不能减去
+    return meanvalue;
+}
+double MeanErr(data *dataSet)
+{
+    int i;
+    double meanvalue=0;
+    double meanErr=0;
+    data *p;
+    meanvalue=mean(dataSet);
+    p=dataSet->next;
+    for(i=0;p!=NULL;i++)
+    {
+        meanErr+=(p->attr_double[ATTR_NUM-1]-meanvalue)*(p->attr_double[ATTR_NUM-1]-meanvalue);
+        p=p->next;
+    }
+    meanErr=sqrt(meanErr/(i));//这里注意i即表示长度，因为i是从0开始算的，所以最后的加1不能减去
+    //cout<<"meanErr="<<meanErr<<endl;
+    return meanErr;
+}
+/*double linearSolve(data *dataSet)
+{
+    int i,j;
+    data *p;
+    p=dataSet->next;
+    while(p!=NULL)
+    {
+        p
+        p=p->next;
+    }
+}*/
+split chooseBestSplit(data *dataSet,int leafType,double minErr,int minLen)
+{
+    int signvalue=1;
+    twoSubData twosubdata;
+    data *p;
+    data *left;
+    data *right;
+    split sp;
+    int len;
+    int i,j;
+    double oldMeanErr=MeanErr(dataSet);
+    double bestMeanErr=MAX;
+    double newMeanErr;
+    p=dataSet->next;
+    double value=p->attr_double[ATTR_NUM-1];
+    for(i=0;p!=NULL;i++)
+    {
+        signvalue=0;
+        if(p->attr_double[ATTR_NUM-1]!=value)
+        {
+            signvalue=0;
+        }
+        len++;
+        p=p->next;
+    }
+    if(signvalue||len==1)
+    {
+        cout<<"signvalue+len"<<endl;
+        sp.bestIndex=-1;
+        sp.value=mean(dataSet);
+        return sp;
+    }
+    sp.bestIndex=0;
+    sp.value=0;
+    for(i=0;i<ATTR_NUM-1;i++)
+    {
+        p=dataSet->next;
+        for(j=0;p!=NULL;j++)
+        {
+            twosubdata=binSplitDataSet(dataSet,i,p->attr_double[i]);
+            left=twosubdata.left->next;
+            right=twosubdata.right->next;
+            len=0;//len记得在进入下次循环是清0
+            while(left!=NULL&&right!=NULL)
+            {
+                left=left->next;
+                right=right->next;
+                len++;
+            }
+            //cout<<"len===="<<len<<endl;
+            if(len<minLen)
+            {
+                p=p->next;//提前结束当前循环之前还得把指针指向下一个
+                continue;
+            }
+            newMeanErr=MeanErr(twosubdata.left)+MeanErr(twosubdata.right);
+            //cout<<"id="<<j<<"  newMeanErr="<<newMeanErr<<endl;
+            if(newMeanErr<bestMeanErr)
+            {
+                sp.bestIndex=i;
+                sp.value=p->attr_double[i];
+                bestMeanErr=newMeanErr;
+            }
+            p=p->next;
+        }
+    }
+    //cout<<"value="<<sp.value<<"  index="<<sp.bestIndex<<endl;
+    if(oldMeanErr-bestMeanErr<minErr||oldMeanErr-bestMeanErr<MIN)
+    {
+        sp.bestIndex=-1;
+        sp.value=mean(dataSet);
+        //cout<<"minErr"<<endl;
+        return sp;
+    }
+    //cout<<sp.bestIndex<<"&"<<sp.value<<"  ";
+    //cout<<oldMeanErr<<"&"<<bestMeanErr<<endl;
+    return sp;
+}
+int createBinTree(bitree &t,data *dataSet)
+{
+    data *p=dataSet->next;
+    if(!(t=(bitnode *)malloc(sizeof(bitnode)))) exit(-1);
+
+    int len=0;
+    while(p!=NULL)
+    {
+        len++;
+        //cout<<"data:  "<<p->attr_double[0]<<"  "<<p->attr_double[1]<<"  "<<p->attr_double[2]<<endl;
+        p=p->next;
+    }
+    cout<<"len="<<len<<endl;;
+    split sp=chooseBestSplit(dataSet,0,0.01,10);
+    //cout<<"index="<<sp.bestIndex<<endl;
+    t->feature=sp.bestIndex;
+    t->value=sp.value;
+    t->data=dataSet;
+    t->len=len;
+    if(t->feature==-1)
+    {
+
+        t->left=NULL;
+        t->right=NULL;
+        t->data=dataSet;
+        t->len=len;
+        cout<<"feature="<<t->feature<<"  value="<<t->value<<endl;
+        return 0;
+    }
+    else
+    {
+        cout<<"feature="<<t->feature<<"  value="<<t->value<<endl;
+        twoSubData twosubdata=binSplitDataSet(dataSet,sp.bestIndex,sp.value);
+        createBinTree((t->left),twosubdata.left);
+        createBinTree((t->right),twosubdata.right);
+    }
+    return 0;
+}
+void loadData(data *dataSet,int trainOrtest)
+{
+    ifstream infile;
+    string tmpstrline;
+    string tmpstr;
+    data *p;
+    p=dataSet;
+    data *datatmp;
+    infile.open("data\\cart.txt",ios::in);
+    int i=0,j=0,yblen=0,fetlen=0;
+    while(!infile.eof()&&i<MAX_SIZE_OF_TRAINING_SET)
+    {
+        getline(infile,tmpstrline,'\n');//读取文件中一行的数据，保存为string类型
+        stringstream input(tmpstrline);
+        if(tmpstrline!="\0"&&i%2==trainOrtest)////由于读取文件结束符同样会继续该操作
+        {
+            datatmp=new data;
+            datatmp->id=i;
+            datatmp->next=NULL;
+            j=0;
+            while(input>>datatmp->attr_double[j])
+            {
+                j++;
+                fetlen=j;
+            }
+            p->next=datatmp;
+            p=p->next;
+        }
+        i++;
+    }
+    //检测数据加载是否正确
+    /*yblen=i;
+    p=dataSet->next;
+    for(i=0; p!=NULL; i++)
+    {
+        for(j=0; j<fetlen; j++)
+        {
+            cout<<p->attr_double[j]<<"  ";
+        }
+        p=p->next;
+        cout<<endl;
+    }*/
+}
+int preorder(bitree &t,data *dataSet)//递归先序遍历二叉树
+{
+    data *p;
+    if(t!=NULL)
+    {
+        cout<<t->feature<<"  "<<t->value<<"  len="<<t->len<<endl;
+        p=dataSet->next;
+        if(t->left!=NULL)//这里之所以不再下一次递归时检测t->left是否为NULL，是因为递归函数中另外一个参数用到了left->data
+        //常规的先序遍历一般在下一次递归为NULL返回
+            preorder(t->left,t->left->data);
+        if(t->right!=NULL)
+            preorder(t->right,t->right->data);
+    }
+    return 0;
+}
+int  prune(bitree &t,data *testData)
+{
+    data *p=testData;
+    int len=0;
+    while(p!=NULL)
+    {
+        p=p->next;
+        len++;
+    }
+    if(len==0)
+        return 0;
+    if(t==NULL)//检测子树是否为NULL,不然后面的操作执行不了
+        return 0;
+    if(t->left->feature>-1||t->right->feature>-1)
+    {
+        twoSubData twosubdata=binSplitDataSet(testData,t->feature,t->value);
+        if(t->left->feature>-1)
+            prune(t->left,twosubdata.left);
+        if(t->right->feature>-1)
+        prune(t->right,twosubdata.right);
+    }
+    else
+    {
+        twoSubData twosubdata=binSplitDataSet(testData,t->feature,t->value);
+        double errortwo=MeanErr(twosubdata.left)+MeanErr(twosubdata.right);
+        double errorone=MeanErr(testData);
+        if(errorone<errortwo)
+        {
+            cout<<"merge"<<endl;
+            t->left=NULL;
+            t->right=NULL;
+            t->feature=-1;
+            t->value=mean(testData);
+            return 0;
+        }
+    }
+
+}
+int main()
+{
+    data *dataSet=new data;
+    dataSet->next=NULL;
+    loadData(dataSet,0);
+    //MeanErr(dataSet);
+    //chooseBestSplit(dataSet,0,0,1);
+    bitree t;
+    if(!(t=(bitree)malloc(sizeof(bitnode)))) exit(-1);
+    //t=NULL;
+    createBinTree(t,dataSet);
+        cout<<t->feature<<endl;
+    preorder(t,dataSet);
+    data *testData=new data;
+    loadData(testData,1);
+    prune(t,testData);
+    preorder(t,dataSet);
+    return 0;
+}
+
diff --git a/data/adaboost.txt b/data/adaboost.txt
new file mode 100644
index 0000000..4d858d3
--- /dev/null
+++ b/data/adaboost.txt
@@ -0,0 +1,67 @@
+2.000000	1.000000	38.500000	54.000000	20.000000	0.000000	1.000000	2.000000	2.000000	3.000000	4.000000	1.000000	2.000000	2.000000	5.900000	0.000000	2.000000	42.000000	6.300000	0.000000	0.000000	1.000000
+2.000000	1.000000	37.600000	48.000000	36.000000	0.000000	0.000000	1.000000	1.000000	0.000000	3.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	44.000000	6.300000	1.000000	5.000000	1.000000
+1.000000	1.000000	37.700000	44.000000	28.000000	0.000000	4.000000	3.000000	2.000000	5.000000	4.000000	4.000000	1.000000	1.000000	0.000000	3.000000	5.000000	45.000000	70.000000	3.000000	2.000000	1.000000
+1.000000	1.000000	37.000000	56.000000	24.000000	3.000000	1.000000	4.000000	2.000000	4.000000	4.000000	3.000000	1.000000	1.000000	0.000000	0.000000	0.000000	35.000000	61.000000	3.000000	2.000000	-1.000000
+2.000000	1.000000	38.000000	42.000000	12.000000	3.000000	0.000000	3.000000	1.000000	1.000000	0.000000	1.000000	0.000000	0.000000	0.000000	0.000000	2.000000	37.000000	5.800000	0.000000	0.000000	1.000000
+1.000000	1.000000	0.000000	60.000000	40.000000	3.000000	0.000000	1.000000	1.000000	0.000000	4.000000	0.000000	3.000000	2.000000	0.000000	0.000000	5.000000	42.000000	72.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	38.400000	80.000000	60.000000	3.000000	2.000000	2.000000	1.000000	3.000000	2.000000	1.000000	2.000000	2.000000	0.000000	1.000000	1.000000	54.000000	6.900000	0.000000	0.000000	1.000000
+2.000000	1.000000	37.800000	48.000000	12.000000	2.000000	1.000000	2.000000	1.000000	3.000000	0.000000	1.000000	2.000000	0.000000	0.000000	2.000000	0.000000	48.000000	7.300000	1.000000	0.000000	1.000000
+2.000000	1.000000	37.900000	45.000000	36.000000	3.000000	3.000000	3.000000	2.000000	2.000000	3.000000	1.000000	2.000000	1.000000	0.000000	3.000000	0.000000	33.000000	5.700000	3.000000	0.000000	1.000000
+2.000000	1.000000	39.000000	84.000000	12.000000	3.000000	1.000000	5.000000	1.000000	2.000000	4.000000	2.000000	1.000000	2.000000	7.000000	0.000000	4.000000	62.000000	5.900000	2.000000	2.200000	-1.000000
+2.000000	1.000000	38.200000	60.000000	24.000000	3.000000	1.000000	3.000000	2.000000	3.000000	3.000000	2.000000	3.000000	3.000000	0.000000	4.000000	4.000000	53.000000	7.500000	2.000000	1.400000	1.000000
+1.000000	1.000000	0.000000	140.000000	0.000000	0.000000	0.000000	4.000000	2.000000	5.000000	4.000000	4.000000	1.000000	1.000000	0.000000	0.000000	5.000000	30.000000	69.000000	0.000000	0.000000	-1.000000
+1.000000	1.000000	37.900000	120.000000	60.000000	3.000000	3.000000	3.000000	1.000000	5.000000	4.000000	4.000000	2.000000	2.000000	7.500000	4.000000	5.000000	52.000000	6.600000	3.000000	1.800000	-1.000000
+2.000000	1.000000	38.000000	72.000000	36.000000	1.000000	1.000000	3.000000	1.000000	3.000000	0.000000	2.000000	2.000000	1.000000	0.000000	3.000000	5.000000	38.000000	6.800000	2.000000	2.000000	1.000000
+2.000000	9.000000	38.000000	92.000000	28.000000	1.000000	1.000000	2.000000	1.000000	1.000000	3.000000	2.000000	3.000000	0.000000	7.200000	0.000000	0.000000	37.000000	6.100000	1.000000	1.100000	1.000000
+1.000000	1.000000	38.300000	66.000000	30.000000	2.000000	3.000000	1.000000	1.000000	2.000000	4.000000	3.000000	3.000000	2.000000	8.500000	4.000000	5.000000	37.000000	6.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	37.500000	48.000000	24.000000	3.000000	1.000000	1.000000	1.000000	2.000000	1.000000	0.000000	1.000000	1.000000	0.000000	3.000000	2.000000	43.000000	6.000000	1.000000	2.800000	1.000000
+1.000000	1.000000	37.500000	88.000000	20.000000	2.000000	3.000000	3.000000	1.000000	4.000000	3.000000	3.000000	0.000000	0.000000	0.000000	0.000000	0.000000	35.000000	6.400000	1.000000	0.000000	-1.000000
+2.000000	9.000000	0.000000	150.000000	60.000000	4.000000	4.000000	4.000000	2.000000	5.000000	4.000000	4.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	-1.000000
+1.000000	1.000000	39.700000	100.000000	30.000000	0.000000	0.000000	6.000000	2.000000	4.000000	4.000000	3.000000	1.000000	0.000000	0.000000	4.000000	5.000000	65.000000	75.000000	0.000000	0.000000	-1.000000
+1.000000	1.000000	38.300000	80.000000	0.000000	3.000000	3.000000	4.000000	2.000000	5.000000	4.000000	3.000000	2.000000	1.000000	0.000000	4.000000	4.000000	45.000000	7.500000	2.000000	4.600000	1.000000
+2.000000	1.000000	37.500000	40.000000	32.000000	3.000000	1.000000	3.000000	1.000000	3.000000	2.000000	3.000000	2.000000	1.000000	0.000000	0.000000	5.000000	32.000000	6.400000	1.000000	1.100000	1.000000
+1.000000	1.000000	38.400000	84.000000	30.000000	3.000000	1.000000	5.000000	2.000000	4.000000	3.000000	3.000000	2.000000	3.000000	6.500000	4.000000	4.000000	47.000000	7.500000	3.000000	0.000000	-1.000000
+1.000000	1.000000	38.100000	84.000000	44.000000	4.000000	0.000000	4.000000	2.000000	5.000000	3.000000	1.000000	1.000000	3.000000	5.000000	0.000000	4.000000	60.000000	6.800000	0.000000	5.700000	-1.000000
+2.000000	1.000000	38.700000	52.000000	0.000000	1.000000	1.000000	1.000000	1.000000	1.000000	3.000000	1.000000	0.000000	0.000000	0.000000	1.000000	3.000000	4.000000	74.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	38.100000	44.000000	40.000000	2.000000	1.000000	3.000000	1.000000	3.000000	3.000000	1.000000	0.000000	0.000000	0.000000	1.000000	3.000000	35.000000	6.800000	0.000000	0.000000	1.000000
+2.000000	1.000000	38.400000	52.000000	20.000000	2.000000	1.000000	3.000000	1.000000	1.000000	3.000000	2.000000	2.000000	1.000000	0.000000	3.000000	5.000000	41.000000	63.000000	1.000000	1.000000	1.000000
+1.000000	1.000000	38.200000	60.000000	0.000000	1.000000	0.000000	3.000000	1.000000	2.000000	1.000000	1.000000	1.000000	1.000000	0.000000	4.000000	4.000000	43.000000	6.200000	2.000000	3.900000	1.000000
+2.000000	1.000000	37.700000	40.000000	18.000000	1.000000	1.000000	1.000000	0.000000	3.000000	2.000000	1.000000	1.000000	1.000000	0.000000	3.000000	3.000000	36.000000	3.500000	0.000000	0.000000	1.000000
+1.000000	1.000000	39.100000	60.000000	10.000000	0.000000	1.000000	1.000000	0.000000	2.000000	3.000000	0.000000	0.000000	0.000000	0.000000	4.000000	4.000000	0.000000	0.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	37.800000	48.000000	16.000000	1.000000	1.000000	1.000000	1.000000	0.000000	1.000000	1.000000	2.000000	1.000000	0.000000	4.000000	3.000000	43.000000	7.500000	0.000000	0.000000	1.000000
+1.000000	1.000000	39.000000	120.000000	0.000000	4.000000	3.000000	5.000000	2.000000	2.000000	4.000000	3.000000	2.000000	3.000000	8.000000	0.000000	0.000000	65.000000	8.200000	3.000000	4.600000	1.000000
+1.000000	1.000000	38.200000	76.000000	0.000000	2.000000	3.000000	2.000000	1.000000	5.000000	3.000000	3.000000	1.000000	2.000000	6.000000	1.000000	5.000000	35.000000	6.500000	2.000000	0.900000	1.000000
+2.000000	1.000000	38.300000	88.000000	0.000000	0.000000	0.000000	6.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	-1.000000
+1.000000	1.000000	38.000000	80.000000	30.000000	3.000000	3.000000	3.000000	1.000000	0.000000	0.000000	0.000000	0.000000	0.000000	6.000000	0.000000	0.000000	48.000000	8.300000	0.000000	4.300000	1.000000
+1.000000	1.000000	0.000000	0.000000	0.000000	3.000000	1.000000	1.000000	1.000000	2.000000	3.000000	3.000000	1.000000	3.000000	6.000000	4.000000	4.000000	0.000000	0.000000	2.000000	0.000000	-1.000000
+1.000000	1.000000	37.600000	40.000000	0.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	0.000000	0.000000	0.000000	1.000000	1.000000	0.000000	0.000000	2.000000	2.100000	1.000000
+2.000000	1.000000	37.500000	44.000000	0.000000	1.000000	1.000000	1.000000	1.000000	3.000000	3.000000	2.000000	0.000000	0.000000	0.000000	0.000000	0.000000	45.000000	5.800000	2.000000	1.400000	1.000000
+2.000000	1.000000	38.200000	42.000000	16.000000	1.000000	1.000000	3.000000	1.000000	1.000000	3.000000	1.000000	0.000000	0.000000	0.000000	1.000000	0.000000	35.000000	60.000000	1.000000	1.000000	1.000000
+2.000000	1.000000	38.000000	56.000000	44.000000	3.000000	3.000000	3.000000	0.000000	0.000000	1.000000	1.000000	2.000000	1.000000	0.000000	4.000000	0.000000	47.000000	70.000000	2.000000	1.000000	1.000000
+2.000000	1.000000	38.300000	45.000000	20.000000	3.000000	3.000000	2.000000	2.000000	2.000000	4.000000	1.000000	2.000000	0.000000	0.000000	4.000000	0.000000	0.000000	0.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	0.000000	48.000000	96.000000	1.000000	1.000000	3.000000	1.000000	0.000000	4.000000	1.000000	2.000000	1.000000	0.000000	1.000000	4.000000	42.000000	8.000000	1.000000	0.000000	1.000000
+1.000000	1.000000	37.700000	55.000000	28.000000	2.000000	1.000000	2.000000	1.000000	2.000000	3.000000	3.000000	0.000000	3.000000	5.000000	4.000000	5.000000	0.000000	0.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	36.000000	100.000000	20.000000	4.000000	3.000000	6.000000	2.000000	2.000000	4.000000	3.000000	1.000000	1.000000	0.000000	4.000000	5.000000	74.000000	5.700000	2.000000	2.500000	-1.000000
+1.000000	1.000000	37.100000	60.000000	20.000000	2.000000	0.000000	4.000000	1.000000	3.000000	0.000000	3.000000	0.000000	2.000000	5.000000	3.000000	4.000000	64.000000	8.500000	2.000000	0.000000	1.000000
+2.000000	1.000000	37.100000	114.000000	40.000000	3.000000	0.000000	3.000000	2.000000	2.000000	2.000000	1.000000	0.000000	0.000000	0.000000	0.000000	3.000000	32.000000	0.000000	3.000000	6.500000	1.000000
+1.000000	1.000000	38.100000	72.000000	30.000000	3.000000	3.000000	3.000000	1.000000	4.000000	4.000000	3.000000	2.000000	1.000000	0.000000	3.000000	5.000000	37.000000	56.000000	3.000000	1.000000	1.000000
+1.000000	1.000000	37.000000	44.000000	12.000000	3.000000	1.000000	1.000000	2.000000	1.000000	1.000000	1.000000	0.000000	0.000000	0.000000	4.000000	2.000000	40.000000	6.700000	3.000000	8.000000	1.000000
+1.000000	1.000000	38.600000	48.000000	20.000000	3.000000	1.000000	1.000000	1.000000	4.000000	3.000000	1.000000	0.000000	0.000000	0.000000	3.000000	0.000000	37.000000	75.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	0.000000	82.000000	72.000000	3.000000	1.000000	4.000000	1.000000	2.000000	3.000000	3.000000	0.000000	3.000000	0.000000	4.000000	4.000000	53.000000	65.000000	3.000000	2.000000	-1.000000
+1.000000	9.000000	38.200000	78.000000	60.000000	4.000000	4.000000	6.000000	0.000000	3.000000	3.000000	3.000000	0.000000	0.000000	0.000000	1.000000	0.000000	59.000000	5.800000	3.000000	3.100000	-1.000000
+2.000000	1.000000	37.800000	60.000000	16.000000	1.000000	1.000000	3.000000	1.000000	2.000000	3.000000	2.000000	1.000000	2.000000	0.000000	3.000000	0.000000	41.000000	73.000000	0.000000	0.000000	-1.000000
+1.000000	1.000000	38.700000	34.000000	30.000000	2.000000	0.000000	3.000000	1.000000	2.000000	3.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	33.000000	69.000000	0.000000	2.000000	-1.000000
+1.000000	1.000000	0.000000	36.000000	12.000000	1.000000	1.000000	1.000000	1.000000	1.000000	2.000000	1.000000	1.000000	1.000000	0.000000	1.000000	5.000000	44.000000	0.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	38.300000	44.000000	60.000000	0.000000	0.000000	1.000000	1.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	6.400000	36.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	37.400000	54.000000	18.000000	3.000000	0.000000	1.000000	1.000000	3.000000	4.000000	3.000000	2.000000	2.000000	0.000000	4.000000	5.000000	30.000000	7.100000	2.000000	0.000000	1.000000
+1.000000	1.000000	0.000000	0.000000	0.000000	4.000000	3.000000	0.000000	2.000000	2.000000	4.000000	1.000000	0.000000	0.000000	0.000000	0.000000	0.000000	54.000000	76.000000	3.000000	2.000000	1.000000
+1.000000	1.000000	36.600000	48.000000	16.000000	3.000000	1.000000	3.000000	1.000000	4.000000	1.000000	1.000000	1.000000	1.000000	0.000000	0.000000	0.000000	27.000000	56.000000	0.000000	0.000000	-1.000000
+1.000000	1.000000	38.500000	90.000000	0.000000	1.000000	1.000000	3.000000	1.000000	3.000000	3.000000	3.000000	2.000000	3.000000	2.000000	4.000000	5.000000	47.000000	79.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	0.000000	75.000000	12.000000	1.000000	1.000000	4.000000	1.000000	5.000000	3.000000	3.000000	0.000000	3.000000	5.800000	0.000000	0.000000	58.000000	8.500000	1.000000	0.000000	1.000000
+2.000000	1.000000	38.200000	42.000000	0.000000	3.000000	1.000000	1.000000	1.000000	1.000000	1.000000	2.000000	2.000000	1.000000	0.000000	3.000000	2.000000	35.000000	5.900000	2.000000	0.000000	1.000000
+1.000000	9.000000	38.200000	78.000000	60.000000	4.000000	4.000000	6.000000	0.000000	3.000000	3.000000	3.000000	0.000000	0.000000	0.000000	1.000000	0.000000	59.000000	5.800000	3.000000	3.100000	-1.000000
+2.000000	1.000000	38.600000	60.000000	30.000000	1.000000	1.000000	3.000000	1.000000	4.000000	2.000000	2.000000	1.000000	1.000000	0.000000	0.000000	0.000000	40.000000	6.000000	1.000000	0.000000	1.000000
+2.000000	1.000000	37.800000	42.000000	40.000000	1.000000	1.000000	1.000000	1.000000	1.000000	3.000000	1.000000	0.000000	0.000000	0.000000	3.000000	3.000000	36.000000	6.200000	0.000000	0.000000	1.000000
+1.000000	1.000000	38.000000	60.000000	12.000000	1.000000	1.000000	2.000000	1.000000	2.000000	1.000000	1.000000	1.000000	1.000000	0.000000	1.000000	4.000000	44.000000	65.000000	3.000000	2.000000	-1.000000
+2.000000	1.000000	38.000000	42.000000	12.000000	3.000000	0.000000	3.000000	1.000000	1.000000	1.000000	1.000000	0.000000	0.000000	0.000000	0.000000	1.000000	37.000000	5.800000	0.000000	0.000000	1.000000
+2.000000	1.000000	37.600000	88.000000	36.000000	3.000000	1.000000	1.000000	1.000000	3.000000	3.000000	2.000000	1.000000	3.000000	1.500000	0.000000	0.000000	44.000000	6.000000	0.000000	0.000000	-1.000000
diff --git a/data/cart.txt b/data/cart.txt
new file mode 100644
index 0000000..72b8e59
--- /dev/null
+++ b/data/cart.txt
@@ -0,0 +1,200 @@
+11.000000	0.409175	1.883180
+1.000000	0.182603	0.063908
+12.000000	0.663687	3.042257
+1.000000	0.517395	2.305004
+1.000000	0.013643	-0.067698
+1.000000	0.469643	1.662809
+1.000000	0.725426	3.275749
+31.000000	0.394350	1.118077
+1.000000	0.507760	2.095059
+41.000000	0.237395	1.181912
+1.000000	0.057534	0.221663
+1.000000	0.369820	0.938453
+1.000000	0.976819	4.149409
+15.000000	0.616051	3.105444
+61.000000	0.413700	1.896278
+1.000000	0.105279	-0.121345
+51.000000	0.670273	3.161652
+1.000000	0.952758	4.135358
+1.000000	0.272316	0.859063
+1.000000	0.303697	1.170272
+15.000000	0.486698	1.687960
+1.000000	0.511810	1.979745
+1.000000	0.195865	0.068690
+1.000000	0.986769	4.052137
+1.000000	0.785623	3.156316
+1.000000	0.797583	2.950630
+1.000000	0.081306	0.068935
+1.000000	0.659753	2.854020
+1.000000	0.375270	0.999743
+1.000000	0.819136	4.048082
+1.000000	0.142432	0.230923
+1.000000	0.215112	0.816693
+1.000000	0.041270	0.130713
+1.000000	0.044136	-0.537706
+1.000000	0.131337	-0.339109
+1.000000	0.463444	2.124538
+1.000000	0.671905	2.708292
+1.000000	0.946559	4.017390
+1.000000	0.904176	4.004021
+1.000000	0.306674	1.022555
+1.000000	0.819006	3.657442
+1.000000	0.845472	4.073619
+1.000000	0.156258	0.011994
+1.000000	0.857185	3.640429
+1.000000	0.400158	1.808497
+1.000000	0.375395	1.431404
+1.000000	0.885807	3.935544
+1.000000	0.239960	1.162152
+1.000000	0.148640	-0.227330
+1.000000	0.143143	-0.068728
+1.000000	0.321582	0.825051
+1.000000	0.509393	2.008645
+1.000000	0.355891	0.664566
+1.000000	0.938633	4.180202
+1.000000	0.348057	0.864845
+1.000000	0.438898	1.851174
+1.000000	0.781419	2.761993
+1.000000	0.911333	4.075914
+1.000000	0.032469	0.110229
+1.000000	0.499985	2.181987
+1.000000	0.771663	3.152528
+1.000000	0.670361	3.046564
+1.000000	0.176202	0.128954
+1.000000	0.392170	1.062726
+1.000000	0.911188	3.651742
+1.000000	0.872288	4.401950
+1.000000	0.733107	3.022888
+1.000000	0.610239	2.874917
+1.000000	0.732739	2.946801
+1.000000	0.714825	2.893644
+1.000000	0.076386	0.072131
+1.000000	0.559009	1.748275
+1.000000	0.427258	1.912047
+1.000000	0.841875	3.710686
+1.000000	0.558918	1.719148
+1.000000	0.533241	2.174090
+1.000000	0.956665	3.656357
+1.000000	0.620393	3.522504
+1.000000	0.566120	2.234126
+1.000000	0.523258	1.859772
+1.000000	0.476884	2.097017
+1.000000	0.176408	0.001794
+1.000000	0.303094	1.231928
+1.000000	0.609731	2.953862
+1.000000	0.017774	-0.116803
+1.000000	0.622616	2.638864
+1.000000	0.886539	3.943428
+1.000000	0.148654	-0.328513
+1.000000	0.104350	-0.099866
+1.000000	0.116868	-0.030836
+1.000000	0.516514	2.359786
+1.000000	0.664896	3.212581
+1.000000	0.004327	0.188975
+1.000000	0.425559	1.904109
+1.000000	0.743671	3.007114
+1.000000	0.935185	3.845834
+1.000000	0.697300	3.079411
+1.000000	0.444551	1.939739
+1.000000	0.683753	2.880078
+1.000000	0.755993	3.063577
+1.000000	0.902690	4.116296
+1.000000	0.094491	-0.240963
+1.000000	0.873831	4.066299
+1.000000	0.991810	4.011834
+1.000000	0.185611	0.077710
+1.000000	0.694551	3.103069
+1.000000	0.657275	2.811897
+1.000000	0.118746	-0.104630
+1.000000	0.084302	0.025216
+1.000000	0.945341	4.330063
+1.000000	0.785827	3.087091
+1.000000	0.530933	2.269988
+1.000000	0.879594	4.010701
+1.000000	0.652770	3.119542
+1.000000	0.879338	3.723411
+1.000000	0.764739	2.792078
+1.000000	0.504884	2.192787
+1.000000	0.554203	2.081305
+1.000000	0.493209	1.714463
+1.000000	0.363783	0.885854
+1.000000	0.316465	1.028187
+1.000000	0.580283	1.951497
+1.000000	0.542898	1.709427
+1.000000	0.112661	0.144068
+1.000000	0.816742	3.880240
+1.000000	0.234175	0.921876
+1.000000	0.402804	1.979316
+1.000000	0.709423	3.085768
+1.000000	0.867298	3.476122
+1.000000	0.993392	3.993679
+1.000000	0.711580	3.077880
+1.000000	0.133643	-0.105365
+1.000000	0.052031	-0.164703
+1.000000	0.366806	1.096814
+1.000000	0.697521	3.092879
+1.000000	0.787262	2.987926
+1.000000	0.476710	2.061264
+1.000000	0.721417	2.746854
+1.000000	0.230376	0.716710
+1.000000	0.104397	0.103831
+1.000000	0.197834	0.023776
+1.000000	0.129291	-0.033299
+1.000000	0.528528	1.942286
+1.000000	0.009493	-0.006338
+1.000000	0.998533	3.808753
+1.000000	0.363522	0.652799
+1.000000	0.901386	4.053747
+1.000000	0.832693	4.569290
+1.000000	0.119002	-0.032773
+1.000000	0.487638	2.066236
+1.000000	0.153667	0.222785
+1.000000	0.238619	1.089268
+1.000000	0.208197	1.487788
+1.000000	0.750921	2.852033
+1.000000	0.183403	0.024486
+1.000000	0.995608	3.737750
+1.000000	0.151311	0.045017
+1.000000	0.126804	0.001238
+1.000000	0.983153	3.892763
+1.000000	0.772495	2.819376
+1.000000	0.784133	2.830665
+1.000000	0.056934	0.234633
+1.000000	0.425584	1.810782
+1.000000	0.998709	4.237235
+1.000000	0.707815	3.034768
+1.000000	0.413816	1.742106
+1.000000	0.217152	1.169250
+1.000000	0.360503	0.831165
+1.000000	0.977989	3.729376
+1.000000	0.507953	1.823205
+1.000000	0.920771	4.021970
+1.000000	0.210542	1.262939
+1.000000	0.928611	4.159518
+1.000000	0.580373	2.039114
+1.000000	0.841390	4.101837
+1.000000	0.681530	2.778672
+1.000000	0.292795	1.228284
+1.000000	0.456918	1.736620
+1.000000	0.134128	-0.195046
+1.000000	0.016241	-0.063215
+1.000000	0.691214	3.305268
+1.000000	0.582002	2.063627
+1.000000	0.303102	0.898840
+1.000000	0.622598	2.701692
+1.000000	0.525024	1.992909
+1.000000	0.996775	3.811393
+1.000000	0.881025	4.353857
+1.000000	0.723457	2.635641
+1.000000	0.676346	2.856311
+1.000000	0.254625	1.352682
+1.000000	0.488632	2.336459
+1.000000	0.519875	2.111651
+1.000000	0.160176	0.121726
+1.000000	0.609483	3.264605
+1.000000	0.531881	2.103446
+1.000000	0.321632	0.896855
+1.000000	0.845148	4.220850
+1.000000	0.012003	-0.217283
+1.000000	0.018883	-0.300577
+1.000000	0.071476	0.006014
diff --git a/data/email/ham/1.txt b/data/email/ham/1.txt
new file mode 100644
index 0000000..a2c0049
--- /dev/null
+++ b/data/email/ham/1.txt
@@ -0,0 +1,8 @@
+Hi Peter,
+
+Witheee Jose out of town, do you want to
+meet once in a while to keep things
+going and do some interesting stuff?
+
+Let me know
+Eugene
\ No newline at end of file
diff --git a/data/email/ham/10.txt b/data/email/ham/10.txt
new file mode 100644
index 0000000..f4bbe08
--- /dev/null
+++ b/data/email/ham/10.txt
@@ -0,0 +1,4 @@
+Ryan Whybrew commented on your status.
+
+Ryan wrote:
+"turd ferguson or butt horn."
diff --git a/data/email/ham/11.txt b/data/email/ham/11.txt
new file mode 100644
index 0000000..a22b036
--- /dev/null
+++ b/data/email/ham/11.txt
@@ -0,0 +1,8 @@
+Arvind Thirumalai commented on your status.
+
+Arvind wrote:
+""you know""
+
+
+Reply to this email to comment on this status.
+
diff --git a/data/email/ham/12.txt b/data/email/ham/12.txt
new file mode 100644
index 0000000..d0150b0
--- /dev/null
+++ b/data/email/ham/12.txt
@@ -0,0 +1,11 @@
+Thanks Peter.
+
+I'll definitely check in on this. How is your book
+going? I heard chapter 1 came in and it was in 
+good shape. ;-)
+
+I hope you are doing well.
+
+Cheers,
+
+Troy
\ No newline at end of file
diff --git a/data/email/ham/13.txt b/data/email/ham/13.txt
new file mode 100644
index 0000000..0b05545
--- /dev/null
+++ b/data/email/ham/13.txt
@@ -0,0 +1,10 @@
+Jay Stepp commented on your status.
+
+Jay wrote:
+""to the" ???"
+
+
+Reply to this email to comment on this status.
+
+To see the comment thread, follow the link below:
+
diff --git a/data/email/ham/14.txt b/data/email/ham/14.txt
new file mode 100644
index 0000000..7b26277
--- /dev/null
+++ b/data/email/ham/14.txt
@@ -0,0 +1,10 @@
+LinkedIn
+
+Kerry Haloney requested to add you as a connection on LinkedIn:
+
+Peter,
+
+I'd like to add you to my professional network on LinkedIn.
+
+- Kerry Haloney
+ 
diff --git a/data/email/ham/15.txt b/data/email/ham/15.txt
new file mode 100644
index 0000000..62660f3
--- /dev/null
+++ b/data/email/ham/15.txt
@@ -0,0 +1,9 @@
+Hi Peter,
+ 
+The hotels are the ones that rent out the tent. They are all lined up on the hotel grounds : )) So much for being one with nature, more like being one with a couple dozen tour groups and nature.
+I have about 100M of pictures from that trip. I can go through them and get you jpgs of my favorite scenic pictures.
+ 
+Where are you and Jocelyn now? New York? Will you come to Tokyo for Chinese New Year? Perhaps to see the two of you then. I will go to Thailand for winter holiday to see my mom : )
+ 
+Take care,
+D
diff --git a/data/email/ham/16.txt b/data/email/ham/16.txt
new file mode 100644
index 0000000..1980ca6
--- /dev/null
+++ b/data/email/ham/16.txt
@@ -0,0 +1 @@
+yeah I am ready.  I may not be here because Jar Jar has plane tickets to Germany for me.  
\ No newline at end of file
diff --git a/data/email/ham/17.txt b/data/email/ham/17.txt
new file mode 100644
index 0000000..db43d33
--- /dev/null
+++ b/data/email/ham/17.txt
@@ -0,0 +1,11 @@
+Benoit Mandelbrot 1924-2010
+
+Benoit Mandelbrot 1924-2010
+
+Wilmott Team
+
+Benoit Mandelbrot, the mathematician, the father of fractal mathematics, and advocate of more sophisticated modelling in quantitative finance, died on 14th October 2010 aged 85.
+
+Wilmott magazine has often featured Mandelbrot, his ideas, and the work of others inspired by his fundamental insights.
+
+You must be logged on to view these articles from past issues of Wilmott Magazine.
\ No newline at end of file
diff --git a/data/email/ham/18.txt b/data/email/ham/18.txt
new file mode 100644
index 0000000..5a8b807
--- /dev/null
+++ b/data/email/ham/18.txt
@@ -0,0 +1,8 @@
+Hi Peter,
+
+    Sure thing.  Sounds good.  Let me know what time would be good for you.
+I will come prepared with some ideas and we can go from there.
+
+Regards,
+
+-Vivek.
\ No newline at end of file
diff --git a/data/email/ham/19.txt b/data/email/ham/19.txt
new file mode 100644
index 0000000..8377181
--- /dev/null
+++ b/data/email/ham/19.txt
@@ -0,0 +1,10 @@
+LinkedIn
+
+Julius O requested to add you as a connection on LinkedIn:
+
+Hi Peter.
+
+Looking forward to the book!
+
+ 
+Accept 	View invitation from Julius O
diff --git a/data/email/ham/2.txt b/data/email/ham/2.txt
new file mode 100644
index 0000000..23af9ba
--- /dev/null
+++ b/data/email/ham/2.txt
@@ -0,0 +1,3 @@
+Yay to you both doing fine!
+
+I'm working on an MBA in Design Strategy at CCA (top art school.)  It's a new program focusing on more of a right-brained creative and strategic approach to management.  I'm an 1/8 of the way done today!
\ No newline at end of file
diff --git a/data/email/ham/20.txt b/data/email/ham/20.txt
new file mode 100644
index 0000000..c0470e5
--- /dev/null
+++ b/data/email/ham/20.txt
@@ -0,0 +1,5 @@
+I've thought about this and think it's possible. We should get another
+lunch. I have a car now and could come pick you up this time. Does
+this wednesday work? 11:50?
+
+Can I have a signed copy of you book?
\ No newline at end of file
diff --git a/data/email/ham/21.txt b/data/email/ham/21.txt
new file mode 100644
index 0000000..3e44f48
--- /dev/null
+++ b/data/email/ham/21.txt
@@ -0,0 +1,6 @@
+we saw this on the way to the coast...thought u might like it
+
+hangzhou is huge, one day wasn't enough, but we got a glimpse...
+
+we went inside the china pavilion at expo, it is pretty interesting,
+each province has an exhibit...
\ No newline at end of file
diff --git a/data/email/ham/22.txt b/data/email/ham/22.txt
new file mode 100644
index 0000000..0b8282c
--- /dev/null
+++ b/data/email/ham/22.txt
@@ -0,0 +1,7 @@
+Hi Hommies,
+
+Just got a phone call from the roofer, they will come and spaying the foaming today. it will be dusty. pls close all the doors and windows.
+Could you help me to close my bathroom window, cat window and the sliding door behind the TV?
+I don't know how can those 2 cats survive......
+
+Sorry for any inconvenience!
\ No newline at end of file
diff --git a/data/email/ham/23.txt b/data/email/ham/23.txt
new file mode 100644
index 0000000..5dea955
--- /dev/null
+++ b/data/email/ham/23.txt
@@ -0,0 +1,7 @@
+
+SciFinance now automatically generates GPU-enabled pricing & risk model source code that runs up to 50-300x faster than serial code using a new NVIDIA Fermi-class Tesla 20-Series GPU.
+
+SciFinance� is a derivatives pricing and risk model development tool that automatically generates C/C++ and GPU-enabled source code from concise, high-level model specifications. No parallel computing or CUDA programming expertise is required.
+
+SciFinance's automatic, GPU-enabled Monte Carlo pricing model source code generation capabilities have been significantly extended in the latest release. This includes:
+
diff --git a/data/email/ham/24.txt b/data/email/ham/24.txt
new file mode 100644
index 0000000..3f272cc
--- /dev/null
+++ b/data/email/ham/24.txt
@@ -0,0 +1 @@
+Ok I will be there by 10:00 at the latest.
\ No newline at end of file
diff --git a/data/email/ham/25.txt b/data/email/ham/25.txt
new file mode 100644
index 0000000..6ef5714
--- /dev/null
+++ b/data/email/ham/25.txt
@@ -0,0 +1,2 @@
+That is cold.  Is there going to be a retirement party?  
+Are the leaves changing color?
\ No newline at end of file
diff --git a/data/email/ham/3.txt b/data/email/ham/3.txt
new file mode 100644
index 0000000..c0fb3dc
--- /dev/null
+++ b/data/email/ham/3.txt
@@ -0,0 +1,8 @@
+WHat is going on there?
+I talked to John on email.  We talked about some computer stuff that's it.
+
+I went bike riding in the rain, it was not that cold.
+
+We went to the museum in SF yesterday it was $3 to get in and they had
+free food.  At the same time was a SF Giants game, when we got done we
+had to take the train with all the Giants fans, they are 1/2 drunk.
\ No newline at end of file
diff --git a/data/email/ham/4.txt b/data/email/ham/4.txt
new file mode 100644
index 0000000..54f0ad9
--- /dev/null
+++ b/data/email/ham/4.txt
@@ -0,0 +1,3 @@
+Yo.  I've been working on my running website.  I'm using jquery and the jqplot plugin.  I'm not too far away from having a prototype to launch.  
+
+You used jqplot right?  If not, I think you would like it.
\ No newline at end of file
diff --git a/data/email/ham/5.txt b/data/email/ham/5.txt
new file mode 100644
index 0000000..77903ed
--- /dev/null
+++ b/data/email/ham/5.txt
@@ -0,0 +1,2 @@
+There was a guy at the gas station who told me that if I knew Mandarin
+and Python I could get a job with the FBI.
\ No newline at end of file
diff --git a/data/email/ham/6.txt b/data/email/ham/6.txt
new file mode 100644
index 0000000..537928a
--- /dev/null
+++ b/data/email/ham/6.txt
@@ -0,0 +1,7 @@
+Hello,
+
+Since you are an owner of at least one Google Groups group that uses the customized welcome message, pages or files, we are writing to inform you that we will no longer be supporting these features starting February 2011. We made this decision so that we can focus on improving the core functionalities of Google Groups -- mailing lists and forum discussions.  Instead of these features, we encourage you to use products that are designed specifically for file storage and page creation, such as Google Docs and Google Sites.
+
+For example, you can easily create your pages on Google Sites and share the site (http://www.google.com/support/sites/bin/answer.py?hl=en&answer=174623) with the members of your group. You can also store your files on the site by attaching files to pages (http://www.google.com/support/sites/bin/answer.py?hl=en&answer=90563) on the site. If you抮e just looking for a place to upload your files so that your group members can download them, we suggest you try Google Docs. You can upload files (http://docs.google.com/support/bin/answer.py?hl=en&answer=50092) and share access with either a group (http://docs.google.com/support/bin/answer.py?hl=en&answer=66343) or an individual (http://docs.google.com/support/bin/answer.py?hl=en&answer=86152), assigning either edit or download only access to the files.
+
+you have received this mandatory email service announcement to update you about important changes to Google Groups.
\ No newline at end of file
diff --git a/data/email/ham/7.txt b/data/email/ham/7.txt
new file mode 100644
index 0000000..8be6583
--- /dev/null
+++ b/data/email/ham/7.txt
@@ -0,0 +1,6 @@
+Zach Hamm commented on your status.
+
+Zach wrote:
+"doggy style - enough said, thank you & good night"
+
+
diff --git a/data/email/ham/8.txt b/data/email/ham/8.txt
new file mode 100644
index 0000000..8b71fb0
--- /dev/null
+++ b/data/email/ham/8.txt
@@ -0,0 +1,5 @@
+This e-mail was sent from a notification-only address that cannot accept incoming e-mail. Please do not reply to this message.
+
+Thank you for your online reservation. The store you selected has located the item you requested and has placed it on hold in your name. Please note that all items are held for 1 day.  Please note store prices may differ from those online.
+
+If you have questions or need assistance with your reservation, please contact the store at the phone number listed below. You can also access store information, such as store hours and location, on the web at http://www.borders.com/online/store/StoreDetailView_98.
\ No newline at end of file
diff --git a/data/email/ham/9.txt b/data/email/ham/9.txt
new file mode 100644
index 0000000..b4a2177
--- /dev/null
+++ b/data/email/ham/9.txt
@@ -0,0 +1,5 @@
+Hi Peter,
+
+These are the only good scenic ones and it's too bad there was a girl's back in one of them. Just try to enjoy the blue sky : ))
+
+D
\ No newline at end of file
diff --git a/data/email/spam/1.txt b/data/email/spam/1.txt
new file mode 100644
index 0000000..6a91ee8
--- /dev/null
+++ b/data/email/spam/1.txt
@@ -0,0 +1,4 @@
+--- Codeine 15mg -- 30 for $203.70 -- VISA Only!!! --
+
+-- Codeine (Methylmorphine) is a narcotic (opioid) pain reliever
+-- We have 15mg & 30mg pills -- 30/15mg for $203.70 - 60/15mg for $385.80 - 90/15mg for $562.50 -- VISA Only!!! ---
\ No newline at end of file
diff --git a/data/email/spam/10.txt b/data/email/spam/10.txt
new file mode 100644
index 0000000..d0000f5
--- /dev/null
+++ b/data/email/spam/10.txt
@@ -0,0 +1,6 @@
+OrderCializViagra Online & Save 75-90%
+
+0nline Pharmacy NoPrescription required
+Buy Canadian Drugs at Wholesale Prices and Save 75-90%
+FDA-Approved drugs + Superb Quality Drugs only!
+Accept all major credit cards
\ No newline at end of file
diff --git a/data/email/spam/11.txt b/data/email/spam/11.txt
new file mode 100644
index 0000000..322a40f
--- /dev/null
+++ b/data/email/spam/11.txt
@@ -0,0 +1,13 @@
+You Have Everything To Gain!
+
+Incredib1e gains in length of 3-4 inches to yourPenis, PERMANANTLY
+
+Amazing increase in thickness of yourPenis, up to 30%
+BetterEjacu1ation control
+Experience Rock-HardErecetions
+Explosive, intenseOrgasns
+Increase volume ofEjacu1ate
+Doctor designed and endorsed
+100% herbal, 100% Natural, 100% Safe
+The proven NaturalPenisEnhancement that works!
+100% MoneyBack Guaranteeed
\ No newline at end of file
diff --git a/data/email/spam/12.txt b/data/email/spam/12.txt
new file mode 100644
index 0000000..cf2c2dc
--- /dev/null
+++ b/data/email/spam/12.txt
@@ -0,0 +1,7 @@
+Buy Ambiem (Zolpidem) 5mg/10mg @ $2.39/- pill
+
+30 pills x 5 mg - $129.00
+60 pills x 5 mg - $199.20
+180 pills x 5 mg - $430.20
+30 pills x 10 mg - $ 138.00
+120 pills x 10 mg - $ 322.80
\ No newline at end of file
diff --git a/data/email/spam/13.txt b/data/email/spam/13.txt
new file mode 100644
index 0000000..2579c6d
--- /dev/null
+++ b/data/email/spam/13.txt
@@ -0,0 +1,7 @@
+OrderCializViagra Online & Save 75-90%
+
+0nline Pharmacy NoPrescription required
+Buy Canadian Drugs at Wholesale Prices and Save 75-90%
+FDA-Approved drugs + Superb Quality Drugs only!
+Accept all major credit cards
+        Order Today! From $1.38
diff --git a/data/email/spam/14.txt b/data/email/spam/14.txt
new file mode 100644
index 0000000..e02e7fc
--- /dev/null
+++ b/data/email/spam/14.txt
@@ -0,0 +1,7 @@
+BuyVIAGRA 25mg, 50mg, 100mg,
+BrandViagra, FemaleViagra from $1.15 per pill
+
+
+ViagraNoPrescription needed - from Certified Canadian Pharmacy
+
+Buy Here... We accept VISA, AMEX, E-Check... Worldwide Delivery
\ No newline at end of file
diff --git a/data/email/spam/15.txt b/data/email/spam/15.txt
new file mode 100644
index 0000000..b2b210e
--- /dev/null
+++ b/data/email/spam/15.txt
@@ -0,0 +1,11 @@
+You Have Everything To Gain!
+
+Incredib1e gains in length of 3-4 inches to yourPenis, PERMANANTLY
+
+Amazing increase in thickness of yourPenis, up to 30%
+BetterEjacu1ation control
+Experience Rock-HardErecetions
+Explosive, intenseOrgasns
+Increase volume ofEjacu1ate
+Doctor designed and endorsed
+100% herbal, 100% Natural, 100% Safe
\ No newline at end of file
diff --git a/data/email/spam/16.txt b/data/email/spam/16.txt
new file mode 100644
index 0000000..b2b210e
--- /dev/null
+++ b/data/email/spam/16.txt
@@ -0,0 +1,11 @@
+You Have Everything To Gain!
+
+Incredib1e gains in length of 3-4 inches to yourPenis, PERMANANTLY
+
+Amazing increase in thickness of yourPenis, up to 30%
+BetterEjacu1ation control
+Experience Rock-HardErecetions
+Explosive, intenseOrgasns
+Increase volume ofEjacu1ate
+Doctor designed and endorsed
+100% herbal, 100% Natural, 100% Safe
\ No newline at end of file
diff --git a/data/email/spam/17.txt b/data/email/spam/17.txt
new file mode 100644
index 0000000..cc16f0b
--- /dev/null
+++ b/data/email/spam/17.txt
@@ -0,0 +1,14 @@
+A home based business opportunity is knocking at your door.
+
+Don抰 be rude and let this chance go by.
+
+You can earn a great income and find
+your financial life transformed.
+
+Learn more Here.
+
+
+
+To Your Success.
+
+Work From Home Finder Experts
\ No newline at end of file
diff --git a/data/email/spam/18.txt b/data/email/spam/18.txt
new file mode 100644
index 0000000..13936b1
--- /dev/null
+++ b/data/email/spam/18.txt
@@ -0,0 +1,6 @@
+Codeine (the most competitive price on NET!)
+
+Codeine (WILSON) 30mg x 30 $156.00
+Codeine (WILSON) 30mg x 60 $291.00 (+4 FreeViagra pills)
+Codeine (WILSON) 30mg x 90 $396.00 (+4 FreeViagra pills)
+Codeine (WILSON) 30mg x 120 $492.00 (+10 FreeViagra pills)
\ No newline at end of file
diff --git a/data/email/spam/19.txt b/data/email/spam/19.txt
new file mode 100644
index 0000000..47ebfa1
--- /dev/null
+++ b/data/email/spam/19.txt
@@ -0,0 +1,13 @@
+Get Up to 75% OFF at Online WatchesStore
+
+Discount Watches for All Famous Brands
+
+* Watches: aRolexBvlgari, Dior, Hermes, Oris, Cartier, AP and more brands
+* Louis Vuitton Bags & Wallets
+* Gucci Bags
+* Tiffany & Co Jewerly
+
+Enjoy a full 1 year WARRANTY
+Shipment via reputable courier: FEDEX, UPS, DHL and EMS Speedpost
+You will 100% recieve your order
+Save Up to 75% OFF Quality Watches
\ No newline at end of file
diff --git a/data/email/spam/2.txt b/data/email/spam/2.txt
new file mode 100644
index 0000000..22fe388
--- /dev/null
+++ b/data/email/spam/2.txt
@@ -0,0 +1,8 @@
+Hydrocodone/Vicodin ES/Brand Watson
+
+Vicodin ES - 7.5/750 mg: 30 - $195 / 120 $570
+Brand Watson - 7.5/750 mg: 30 - $195 / 120 $570
+Brand Watson - 10/325 mg: 30 - $199 / 120 - $588
+NoPrescription Required
+FREE Express FedEx (3-5 days Delivery) for over $200 order
+Major Credit Cards + E-CHECK
\ No newline at end of file
diff --git a/data/email/spam/20.txt b/data/email/spam/20.txt
new file mode 100644
index 0000000..00ddace
--- /dev/null
+++ b/data/email/spam/20.txt
@@ -0,0 +1,12 @@
+Get Up to 75% OFF at Online WatchesStore
+
+Discount Watches for All Famous Brands
+
+* Watches: aRolexBvlgari, Dior, Hermes, Oris, Cartier, AP and more brands
+* Louis Vuitton Bags & Wallets
+* Gucci Bags
+* Tiffany & Co Jewerly
+
+Enjoy a full 1 year WARRANTY
+Shipment via reputable courier: FEDEX, UPS, DHL and EMS Speedpost
+You will 100% recieve your order
\ No newline at end of file
diff --git a/data/email/spam/21.txt b/data/email/spam/21.txt
new file mode 100644
index 0000000..48183f5
--- /dev/null
+++ b/data/email/spam/21.txt
@@ -0,0 +1,4 @@
+Percocet 10/625 mg withoutPrescription 30 tabs - $225!
+Percocet, a narcotic analgesic, is used to treat moderate to moderately SeverePain
+Top Quality, EXPRESS Shipping, 100% Safe & Discreet & Private.
+Buy Cheap Percocet Online
\ No newline at end of file
diff --git a/data/email/spam/22.txt b/data/email/spam/22.txt
new file mode 100644
index 0000000..00ddace
--- /dev/null
+++ b/data/email/spam/22.txt
@@ -0,0 +1,12 @@
+Get Up to 75% OFF at Online WatchesStore
+
+Discount Watches for All Famous Brands
+
+* Watches: aRolexBvlgari, Dior, Hermes, Oris, Cartier, AP and more brands
+* Louis Vuitton Bags & Wallets
+* Gucci Bags
+* Tiffany & Co Jewerly
+
+Enjoy a full 1 year WARRANTY
+Shipment via reputable courier: FEDEX, UPS, DHL and EMS Speedpost
+You will 100% recieve your order
\ No newline at end of file
diff --git a/data/email/spam/23.txt b/data/email/spam/23.txt
new file mode 100644
index 0000000..b2b210e
--- /dev/null
+++ b/data/email/spam/23.txt
@@ -0,0 +1,11 @@
+You Have Everything To Gain!
+
+Incredib1e gains in length of 3-4 inches to yourPenis, PERMANANTLY
+
+Amazing increase in thickness of yourPenis, up to 30%
+BetterEjacu1ation control
+Experience Rock-HardErecetions
+Explosive, intenseOrgasns
+Increase volume ofEjacu1ate
+Doctor designed and endorsed
+100% herbal, 100% Natural, 100% Safe
\ No newline at end of file
diff --git a/data/email/spam/24.txt b/data/email/spam/24.txt
new file mode 100644
index 0000000..b2b210e
--- /dev/null
+++ b/data/email/spam/24.txt
@@ -0,0 +1,11 @@
+You Have Everything To Gain!
+
+Incredib1e gains in length of 3-4 inches to yourPenis, PERMANANTLY
+
+Amazing increase in thickness of yourPenis, up to 30%
+BetterEjacu1ation control
+Experience Rock-HardErecetions
+Explosive, intenseOrgasns
+Increase volume ofEjacu1ate
+Doctor designed and endorsed
+100% herbal, 100% Natural, 100% Safe
\ No newline at end of file
diff --git a/data/email/spam/25.txt b/data/email/spam/25.txt
new file mode 100644
index 0000000..226e8cc
--- /dev/null
+++ b/data/email/spam/25.txt
@@ -0,0 +1,7 @@
+Experience with BiggerPenis Today! Grow 3-inches more
+
+The Safest & Most Effective Methods Of_PenisEn1argement.
+Save your time and money!
+BetterErections with effective Ma1eEnhancement products.
+
+#1 Ma1eEnhancement Supplement. Trusted by Millions. Buy Today!
\ No newline at end of file
diff --git a/data/email/spam/3.txt b/data/email/spam/3.txt
new file mode 100644
index 0000000..322a40f
--- /dev/null
+++ b/data/email/spam/3.txt
@@ -0,0 +1,13 @@
+You Have Everything To Gain!
+
+Incredib1e gains in length of 3-4 inches to yourPenis, PERMANANTLY
+
+Amazing increase in thickness of yourPenis, up to 30%
+BetterEjacu1ation control
+Experience Rock-HardErecetions
+Explosive, intenseOrgasns
+Increase volume ofEjacu1ate
+Doctor designed and endorsed
+100% herbal, 100% Natural, 100% Safe
+The proven NaturalPenisEnhancement that works!
+100% MoneyBack Guaranteeed
\ No newline at end of file
diff --git a/data/email/spam/4.txt b/data/email/spam/4.txt
new file mode 100644
index 0000000..48183f5
--- /dev/null
+++ b/data/email/spam/4.txt
@@ -0,0 +1,4 @@
+Percocet 10/625 mg withoutPrescription 30 tabs - $225!
+Percocet, a narcotic analgesic, is used to treat moderate to moderately SeverePain
+Top Quality, EXPRESS Shipping, 100% Safe & Discreet & Private.
+Buy Cheap Percocet Online
\ No newline at end of file
diff --git a/data/email/spam/5.txt b/data/email/spam/5.txt
new file mode 100644
index 0000000..6a91ee8
--- /dev/null
+++ b/data/email/spam/5.txt
@@ -0,0 +1,4 @@
+--- Codeine 15mg -- 30 for $203.70 -- VISA Only!!! --
+
+-- Codeine (Methylmorphine) is a narcotic (opioid) pain reliever
+-- We have 15mg & 30mg pills -- 30/15mg for $203.70 - 60/15mg for $385.80 - 90/15mg for $562.50 -- VISA Only!!! ---
\ No newline at end of file
diff --git a/data/email/spam/6.txt b/data/email/spam/6.txt
new file mode 100644
index 0000000..dbb487f
--- /dev/null
+++ b/data/email/spam/6.txt
@@ -0,0 +1,8 @@
+OEM Adobe & Microsoft softwares
+Fast order and download
+
+Microsoft Office Professional Plus 2007/2010 $129
+Microsoft Windows 7 Ultimate $119
+Adobe Photoshop CS5 Extended
+Adobe Acrobat 9 Pro Extended
+Windows XP Professional & thousand more titles
\ No newline at end of file
diff --git a/data/email/spam/7.txt b/data/email/spam/7.txt
new file mode 100644
index 0000000..c5cbd04
--- /dev/null
+++ b/data/email/spam/7.txt
@@ -0,0 +1,9 @@
+Bargains Here! Buy Phentermin 37.5 mg (K-25)
+
+Buy Genuine Phentermin at Low Cost
+VISA Accepted
+30 - $130.50
+60 - $219.00
+90 - $292.50
+120 - $366.00
+180 - $513.00
\ No newline at end of file
diff --git a/data/email/spam/8.txt b/data/email/spam/8.txt
new file mode 100644
index 0000000..b2b210e
--- /dev/null
+++ b/data/email/spam/8.txt
@@ -0,0 +1,11 @@
+You Have Everything To Gain!
+
+Incredib1e gains in length of 3-4 inches to yourPenis, PERMANANTLY
+
+Amazing increase in thickness of yourPenis, up to 30%
+BetterEjacu1ation control
+Experience Rock-HardErecetions
+Explosive, intenseOrgasns
+Increase volume ofEjacu1ate
+Doctor designed and endorsed
+100% herbal, 100% Natural, 100% Safe
\ No newline at end of file
diff --git a/data/email/spam/9.txt b/data/email/spam/9.txt
new file mode 100644
index 0000000..c5cbd04
--- /dev/null
+++ b/data/email/spam/9.txt
@@ -0,0 +1,9 @@
+Bargains Here! Buy Phentermin 37.5 mg (K-25)
+
+Buy Genuine Phentermin at Low Cost
+VISA Accepted
+30 - $130.50
+60 - $219.00
+90 - $292.50
+120 - $366.00
+180 - $513.00
\ No newline at end of file
diff --git a/data/email/test.txt b/data/email/test.txt
new file mode 100644
index 0000000..68cf508
--- /dev/null
+++ b/data/email/test.txt
@@ -0,0 +1,3 @@
+Hi
+
+my name is hh Codeine pain reliever working today! MBA 
\ No newline at end of file
diff --git a/data/id3.txt b/data/id3.txt
new file mode 100644
index 0000000..e55d62a
--- /dev/null
+++ b/data/id3.txt
@@ -0,0 +1,24 @@
+young	myope	no	reduced	nolenses
+young	myope	no	normal	soft
+young	myope	yes	reduced	nolenses
+young	myope	yes	normal	hard
+young	hyper	no	reduced	nolenses
+young	hyper	no	normal	soft
+young	hyper	yes	reduced	nolenses
+young	hyper	yes	normal	hard
+pre	myope	no	reduced	nolenses
+pre	myope	no	normal	soft
+pre	myope	yes	reduced	nolenses
+pre	myope	yes	normal	hard
+pre	hyper	no	reduced	nolenses
+pre	hyper	no	normal	soft
+pre	hyper	yes	reduced	nolenses
+pre	hyper	yes	normal	nolenses
+presbyopic	myope	no	reduced	nolenses
+presbyopic	myope	no	normal	nolenses
+presbyopic	myope	yes	reduced	nolenses
+presbyopic	myope	yes	normal	hard
+presbyopic	hyper	no	reduced	nolenses
+presbyopic	hyper	no	normal	soft
+presbyopic	hyper	yes	reduced	nolenses
+presbyopic	hyper	yes	normal	nolenses
diff --git a/data/kmeans.txt b/data/kmeans.txt
new file mode 100644
index 0000000..0fae57b
--- /dev/null
+++ b/data/kmeans.txt
@@ -0,0 +1,80 @@
+1.658985	4.285136
+-3.453687	3.424321
+4.838138	-1.151539
+-5.379713	-3.362104
+0.972564	2.924086
+-3.567919	1.531611
+0.450614	-3.302219
+-3.487105	-1.724432
+2.668759	1.594842
+-3.156485	3.191137
+3.165506	-3.999838
+-2.786837	-3.099354
+4.208187	2.984927
+-2.123337	2.943366
+0.704199	-0.479481
+-0.392370	-3.963704
+2.831667	1.574018
+-0.790153	3.343144
+2.943496	-3.357075
+-3.195883	-2.283926
+2.336445	2.875106
+-1.786345	2.554248
+2.190101	-1.906020
+-3.403367	-2.778288
+1.778124	3.880832
+-1.688346	2.230267
+2.592976	-2.054368
+-4.007257	-3.207066
+2.257734	3.387564
+-2.679011	0.785119
+0.939512	-4.023563
+-3.674424	-2.261084
+2.046259	2.735279
+-3.189470	1.780269
+4.372646	-0.822248
+-2.579316	-3.497576
+1.889034	5.190400
+-0.798747	2.185588
+2.836520	-2.658556
+-3.837877	-3.253815
+2.096701	3.886007
+-2.709034	2.923887
+3.367037	-3.184789
+-2.121479	-4.232586
+2.329546	3.179764
+-3.284816	3.273099
+3.091414	-3.815232
+-3.762093	-2.432191
+3.542056	2.778832
+-1.736822	4.241041
+2.127073	-2.983680
+-4.323818	-3.938116
+3.792121	5.135768
+-4.786473	3.358547
+2.624081	-3.260715
+-4.009299	-2.978115
+2.493525	1.963710
+-2.513661	2.642162
+1.864375	-3.176309
+-3.171184	-3.572452
+2.894220	2.489128
+-2.562539	2.884438
+3.491078	-3.947487
+-2.565729	-2.012114
+3.332948	3.983102
+-1.616805	3.573188
+2.280615	-2.559444
+-2.651229	-3.103198
+2.321395	3.154987
+-1.685703	2.939697
+3.031012	-3.620252
+-4.599622	-2.185829
+4.196223	1.126677
+-2.133863	3.093686
+4.668892	-2.562705
+-2.793241	-2.149706
+2.884105	3.043438
+-2.967647	2.848696
+4.479332	-1.764772
+-4.905566	-2.911070
diff --git a/data/knn.txt b/data/knn.txt
new file mode 100644
index 0000000..dd889d6
--- /dev/null
+++ b/data/knn.txt
@@ -0,0 +1,1000 @@
+40920	8.326976	0.953952	3
+14488	7.153469	1.673904	2
+26052	1.441871	0.805124	1
+75136	13.147394	0.428964	1
+38344	1.669788	0.134296	1
+72993	10.141740	1.032955	1
+35948	6.830792	1.213192	3
+42666	13.276369	0.543880	3
+67497	8.631577	0.749278	1
+35483	12.273169	1.508053	3
+50242	3.723498	0.831917	1
+63275	8.385879	1.669485	1
+5569	4.875435	0.728658	2
+51052	4.680098	0.625224	1
+77372	15.299570	0.331351	1
+43673	1.889461	0.191283	1
+61364	7.516754	1.269164	1
+69673	14.239195	0.261333	1
+15669	0.000000	1.250185	2
+28488	10.528555	1.304844	3
+6487	3.540265	0.822483	2
+37708	2.991551	0.833920	1
+22620	5.297865	0.638306	2
+28782	6.593803	0.187108	3
+19739	2.816760	1.686209	2
+36788	12.458258	0.649617	3
+5741	0.000000	1.656418	2
+28567	9.968648	0.731232	3
+6808	1.364838	0.640103	2
+41611	0.230453	1.151996	1
+36661	11.865402	0.882810	3
+43605	0.120460	1.352013	1
+15360	8.545204	1.340429	3
+63796	5.856649	0.160006	1
+10743	9.665618	0.778626	2
+70808	9.778763	1.084103	1
+72011	4.932976	0.632026	1
+5914	2.216246	0.587095	2
+14851	14.305636	0.632317	3
+33553	12.591889	0.686581	3
+44952	3.424649	1.004504	1
+17934	0.000000	0.147573	2
+27738	8.533823	0.205324	3
+29290	9.829528	0.238620	3
+42330	11.492186	0.263499	3
+36429	3.570968	0.832254	1
+39623	1.771228	0.207612	1
+32404	3.513921	0.991854	1
+27268	4.398172	0.975024	1
+5477	4.276823	1.174874	2
+14254	5.946014	1.614244	2
+68613	13.798970	0.724375	1
+41539	10.393591	1.663724	3
+7917	3.007577	0.297302	2
+21331	1.031938	0.486174	2
+8338	4.751212	0.064693	2
+5176	3.692269	1.655113	2
+18983	10.448091	0.267652	3
+68837	10.585786	0.329557	1
+13438	1.604501	0.069064	2
+48849	3.679497	0.961466	1
+12285	3.795146	0.696694	2
+7826	2.531885	1.659173	2
+5565	9.733340	0.977746	2
+10346	6.093067	1.413798	2
+1823	7.712960	1.054927	2
+9744	11.470364	0.760461	3
+16857	2.886529	0.934416	2
+39336	10.054373	1.138351	3
+65230	9.972470	0.881876	1
+2463	2.335785	1.366145	2
+27353	11.375155	1.528626	3
+16191	0.000000	0.605619	2
+12258	4.126787	0.357501	2
+42377	6.319522	1.058602	1
+25607	8.680527	0.086955	3
+77450	14.856391	1.129823	1
+58732	2.454285	0.222380	1
+46426	7.292202	0.548607	3
+32688	8.745137	0.857348	3
+64890	8.579001	0.683048	1
+8554	2.507302	0.869177	2
+28861	11.415476	1.505466	3
+42050	4.838540	1.680892	1
+32193	10.339507	0.583646	3
+64895	6.573742	1.151433	1
+2355	6.539397	0.462065	2
+0	2.209159	0.723567	2
+70406	11.196378	0.836326	1
+57399	4.229595	0.128253	1
+41732	9.505944	0.005273	3
+11429	8.652725	1.348934	3
+75270	17.101108	0.490712	1
+5459	7.871839	0.717662	2
+73520	8.262131	1.361646	1
+40279	9.015635	1.658555	3
+21540	9.215351	0.806762	3
+17694	6.375007	0.033678	2
+22329	2.262014	1.022169	1
+46570	5.677110	0.709469	1
+42403	11.293017	0.207976	3
+33654	6.590043	1.353117	1
+9171	4.711960	0.194167	2
+28122	8.768099	1.108041	3
+34095	11.502519	0.545097	3
+1774	4.682812	0.578112	2
+40131	12.446578	0.300754	3
+13994	12.908384	1.657722	3
+77064	12.601108	0.974527	1
+11210	3.929456	0.025466	2
+6122	9.751503	1.182050	3
+15341	3.043767	0.888168	2
+44373	4.391522	0.807100	1
+28454	11.695276	0.679015	3
+63771	7.879742	0.154263	1
+9217	5.613163	0.933632	2
+69076	9.140172	0.851300	1
+24489	4.258644	0.206892	1
+16871	6.799831	1.221171	2
+39776	8.752758	0.484418	3
+5901	1.123033	1.180352	2
+40987	10.833248	1.585426	3
+7479	3.051618	0.026781	2
+38768	5.308409	0.030683	3
+4933	1.841792	0.028099	2
+32311	2.261978	1.605603	1
+26501	11.573696	1.061347	3
+37433	8.038764	1.083910	3
+23503	10.734007	0.103715	3
+68607	9.661909	0.350772	1
+27742	9.005850	0.548737	3
+11303	0.000000	0.539131	2
+0	5.757140	1.062373	2
+32729	9.164656	1.624565	3
+24619	1.318340	1.436243	1
+42414	14.075597	0.695934	3
+20210	10.107550	1.308398	3
+33225	7.960293	1.219760	3
+54483	6.317292	0.018209	1
+18475	12.664194	0.595653	3
+33926	2.906644	0.581657	1
+43865	2.388241	0.913938	1
+26547	6.024471	0.486215	3
+44404	7.226764	1.255329	3
+16674	4.183997	1.275290	2
+8123	11.850211	1.096981	3
+42747	11.661797	1.167935	3
+56054	3.574967	0.494666	1
+10933	0.000000	0.107475	2
+18121	7.937657	0.904799	3
+11272	3.365027	1.014085	2
+16297	0.000000	0.367491	2
+28168	13.860672	1.293270	3
+40963	10.306714	1.211594	3
+31685	7.228002	0.670670	3
+55164	4.508740	1.036192	1
+17595	0.366328	0.163652	2
+1862	3.299444	0.575152	2
+57087	0.573287	0.607915	1
+63082	9.183738	0.012280	1
+51213	7.842646	1.060636	3
+6487	4.750964	0.558240	2
+4805	11.438702	1.556334	3
+30302	8.243063	1.122768	3
+68680	7.949017	0.271865	1
+17591	7.875477	0.227085	2
+74391	9.569087	0.364856	1
+37217	7.750103	0.869094	3
+42814	0.000000	1.515293	1
+14738	3.396030	0.633977	2
+19896	11.916091	0.025294	3
+14673	0.460758	0.689586	2
+32011	13.087566	0.476002	3
+58736	4.589016	1.672600	1
+54744	8.397217	1.534103	1
+29482	5.562772	1.689388	1
+27698	10.905159	0.619091	3
+11443	1.311441	1.169887	2
+56117	10.647170	0.980141	3
+39514	0.000000	0.481918	1
+26627	8.503025	0.830861	3
+16525	0.436880	1.395314	2
+24368	6.127867	1.102179	1
+22160	12.112492	0.359680	3
+6030	1.264968	1.141582	2
+6468	6.067568	1.327047	2
+22945	8.010964	1.681648	3
+18520	3.791084	0.304072	2
+34914	11.773195	1.262621	3
+6121	8.339588	1.443357	2
+38063	2.563092	1.464013	1
+23410	5.954216	0.953782	1
+35073	9.288374	0.767318	3
+52914	3.976796	1.043109	1
+16801	8.585227	1.455708	3
+9533	1.271946	0.796506	2
+16721	0.000000	0.242778	2
+5832	0.000000	0.089749	2
+44591	11.521298	0.300860	3
+10143	1.139447	0.415373	2
+21609	5.699090	1.391892	2
+23817	2.449378	1.322560	1
+15640	0.000000	1.228380	2
+8847	3.168365	0.053993	2
+50939	10.428610	1.126257	3
+28521	2.943070	1.446816	1
+32901	10.441348	0.975283	3
+42850	12.478764	1.628726	3
+13499	5.856902	0.363883	2
+40345	2.476420	0.096075	1
+43547	1.826637	0.811457	1
+70758	4.324451	0.328235	1
+19780	1.376085	1.178359	2
+44484	5.342462	0.394527	1
+54462	11.835521	0.693301	3
+20085	12.423687	1.424264	3
+42291	12.161273	0.071131	3
+47550	8.148360	1.649194	3
+11938	1.531067	1.549756	2
+40699	3.200912	0.309679	1
+70908	8.862691	0.530506	1
+73989	6.370551	0.369350	1
+11872	2.468841	0.145060	2
+48463	11.054212	0.141508	3
+15987	2.037080	0.715243	2
+70036	13.364030	0.549972	1
+32967	10.249135	0.192735	3
+63249	10.464252	1.669767	1
+42795	9.424574	0.013725	3
+14459	4.458902	0.268444	2
+19973	0.000000	0.575976	2
+5494	9.686082	1.029808	3
+67902	13.649402	1.052618	1
+25621	13.181148	0.273014	3
+27545	3.877472	0.401600	1
+58656	1.413952	0.451380	1
+7327	4.248986	1.430249	2
+64555	8.779183	0.845947	1
+8998	4.156252	0.097109	2
+11752	5.580018	0.158401	2
+76319	15.040440	1.366898	1
+27665	12.793870	1.307323	3
+67417	3.254877	0.669546	1
+21808	10.725607	0.588588	3
+15326	8.256473	0.765891	2
+20057	8.033892	1.618562	3
+79341	10.702532	0.204792	1
+15636	5.062996	1.132555	2
+35602	10.772286	0.668721	3
+28544	1.892354	0.837028	1
+57663	1.019966	0.372320	1
+78727	15.546043	0.729742	1
+68255	11.638205	0.409125	1
+14964	3.427886	0.975616	2
+21835	11.246174	1.475586	3
+7487	0.000000	0.645045	2
+8700	0.000000	1.424017	2
+26226	8.242553	0.279069	3
+65899	8.700060	0.101807	1
+6543	0.812344	0.260334	2
+46556	2.448235	1.176829	1
+71038	13.230078	0.616147	1
+47657	0.236133	0.340840	1
+19600	11.155826	0.335131	3
+37422	11.029636	0.505769	3
+1363	2.901181	1.646633	2
+26535	3.924594	1.143120	1
+47707	2.524806	1.292848	1
+38055	3.527474	1.449158	1
+6286	3.384281	0.889268	2
+10747	0.000000	1.107592	2
+44883	11.898890	0.406441	3
+56823	3.529892	1.375844	1
+68086	11.442677	0.696919	1
+70242	10.308145	0.422722	1
+11409	8.540529	0.727373	2
+67671	7.156949	1.691682	1
+61238	0.720675	0.847574	1
+17774	0.229405	1.038603	2
+53376	3.399331	0.077501	1
+30930	6.157239	0.580133	1
+28987	1.239698	0.719989	1
+13655	6.036854	0.016548	2
+7227	5.258665	0.933722	2
+40409	12.393001	1.571281	3
+13605	9.627613	0.935842	2
+26400	11.130453	0.597610	3
+13491	8.842595	0.349768	3
+30232	10.690010	1.456595	3
+43253	5.714718	1.674780	3
+55536	3.052505	1.335804	1
+8807	0.000000	0.059025	2
+25783	9.945307	1.287952	3
+22812	2.719723	1.142148	1
+77826	11.154055	1.608486	1
+38172	2.687918	0.660836	1
+31676	10.037847	0.962245	3
+74038	12.404762	1.112080	1
+44738	10.237305	0.633422	3
+17410	4.745392	0.662520	2
+5688	4.639461	1.569431	2
+36642	3.149310	0.639669	1
+29956	13.406875	1.639194	3
+60350	6.068668	0.881241	1
+23758	9.477022	0.899002	3
+25780	3.897620	0.560201	2
+11342	5.463615	1.203677	2
+36109	3.369267	1.575043	1
+14292	5.234562	0.825954	2
+11160	0.000000	0.722170	2
+23762	12.979069	0.504068	3
+39567	5.376564	0.557476	1
+25647	13.527910	1.586732	3
+14814	2.196889	0.784587	2
+73590	10.691748	0.007509	1
+35187	1.659242	0.447066	1
+49459	8.369667	0.656697	3
+31657	13.157197	0.143248	3
+6259	8.199667	0.908508	2
+33101	4.441669	0.439381	3
+27107	9.846492	0.644523	3
+17824	0.019540	0.977949	2
+43536	8.253774	0.748700	3
+67705	6.038620	1.509646	1
+35283	6.091587	1.694641	3
+71308	8.986820	1.225165	1
+31054	11.508473	1.624296	3
+52387	8.807734	0.713922	3
+40328	0.000000	0.816676	1
+34844	8.889202	1.665414	3
+11607	3.178117	0.542752	2
+64306	7.013795	0.139909	1
+32721	9.605014	0.065254	3
+33170	1.230540	1.331674	1
+37192	10.412811	0.890803	3
+13089	0.000000	0.567161	2
+66491	9.699991	0.122011	1
+15941	0.000000	0.061191	2
+4272	4.455293	0.272135	2
+48812	3.020977	1.502803	1
+28818	8.099278	0.216317	3
+35394	1.157764	1.603217	1
+71791	10.105396	0.121067	1
+40668	11.230148	0.408603	3
+39580	9.070058	0.011379	3
+11786	0.566460	0.478837	2
+19251	0.000000	0.487300	2
+56594	8.956369	1.193484	3
+54495	1.523057	0.620528	1
+11844	2.749006	0.169855	2
+45465	9.235393	0.188350	3
+31033	10.555573	0.403927	3
+16633	6.956372	1.519308	2
+13887	0.636281	1.273984	2
+52603	3.574737	0.075163	1
+72000	9.032486	1.461809	1
+68497	5.958993	0.023012	1
+35135	2.435300	1.211744	1
+26397	10.539731	1.638248	3
+7313	7.646702	0.056513	2
+91273	20.919349	0.644571	1
+24743	1.424726	0.838447	1
+31690	6.748663	0.890223	3
+15432	2.289167	0.114881	2
+58394	5.548377	0.402238	1
+33962	6.057227	0.432666	1
+31442	10.828595	0.559955	3
+31044	11.318160	0.271094	3
+29938	13.265311	0.633903	3
+9875	0.000000	1.496715	2
+51542	6.517133	0.402519	3
+11878	4.934374	1.520028	2
+69241	10.151738	0.896433	1
+37776	2.425781	1.559467	1
+68997	9.778962	1.195498	1
+67416	12.219950	0.657677	1
+59225	7.394151	0.954434	1
+29138	8.518535	0.742546	3
+5962	2.798700	0.662632	2
+10847	0.637930	0.617373	2
+70527	10.750490	0.097415	1
+9610	0.625382	0.140969	2
+64734	10.027968	0.282787	1
+25941	9.817347	0.364197	3
+2763	0.646828	1.266069	2
+55601	3.347111	0.914294	1
+31128	11.816892	0.193798	3
+5181	0.000000	1.480198	2
+69982	10.945666	0.993219	1
+52440	10.244706	0.280539	3
+57350	2.579801	1.149172	1
+57869	2.630410	0.098869	1
+56557	11.746200	1.695517	3
+42342	8.104232	1.326277	3
+15560	12.409743	0.790295	3
+34826	12.167844	1.328086	3
+8569	3.198408	0.299287	2
+77623	16.055513	0.541052	1
+78184	7.138659	0.158481	1
+7036	4.831041	0.761419	2
+69616	10.082890	1.373611	1
+21546	10.066867	0.788470	3
+36715	8.129538	0.329913	3
+20522	3.012463	1.138108	2
+42349	3.720391	0.845974	1
+9037	0.773493	1.148256	2
+26728	10.962941	1.037324	3
+587	0.177621	0.162614	2
+48915	3.085853	0.967899	1
+9824	8.426781	0.202558	2
+4135	1.825927	1.128347	2
+9666	2.185155	1.010173	2
+59333	7.184595	1.261338	1
+36198	0.000000	0.116525	1
+34909	8.901752	1.033527	3
+47516	2.451497	1.358795	1
+55807	3.213631	0.432044	1
+14036	3.974739	0.723929	2
+42856	9.601306	0.619232	3
+64007	8.363897	0.445341	1
+59428	6.381484	1.365019	1
+13730	0.000000	1.403914	2
+41740	9.609836	1.438105	3
+63546	9.904741	0.985862	1
+30417	7.185807	1.489102	3
+69636	5.466703	1.216571	1
+64660	0.000000	0.915898	1
+14883	4.575443	0.535671	2
+7965	3.277076	1.010868	2
+68620	10.246623	1.239634	1
+8738	2.341735	1.060235	2
+7544	3.201046	0.498843	2
+6377	6.066013	0.120927	2
+36842	8.829379	0.895657	3
+81046	15.833048	1.568245	1
+67736	13.516711	1.220153	1
+32492	0.664284	1.116755	1
+39299	6.325139	0.605109	3
+77289	8.677499	0.344373	1
+33835	8.188005	0.964896	3
+71890	9.414263	0.384030	1
+32054	9.196547	1.138253	3
+38579	10.202968	0.452363	3
+55984	2.119439	1.481661	1
+72694	13.635078	0.858314	1
+42299	0.083443	0.701669	1
+26635	9.149096	1.051446	3
+8579	1.933803	1.374388	2
+37302	14.115544	0.676198	3
+22878	8.933736	0.943352	3
+4364	2.661254	0.946117	2
+4985	0.988432	1.305027	2
+37068	2.063741	1.125946	1
+41137	2.220590	0.690754	1
+67759	6.424849	0.806641	1
+11831	1.156153	1.613674	2
+34502	3.032720	0.601847	1
+4088	3.076828	0.952089	2
+15199	0.000000	0.318105	2
+17309	7.750480	0.554015	3
+42816	10.958135	1.482500	3
+43751	10.222018	0.488678	3
+58335	2.367988	0.435741	1
+75039	7.686054	1.381455	1
+42878	11.464879	1.481589	3
+42770	11.075735	0.089726	3
+8848	3.543989	0.345853	2
+31340	8.123889	1.282880	3
+41413	4.331769	0.754467	3
+12731	0.120865	1.211961	2
+22447	6.116109	0.701523	3
+33564	7.474534	0.505790	3
+48907	8.819454	0.649292	3
+8762	6.802144	0.615284	2
+46696	12.666325	0.931960	3
+36851	8.636180	0.399333	3
+67639	11.730991	1.289833	1
+171	8.132449	0.039062	2
+26674	10.296589	1.496144	3
+8739	7.583906	1.005764	2
+66668	9.777806	0.496377	1
+68732	8.833546	0.513876	1
+69995	4.907899	1.518036	1
+82008	8.362736	1.285939	1
+25054	9.084726	1.606312	3
+33085	14.164141	0.560970	3
+41379	9.080683	0.989920	3
+39417	6.522767	0.038548	3
+12556	3.690342	0.462281	2
+39432	3.563706	0.242019	1
+38010	1.065870	1.141569	1
+69306	6.683796	1.456317	1
+38000	1.712874	0.243945	1
+46321	13.109929	1.280111	3
+66293	11.327910	0.780977	1
+22730	4.545711	1.233254	1
+5952	3.367889	0.468104	2
+72308	8.326224	0.567347	1
+60338	8.978339	1.442034	1
+13301	5.655826	1.582159	2
+27884	8.855312	0.570684	3
+11188	6.649568	0.544233	2
+56796	3.966325	0.850410	1
+8571	1.924045	1.664782	2
+4914	6.004812	0.280369	2
+10784	0.000000	0.375849	2
+39296	9.923018	0.092192	3
+13113	2.389084	0.119284	2
+70204	13.663189	0.133251	1
+46813	11.434976	0.321216	3
+11697	0.358270	1.292858	2
+44183	9.598873	0.223524	3
+2225	6.375275	0.608040	2
+29066	11.580532	0.458401	3
+4245	5.319324	1.598070	2
+34379	4.324031	1.603481	1
+44441	2.358370	1.273204	1
+2022	0.000000	1.182708	2
+26866	12.824376	0.890411	3
+57070	1.587247	1.456982	1
+32932	8.510324	1.520683	3
+51967	10.428884	1.187734	3
+44432	8.346618	0.042318	3
+67066	7.541444	0.809226	1
+17262	2.540946	1.583286	2
+79728	9.473047	0.692513	1
+14259	0.352284	0.474080	2
+6122	0.000000	0.589826	2
+76879	12.405171	0.567201	1
+11426	4.126775	0.871452	2
+2493	0.034087	0.335848	2
+19910	1.177634	0.075106	2
+10939	0.000000	0.479996	2
+17716	0.994909	0.611135	2
+31390	11.053664	1.180117	3
+20375	0.000000	1.679729	2
+26309	2.495011	1.459589	1
+33484	11.516831	0.001156	3
+45944	9.213215	0.797743	3
+4249	5.332865	0.109288	2
+6089	0.000000	1.689771	2
+7513	0.000000	1.126053	2
+27862	12.640062	1.690903	3
+39038	2.693142	1.317518	1
+19218	3.328969	0.268271	2
+62911	7.193166	1.117456	1
+77758	6.615512	1.521012	1
+27940	8.000567	0.835341	3
+2194	4.017541	0.512104	2
+37072	13.245859	0.927465	3
+15585	5.970616	0.813624	2
+25577	11.668719	0.886902	3
+8777	4.283237	1.272728	2
+29016	10.742963	0.971401	3
+21910	12.326672	1.592608	3
+12916	0.000000	0.344622	2
+10976	0.000000	0.922846	2
+79065	10.602095	0.573686	1
+36759	10.861859	1.155054	3
+50011	1.229094	1.638690	1
+1155	0.410392	1.313401	2
+71600	14.552711	0.616162	1
+30817	14.178043	0.616313	3
+54559	14.136260	0.362388	1
+29764	0.093534	1.207194	1
+69100	10.929021	0.403110	1
+47324	11.432919	0.825959	3
+73199	9.134527	0.586846	1
+44461	5.071432	1.421420	1
+45617	11.460254	1.541749	3
+28221	11.620039	1.103553	3
+7091	4.022079	0.207307	2
+6110	3.057842	1.631262	2
+79016	7.782169	0.404385	1
+18289	7.981741	0.929789	3
+43679	4.601363	0.268326	1
+22075	2.595564	1.115375	1
+23535	10.049077	0.391045	3
+25301	3.265444	1.572970	2
+32256	11.780282	1.511014	3
+36951	3.075975	0.286284	1
+31290	1.795307	0.194343	1
+38953	11.106979	0.202415	3
+35257	5.994413	0.800021	1
+25847	9.706062	1.012182	3
+32680	10.582992	0.836025	3
+62018	7.038266	1.458979	1
+9074	0.023771	0.015314	2
+33004	12.823982	0.676371	3
+44588	3.617770	0.493483	1
+32565	8.346684	0.253317	3
+38563	6.104317	0.099207	1
+75668	16.207776	0.584973	1
+9069	6.401969	1.691873	2
+53395	2.298696	0.559757	1
+28631	7.661515	0.055981	3
+71036	6.353608	1.645301	1
+71142	10.442780	0.335870	1
+37653	3.834509	1.346121	1
+76839	10.998587	0.584555	1
+9916	2.695935	1.512111	2
+38889	3.356646	0.324230	1
+39075	14.677836	0.793183	3
+48071	1.551934	0.130902	1
+7275	2.464739	0.223502	2
+41804	1.533216	1.007481	1
+35665	12.473921	0.162910	3
+67956	6.491596	0.032576	1
+41892	10.506276	1.510747	3
+38844	4.380388	0.748506	1
+74197	13.670988	1.687944	1
+14201	8.317599	0.390409	2
+3908	0.000000	0.556245	2
+2459	0.000000	0.290218	2
+32027	10.095799	1.188148	3
+12870	0.860695	1.482632	2
+9880	1.557564	0.711278	2
+72784	10.072779	0.756030	1
+17521	0.000000	0.431468	2
+50283	7.140817	0.883813	3
+33536	11.384548	1.438307	3
+9452	3.214568	1.083536	2
+37457	11.720655	0.301636	3
+17724	6.374475	1.475925	3
+43869	5.749684	0.198875	3
+264	3.871808	0.552602	2
+25736	8.336309	0.636238	3
+39584	9.710442	1.503735	3
+31246	1.532611	1.433898	1
+49567	9.785785	0.984614	3
+7052	2.633627	1.097866	2
+35493	9.238935	0.494701	3
+10986	1.205656	1.398803	2
+49508	3.124909	1.670121	1
+5734	7.935489	1.585044	2
+65479	12.746636	1.560352	1
+77268	10.732563	0.545321	1
+28490	3.977403	0.766103	1
+13546	4.194426	0.450663	2
+37166	9.610286	0.142912	3
+16381	4.797555	1.260455	2
+10848	1.615279	0.093002	2
+35405	4.614771	1.027105	1
+15917	0.000000	1.369726	2
+6131	0.608457	0.512220	2
+67432	6.558239	0.667579	1
+30354	12.315116	0.197068	3
+69696	7.014973	1.494616	1
+33481	8.822304	1.194177	3
+43075	10.086796	0.570455	3
+38343	7.241614	1.661627	3
+14318	4.602395	1.511768	2
+5367	7.434921	0.079792	2
+37894	10.467570	1.595418	3
+36172	9.948127	0.003663	3
+40123	2.478529	1.568987	1
+10976	5.938545	0.878540	2
+12705	0.000000	0.948004	2
+12495	5.559181	1.357926	2
+35681	9.776654	0.535966	3
+46202	3.092056	0.490906	1
+11505	0.000000	1.623311	2
+22834	4.459495	0.538867	1
+49901	8.334306	1.646600	3
+71932	11.226654	0.384686	1
+13279	3.904737	1.597294	2
+49112	7.038205	1.211329	3
+77129	9.836120	1.054340	1
+37447	1.990976	0.378081	1
+62397	9.005302	0.485385	1
+0	1.772510	1.039873	2
+15476	0.458674	0.819560	2
+40625	10.003919	0.231658	3
+36706	0.520807	1.476008	1
+28580	10.678214	1.431837	3
+25862	4.425992	1.363842	1
+63488	12.035355	0.831222	1
+33944	10.606732	1.253858	3
+30099	1.568653	0.684264	1
+13725	2.545434	0.024271	2
+36768	10.264062	0.982593	3
+64656	9.866276	0.685218	1
+14927	0.142704	0.057455	2
+43231	9.853270	1.521432	3
+66087	6.596604	1.653574	1
+19806	2.602287	1.321481	2
+41081	10.411776	0.664168	3
+10277	7.083449	0.622589	2
+7014	2.080068	1.254441	2
+17275	0.522844	1.622458	2
+31600	10.362000	1.544827	3
+59956	3.412967	1.035410	1
+42181	6.796548	1.112153	3
+51743	4.092035	0.075804	1
+5194	2.763811	1.564325	2
+30832	12.547439	1.402443	3
+7976	5.708052	1.596152	2
+14602	4.558025	0.375806	2
+41571	11.642307	0.438553	3
+55028	3.222443	0.121399	1
+5837	4.736156	0.029871	2
+39808	10.839526	0.836323	3
+20944	4.194791	0.235483	2
+22146	14.936259	0.888582	3
+42169	3.310699	1.521855	1
+7010	2.971931	0.034321	2
+3807	9.261667	0.537807	2
+29241	7.791833	1.111416	3
+52696	1.480470	1.028750	1
+42545	3.677287	0.244167	1
+24437	2.202967	1.370399	1
+16037	5.796735	0.935893	2
+8493	3.063333	0.144089	2
+68080	11.233094	0.492487	1
+59016	1.965570	0.005697	1
+11810	8.616719	0.137419	2
+68630	6.609989	1.083505	1
+7629	1.712639	1.086297	2
+71992	10.117445	1.299319	1
+13398	0.000000	1.104178	2
+26241	9.824777	1.346821	3
+11160	1.653089	0.980949	2
+76701	18.178822	1.473671	1
+32174	6.781126	0.885340	3
+45043	8.206750	1.549223	3
+42173	10.081853	1.376745	3
+69801	6.288742	0.112799	1
+41737	3.695937	1.543589	1
+46979	6.726151	1.069380	3
+79267	12.969999	1.568223	1
+4615	2.661390	1.531933	2
+32907	7.072764	1.117386	3
+37444	9.123366	1.318988	3
+569	3.743946	1.039546	2
+8723	2.341300	0.219361	2
+6024	0.541913	0.592348	2
+52252	2.310828	1.436753	1
+8358	6.226597	1.427316	2
+26166	7.277876	0.489252	3
+18471	0.000000	0.389459	2
+3386	7.218221	1.098828	2
+41544	8.777129	1.111464	3
+10480	2.813428	0.819419	2
+5894	2.268766	1.412130	2
+7273	6.283627	0.571292	2
+22272	7.520081	1.626868	3
+31369	11.739225	0.027138	3
+10708	3.746883	0.877350	2
+69364	12.089835	0.521631	1
+37760	12.310404	0.259339	3
+13004	0.000000	0.671355	2
+37885	2.728800	0.331502	1
+52555	10.814342	0.607652	3
+38997	12.170268	0.844205	3
+69698	6.698371	0.240084	1
+11783	3.632672	1.643479	2
+47636	10.059991	0.892361	3
+15744	1.887674	0.756162	2
+69058	8.229125	0.195886	1
+33057	7.817082	0.476102	3
+28681	12.277230	0.076805	3
+34042	10.055337	1.115778	3
+29928	3.596002	1.485952	1
+9734	2.755530	1.420655	2
+7344	7.780991	0.513048	2
+7387	0.093705	0.391834	2
+33957	8.481567	0.520078	3
+9936	3.865584	0.110062	2
+36094	9.683709	0.779984	3
+39835	10.617255	1.359970	3
+64486	7.203216	1.624762	1
+0	7.601414	1.215605	2
+39539	1.386107	1.417070	1
+66972	9.129253	0.594089	1
+15029	1.363447	0.620841	2
+44909	3.181399	0.359329	1
+38183	13.365414	0.217011	3
+37372	4.207717	1.289767	1
+0	4.088395	0.870075	2
+17786	3.327371	1.142505	2
+39055	1.303323	1.235650	1
+37045	7.999279	1.581763	3
+6435	2.217488	0.864536	2
+72265	7.751808	0.192451	1
+28152	14.149305	1.591532	3
+25931	8.765721	0.152808	3
+7538	3.408996	0.184896	2
+1315	1.251021	0.112340	2
+12292	6.160619	1.537165	2
+49248	1.034538	1.585162	1
+9025	0.000000	1.034635	2
+13438	2.355051	0.542603	2
+69683	6.614543	0.153771	1
+25374	10.245062	1.450903	3
+55264	3.467074	1.231019	1
+38324	7.487678	1.572293	3
+69643	4.624115	1.185192	1
+44058	8.995957	1.436479	3
+41316	11.564476	0.007195	3
+29119	3.440948	0.078331	1
+51656	1.673603	0.732746	1
+3030	4.719341	0.699755	2
+35695	10.304798	1.576488	3
+1537	2.086915	1.199312	2
+9083	6.338220	1.131305	2
+47744	8.254926	0.710694	3
+71372	16.067108	0.974142	1
+37980	1.723201	0.310488	1
+42385	3.785045	0.876904	1
+22687	2.557561	0.123738	1
+39512	9.852220	1.095171	3
+11885	3.679147	1.557205	2
+4944	9.789681	0.852971	2
+73230	14.958998	0.526707	1
+17585	11.182148	1.288459	3
+68737	7.528533	1.657487	1
+13818	5.253802	1.378603	2
+31662	13.946752	1.426657	3
+86686	15.557263	1.430029	1
+43214	12.483550	0.688513	3
+24091	2.317302	1.411137	1
+52544	10.069724	0.766119	3
+61861	5.792231	1.615483	1
+47903	4.138435	0.475994	1
+37190	12.929517	0.304378	3
+6013	9.378238	0.307392	2
+27223	8.361362	1.643204	3
+69027	7.939406	1.325042	1
+78642	10.735384	0.705788	1
+30254	11.592723	0.286188	3
+21704	10.098356	0.704748	3
+34985	9.299025	0.545337	3
+31316	11.158297	0.218067	3
+76368	16.143900	0.558388	1
+27953	10.971700	1.221787	3
+152	0.000000	0.681478	2
+9146	3.178961	1.292692	2
+75346	17.625350	0.339926	1
+26376	1.995833	0.267826	1
+35255	10.640467	0.416181	3
+19198	9.628339	0.985462	3
+12518	4.662664	0.495403	2
+25453	5.754047	1.382742	2
+12530	0.000000	0.037146	2
+62230	9.334332	0.198118	1
+9517	3.846162	0.619968	2
+71161	10.685084	0.678179	1
+1593	4.752134	0.359205	2
+33794	0.697630	0.966786	1
+39710	10.365836	0.505898	3
+16941	0.461478	0.352865	2
+69209	11.339537	1.068740	1
+4446	5.420280	0.127310	2
+9347	3.469955	1.619947	2
+55635	8.517067	0.994858	3
+65889	8.306512	0.413690	1
+10753	2.628690	0.444320	2
+7055	0.000000	0.802985	2
+7905	0.000000	1.170397	2
+53447	7.298767	1.582346	3
+9194	7.331319	1.277988	2
+61914	9.392269	0.151617	1
+15630	5.541201	1.180596	2
+79194	15.149460	0.537540	1
+12268	5.515189	0.250562	2
+33682	7.728898	0.920494	3
+26080	11.318785	1.510979	3
+19119	3.574709	1.531514	2
+30902	7.350965	0.026332	3
+63039	7.122363	1.630177	1
+51136	1.828412	1.013702	1
+35262	10.117989	1.156862	3
+42776	11.309897	0.086291	3
+64191	8.342034	1.388569	1
+15436	0.241714	0.715577	2
+14402	10.482619	1.694972	2
+6341	9.289510	1.428879	2
+14113	4.269419	0.134181	2
+6390	0.000000	0.189456	2
+8794	0.817119	0.143668	2
+43432	1.508394	0.652651	1
+38334	9.359918	0.052262	3
+34068	10.052333	0.550423	3
+30819	11.111660	0.989159	3
+22239	11.265971	0.724054	3
+28725	10.383830	0.254836	3
+57071	3.878569	1.377983	1
+72420	13.679237	0.025346	1
+28294	10.526846	0.781569	3
+9896	0.000000	0.924198	2
+65821	4.106727	1.085669	1
+7645	8.118856	1.470686	2
+71289	7.796874	0.052336	1
+5128	2.789669	1.093070	2
+13711	6.226962	0.287251	2
+22240	10.169548	1.660104	3
+15092	0.000000	1.370549	2
+5017	7.513353	0.137348	2
+10141	8.240793	0.099735	2
+35570	14.612797	1.247390	3
+46893	3.562976	0.445386	1
+8178	3.230482	1.331698	2
+55783	3.612548	1.551911	1
+1148	0.000000	0.332365	2
+10062	3.931299	0.487577	2
+74124	14.752342	1.155160	1
+66603	10.261887	1.628085	1
+11893	2.787266	1.570402	2
+50908	15.112319	1.324132	3
+39891	5.184553	0.223382	3
+65915	3.868359	0.128078	1
+65678	3.507965	0.028904	1
+62996	11.019254	0.427554	1
+36851	3.812387	0.655245	1
+36669	11.056784	0.378725	3
+38876	8.826880	1.002328	3
+26878	11.173861	1.478244	3
+46246	11.506465	0.421993	3
+12761	7.798138	0.147917	3
+35282	10.155081	1.370039	3
+68306	10.645275	0.693453	1
+31262	9.663200	1.521541	3
+34754	10.790404	1.312679	3
+13408	2.810534	0.219962	2
+30365	9.825999	1.388500	3
+10709	1.421316	0.677603	2
+24332	11.123219	0.809107	3
+45517	13.402206	0.661524	3
+6178	1.212255	0.836807	2
+10639	1.568446	1.297469	2
+29613	3.343473	1.312266	1
+22392	5.400155	0.193494	1
+51126	3.818754	0.590905	1
+53644	7.973845	0.307364	3
+51417	9.078824	0.734876	3
+24859	0.153467	0.766619	1
+61732	8.325167	0.028479	1
+71128	7.092089	1.216733	1
+27276	5.192485	1.094409	3
+30453	10.340791	1.087721	3
+18670	2.077169	1.019775	2
+70600	10.151966	0.993105	1
+12683	0.046826	0.809614	2
+81597	11.221874	1.395015	1
+69959	14.497963	1.019254	1
+8124	3.554508	0.533462	2
+18867	3.522673	0.086725	2
+80886	14.531655	0.380172	1
+55895	3.027528	0.885457	1
+31587	1.845967	0.488985	1
+10591	10.226164	0.804403	3
+70096	10.965926	1.212328	1
+53151	2.129921	1.477378	1
+11992	0.000000	1.606849	2
+33114	9.489005	0.827814	3
+7413	0.000000	1.020797	2
+10583	0.000000	1.270167	2
+58668	6.556676	0.055183	1
+35018	9.959588	0.060020	3
+70843	7.436056	1.479856	1
+14011	0.404888	0.459517	2
+35015	9.952942	1.650279	3
+70839	15.600252	0.021935	1
+3024	2.723846	0.387455	2
+5526	0.513866	1.323448	2
+5113	0.000000	0.861859	2
+20851	7.280602	1.438470	2
+40999	9.161978	1.110180	3
+15823	0.991725	0.730979	2
+35432	7.398380	0.684218	3
+53711	12.149747	1.389088	3
+64371	9.149678	0.874905	1
+9289	9.666576	1.370330	2
+60613	3.620110	0.287767	1
+18338	5.238800	1.253646	2
+22845	14.715782	1.503758	3
+74676	14.445740	1.211160	1
+34143	13.609528	0.364240	3
+14153	3.141585	0.424280	2
+9327	0.000000	0.120947	2
+18991	0.454750	1.033280	2
+9193	0.510310	0.016395	2
+2285	3.864171	0.616349	2
+9493	6.724021	0.563044	2
+2371	4.289375	0.012563	2
+13963	0.000000	1.437030	2
+2299	3.733617	0.698269	2
+5262	2.002589	1.380184	2
+4659	2.502627	0.184223	2
+17582	6.382129	0.876581	2
+27750	8.546741	0.128706	3
+9868	2.694977	0.432818	2
+18333	3.951256	0.333300	2
+3780	9.856183	0.329181	2
+18190	2.068962	0.429927	2
+11145	3.410627	0.631838	2
+68846	9.974715	0.669787	1
+26575	10.650102	0.866627	3
+48111	9.134528	0.728045	3
+43757	7.882601	1.332446	3
diff --git a/data/knnTest.txt b/data/knnTest.txt
new file mode 100644
index 0000000..e9af3ca
--- /dev/null
+++ b/data/knnTest.txt
@@ -0,0 +1,9 @@
+50242	3.723498	0.831917	1
+63275	8.385879	1.669485	1
+5569	4.875435	0.728658	2
+51052	4.680098	0.625224	1
+77372	15.299570	0.331351	1
+43673	1.889461	0.191283	1
+61364	7.516754	1.269164	1
+69673	14.239195	0.261333	1
+15669	0.000000	1.250185	2
diff --git a/data/lineReg.txt b/data/lineReg.txt
new file mode 100644
index 0000000..c84b0cd
--- /dev/null
+++ b/data/lineReg.txt
@@ -0,0 +1,200 @@
+1.000000	0.067732	3.176513
+1.000000	0.427810	3.816464
+1.000000	0.995731	4.550095
+1.000000	0.738336	4.256571
+1.000000	0.981083	4.560815
+1.000000	0.526171	3.929515
+1.000000	0.378887	3.526170
+1.000000	0.033859	3.156393
+1.000000	0.132791	3.110301
+1.000000	0.138306	3.149813
+1.000000	0.247809	3.476346
+1.000000	0.648270	4.119688
+1.000000	0.731209	4.282233
+1.000000	0.236833	3.486582
+1.000000	0.969788	4.655492
+1.000000	0.607492	3.965162
+1.000000	0.358622	3.514900
+1.000000	0.147846	3.125947
+1.000000	0.637820	4.094115
+1.000000	0.230372	3.476039
+1.000000	0.070237	3.210610
+1.000000	0.067154	3.190612
+1.000000	0.925577	4.631504
+1.000000	0.717733	4.295890
+1.000000	0.015371	3.085028
+1.000000	0.335070	3.448080
+1.000000	0.040486	3.167440
+1.000000	0.212575	3.364266
+1.000000	0.617218	3.993482
+1.000000	0.541196	3.891471
+1.000000	0.045353	3.143259
+1.000000	0.126762	3.114204
+1.000000	0.556486	3.851484
+1.000000	0.901144	4.621899
+1.000000	0.958476	4.580768
+1.000000	0.274561	3.620992
+1.000000	0.394396	3.580501
+1.000000	0.872480	4.618706
+1.000000	0.409932	3.676867
+1.000000	0.908969	4.641845
+1.000000	0.166819	3.175939
+1.000000	0.665016	4.264980
+1.000000	0.263727	3.558448
+1.000000	0.231214	3.436632
+1.000000	0.552928	3.831052
+1.000000	0.047744	3.182853
+1.000000	0.365746	3.498906
+1.000000	0.495002	3.946833
+1.000000	0.493466	3.900583
+1.000000	0.792101	4.238522
+1.000000	0.769660	4.233080
+1.000000	0.251821	3.521557
+1.000000	0.181951	3.203344
+1.000000	0.808177	4.278105
+1.000000	0.334116	3.555705
+1.000000	0.338630	3.502661
+1.000000	0.452584	3.859776
+1.000000	0.694770	4.275956
+1.000000	0.590902	3.916191
+1.000000	0.307928	3.587961
+1.000000	0.148364	3.183004
+1.000000	0.702180	4.225236
+1.000000	0.721544	4.231083
+1.000000	0.666886	4.240544
+1.000000	0.124931	3.222372
+1.000000	0.618286	4.021445
+1.000000	0.381086	3.567479
+1.000000	0.385643	3.562580
+1.000000	0.777175	4.262059
+1.000000	0.116089	3.208813
+1.000000	0.115487	3.169825
+1.000000	0.663510	4.193949
+1.000000	0.254884	3.491678
+1.000000	0.993888	4.533306
+1.000000	0.295434	3.550108
+1.000000	0.952523	4.636427
+1.000000	0.307047	3.557078
+1.000000	0.277261	3.552874
+1.000000	0.279101	3.494159
+1.000000	0.175724	3.206828
+1.000000	0.156383	3.195266
+1.000000	0.733165	4.221292
+1.000000	0.848142	4.413372
+1.000000	0.771184	4.184347
+1.000000	0.429492	3.742878
+1.000000	0.162176	3.201878
+1.000000	0.917064	4.648964
+1.000000	0.315044	3.510117
+1.000000	0.201473	3.274434
+1.000000	0.297038	3.579622
+1.000000	0.336647	3.489244
+1.000000	0.666109	4.237386
+1.000000	0.583888	3.913749
+1.000000	0.085031	3.228990
+1.000000	0.687006	4.286286
+1.000000	0.949655	4.628614
+1.000000	0.189912	3.239536
+1.000000	0.844027	4.457997
+1.000000	0.333288	3.513384
+1.000000	0.427035	3.729674
+1.000000	0.466369	3.834274
+1.000000	0.550659	3.811155
+1.000000	0.278213	3.598316
+1.000000	0.918769	4.692514
+1.000000	0.886555	4.604859
+1.000000	0.569488	3.864912
+1.000000	0.066379	3.184236
+1.000000	0.335751	3.500796
+1.000000	0.426863	3.743365
+1.000000	0.395746	3.622905
+1.000000	0.694221	4.310796
+1.000000	0.272760	3.583357
+1.000000	0.503495	3.901852
+1.000000	0.067119	3.233521
+1.000000	0.038326	3.105266
+1.000000	0.599122	3.865544
+1.000000	0.947054	4.628625
+1.000000	0.671279	4.231213
+1.000000	0.434811	3.791149
+1.000000	0.509381	3.968271
+1.000000	0.749442	4.253910
+1.000000	0.058014	3.194710
+1.000000	0.482978	3.996503
+1.000000	0.466776	3.904358
+1.000000	0.357767	3.503976
+1.000000	0.949123	4.557545
+1.000000	0.417320	3.699876
+1.000000	0.920461	4.613614
+1.000000	0.156433	3.140401
+1.000000	0.656662	4.206717
+1.000000	0.616418	3.969524
+1.000000	0.853428	4.476096
+1.000000	0.133295	3.136528
+1.000000	0.693007	4.279071
+1.000000	0.178449	3.200603
+1.000000	0.199526	3.299012
+1.000000	0.073224	3.209873
+1.000000	0.286515	3.632942
+1.000000	0.182026	3.248361
+1.000000	0.621523	3.995783
+1.000000	0.344584	3.563262
+1.000000	0.398556	3.649712
+1.000000	0.480369	3.951845
+1.000000	0.153350	3.145031
+1.000000	0.171846	3.181577
+1.000000	0.867082	4.637087
+1.000000	0.223855	3.404964
+1.000000	0.528301	3.873188
+1.000000	0.890192	4.633648
+1.000000	0.106352	3.154768
+1.000000	0.917886	4.623637
+1.000000	0.014855	3.078132
+1.000000	0.567682	3.913596
+1.000000	0.068854	3.221817
+1.000000	0.603535	3.938071
+1.000000	0.532050	3.880822
+1.000000	0.651362	4.176436
+1.000000	0.901225	4.648161
+1.000000	0.204337	3.332312
+1.000000	0.696081	4.240614
+1.000000	0.963924	4.532224
+1.000000	0.981390	4.557105
+1.000000	0.987911	4.610072
+1.000000	0.990947	4.636569
+1.000000	0.736021	4.229813
+1.000000	0.253574	3.500860
+1.000000	0.674722	4.245514
+1.000000	0.939368	4.605182
+1.000000	0.235419	3.454340
+1.000000	0.110521	3.180775
+1.000000	0.218023	3.380820
+1.000000	0.869778	4.565020
+1.000000	0.196830	3.279973
+1.000000	0.958178	4.554241
+1.000000	0.972673	4.633520
+1.000000	0.745797	4.281037
+1.000000	0.445674	3.844426
+1.000000	0.470557	3.891601
+1.000000	0.549236	3.849728
+1.000000	0.335691	3.492215
+1.000000	0.884739	4.592374
+1.000000	0.918916	4.632025
+1.000000	0.441815	3.756750
+1.000000	0.116598	3.133555
+1.000000	0.359274	3.567919
+1.000000	0.814811	4.363382
+1.000000	0.387125	3.560165
+1.000000	0.982243	4.564305
+1.000000	0.780880	4.215055
+1.000000	0.652565	4.174999
+1.000000	0.870030	4.586640
+1.000000	0.604755	3.960008
+1.000000	0.255212	3.529963
+1.000000	0.730546	4.213412
+1.000000	0.493829	3.908685
+1.000000	0.257017	3.585821
+1.000000	0.833735	4.374394
+1.000000	0.070095	3.213817
+1.000000	0.527070	3.952681
+1.000000	0.116163	3.129283
diff --git a/data/logReg.txt b/data/logReg.txt
new file mode 100644
index 0000000..ef294ef
--- /dev/null
+++ b/data/logReg.txt
@@ -0,0 +1,100 @@
+1   -0.017612	14.053064	0
+1   -1.395634	4.662541	1
+1   -0.752157	6.538620	0
+1   -1.322371	7.152853	0
+1    0.423363	11.054677	0
+1    0.406704	7.067335	1
+1    0.667394	12.741452	0
+1    -2.460150	6.866805	1
+1    0.569411	9.548755	0
+1    -0.026632	10.427743	0
+1    0.850433	6.920334	1
+1    1.347183	13.175500	0
+1    1.176813	3.167020	1
+1   -1.781871	9.097953	0
+ 1   -0.566606	5.749003	1
+1    0.931635	1.589505	1
+1    -0.024205	6.151823	1
+1    -0.036453	2.690988	1
+1    -0.196949	0.444165	1
+1    1.014459	5.754399	1
+1    1.985298	3.230619	1
+1    -1.693453	-0.557540	1
+1    -0.576525	11.778922	0
+ 1   -0.346811	-1.678730	1
+ 1   -2.124484	2.672471	1
+1    1.217916	9.597015	0
+1    -0.733928	9.098687	0
+1    -3.642001	-1.618087	1
+1    0.315985	3.523953	1
+1    1.416614	9.619232	0
+1    -0.386323	3.989286	1
+1    0.556921	8.294984	1
+ 1   1.224863	11.587360	0
+1    -1.347803	-2.406051	1
+1    1.196604	4.951851	1
+1    0.275221	9.543647	0
+1    0.470575	9.332488	0
+1    -1.889567	9.542662	0
+1    -1.527893	12.150579	0
+1   -1.185247	11.309318	0
+1   -0.445678	3.297303	1
+1   1.042222	6.105155	1
+1   -0.618787	10.320986	0
+1   1.152083	0.548467	1
+1   0.828534	2.676045	1
+1   -1.237728	10.549033	0
+1   -0.683565	-2.166125	1
+1   0.229456	5.921938	1
+1   -0.959885	11.555336	0
+1   0.492911	10.993324	0
+1   0.184992	8.721488	0
+1   -0.355715	10.325976	0
+1   -0.397822	8.058397	0
+1   0.824839	13.730343	0
+1   1.507278	5.027866	1
+1    0.099671	6.835839	1
+1   -0.344008	10.717485	0
+1   1.785928	7.718645	1
+1   -0.918801	11.560217	0
+1   -0.364009	4.747300	1
+1   -0.841722	4.119083	1
+1   0.490426	1.960539	1
+1   -0.007194	9.075792	0
+1   0.356107	12.447863	0
+1   0.342578	12.281162	0
+1   -0.810823	-1.466018	1
+1    2.530777	6.476801	1
+1   1.296683	11.607559	0
+1   0.475487	12.040035	0
+1    -0.783277	11.009725	0
+1    0.074798	11.023650	0
+1   -1.337472	0.468339	1
+1   -0.102781	13.763651	0
+1   -0.147324	2.874846	1
+1   0.518389	9.887035	0
+1   1.015399	7.571882	0
+1   -1.658086	-0.027255	1
+1    1.319944	2.171228	1
+1    2.056216	5.019981	1
+1   -0.851633	4.375691	1
+1   -1.510047	6.061992	0
+1   -1.076637	-3.181888	1
+1    1.821096	10.283990	0
+1   3.010150	8.401766	1
+1   -1.099458	1.688274	1
+1   -0.834872	-1.733869	1
+1   -0.846637	3.849075	1
+1    1.400102	12.628781	0
+1   1.752842	5.468166	1
+1   0.078557	0.059736	1
+1   0.089392	-0.715300	1
+1   1.825662	12.693808	0
+1   0.197445	9.744638	0
+1   0.126117	0.922311	1
+1   -0.679797	1.220530	1
+1  0.677983	2.556666	1
+1   0.761349	10.693862	0
+1   -2.168791	0.143632	1
+ 1  1.388610	9.341997	0
+1   0.317029	14.739025	0
diff --git a/data/svm.txt b/data/svm.txt
new file mode 100644
index 0000000..538931e
--- /dev/null
+++ b/data/svm.txt
@@ -0,0 +1,100 @@
+3.542485	1.977398	-1
+3.018896	2.556416	-1
+7.551510	-1.580030	1
+2.114999	-0.004466	-1
+8.127113	1.274372	1
+7.108772	-0.986906	1
+8.610639	2.046708	1
+2.326297	0.265213	-1
+3.634009	1.730537	-1
+0.341367	-0.894998	-1
+3.125951	0.293251	-1
+2.123252	-0.783563	-1
+0.887835	-2.797792	-1
+7.139979	-2.329896	1
+1.696414	-1.212496	-1
+8.117032	0.623493	1
+8.497162	-0.266649	1
+4.658191	3.507396	-1
+8.197181	1.545132	1
+1.208047	0.213100	-1
+1.928486	-0.321870	-1
+2.175808	-0.014527	-1
+7.886608	0.461755	1
+3.223038	-0.552392	-1
+3.628502	2.190585	-1
+7.407860	-0.121961	1
+7.286357	0.251077	1
+2.301095	-0.533988	-1
+-0.232542	-0.547690	-1
+3.457096	-0.082216	-1
+3.023938	-0.057392	-1
+8.015003	0.885325	1
+8.991748	0.923154	1
+7.916831	-1.781735	1
+7.616862	-0.217958	1
+2.450939	0.744967	-1
+7.270337	-2.507834	1
+1.749721	-0.961902	-1
+1.803111	-0.176349	-1
+8.804461	3.044301	1
+1.231257	-0.568573	-1
+2.074915	1.410550	-1
+-0.743036	-1.736103	-1
+3.536555	3.964960	-1
+8.410143	0.025606	1
+7.382988	-0.478764	1
+6.960661	-0.245353	1
+8.234460	0.701868	1
+8.168618	-0.903835	1
+1.534187	-0.622492	-1
+9.229518	2.066088	1
+7.886242	0.191813	1
+2.893743	-1.643468	-1
+1.870457	-1.040420	-1
+5.286862	-2.358286	1
+6.080573	0.418886	1
+2.544314	1.714165	-1
+6.016004	-3.753712	1
+0.926310	-0.564359	-1
+0.870296	-0.109952	-1
+2.369345	1.375695	-1
+1.363782	-0.254082	-1
+7.279460	-0.189572	1
+1.896005	0.515080	-1
+8.102154	-0.603875	1
+2.529893	0.662657	-1
+1.963874	-0.365233	-1
+8.132048	0.785914	1
+8.245938	0.372366	1
+6.543888	0.433164	1
+-0.236713	-5.766721	-1
+8.112593	0.295839	1
+9.803425	1.495167	1
+1.497407	-0.552916	-1
+1.336267	-1.632889	-1
+9.205805	-0.586480	1
+1.966279	-1.840439	-1
+8.398012	1.584918	1
+7.239953	-1.764292	1
+7.556201	0.241185	1
+9.015509	0.345019	1
+8.266085	-0.230977	1
+8.545620	2.788799	1
+9.295969	1.346332	1
+2.404234	0.570278	-1
+2.037772	0.021919	-1
+1.727631	-0.453143	-1
+1.979395	-0.050773	-1
+8.092288	-1.372433	1
+1.667645	0.239204	-1
+9.854303	1.365116	1
+7.921057	-1.327587	1
+8.500757	1.492372	1
+1.339746	-0.291183	-1
+3.107511	0.758367	-1
+2.609525	0.902979	-1
+3.263585	1.367898	-1
+2.912122	-0.202359	-1
+1.731786	0.589096	-1
+2.387003	1.573131	-1
diff --git a/dtgh_mdp.cpp b/dtgh_mdp.cpp
new file mode 100644
index 0000000..cb01ccd
--- /dev/null
+++ b/dtgh_mdp.cpp
@@ -0,0 +1,613 @@
+/**
+动态规划求解马尔科夫决策过程
+
+**/
+/**
+
+1 简单递归实现
+
+**/
+
+/*
+#include <iostream>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stack>
+#define max_vertex_num 20
+#define error -1
+#define ok 1
+#define size 12
+using namespace std;
+typedef struct arccell
+{
+    int adj;//结点间的关系即权
+    char *info;
+} arccell,adjmatrix[max_vertex_num][max_vertex_num];
+typedef struct mgraph
+{
+    int vexs[max_vertex_num];//各顶点名称
+    adjmatrix arcs;//邻接矩阵
+    int vexnum,arcnum;//图当前的顶点数和弧数
+    double reward[max_vertex_num];//每个状态的回报
+} mgraph;
+bool visited[max_vertex_num];
+int matrix[size][size]=
+{
+    {0,1,0,0,1,0,0,0,0,0,0,0},
+    {1,0,1,0,0,0,0,0,0,0,0,0},
+    {0,1,0,1,0,0,1,0,0,0,0,0},
+    {0,0,1,0,0,0,0,1,0,0,0,0},
+    {1,0,0,0,0,0,0,0,1,0,0,0},
+    {0,0,0,0,0,0,0,0,0,0,0,0},
+    {0,0,1,0,0,0,0,1,0,0,1,0},
+    {0,0,0,1,0,0,1,0,0,0,0,1},
+    {0,0,0,0,1,0,0,0,0,1,0,0},
+    {0,0,0,0,0,0,0,0,1,0,1,0},
+    {0,0,0,0,0,0,1,0,0,1,0,1},
+    {0,0,0,0,0,0,0,1,0,0,1,0}
+};
+double reward[size]=
+{
+    -0.02,-0.02,-0.02,1,
+    -0.02,0,-0.02,-1,
+    -0.02,-0.02,-0.02,-0.02
+};
+double sumreward[size];
+double maxreward[size]={0,0,0,0,0,0,0,0,0,0,0,0};
+int count=0;
+int createudn(mgraph &g);
+void dfstraverse(mgraph &g);//深度遍历图
+void dfs(mgraph &g,int i);
+stack<int> s;//该栈定义为全局变量的原因是如果定义在有递归函数的体内部，
+//则每一次都会申请一次栈，每一次操作也不是对同一个栈进行操作
+stack<int>copys;
+int main()
+{
+    mgraph g;
+    createudn(g);
+    int i=0;
+    dfstraverse(g);//深度遍历和广度遍历而选其一，因为公用了全局变量
+    for(i=0; i<size; i++)
+        cout<<maxreward[i]<<"  ";
+        cout<<"count="<<count<<endl;
+    return 0;
+}
+int createudn(mgraph &g)
+{
+    int i,j,k;
+    int x,y,w;
+    int a[size]= {1,2,3,4,5,6,7,8,9,10,11,12}; //顶点名称
+    g.vexnum=size;
+    for(i=0; i<g.vexnum; ++i)//初始化顶点名称
+    {
+        g.vexs[i]=a[i];
+    }
+    cout<<endl;
+    for(i=0; i<g.vexnum; i++)//初始化没有任何弧和弧的信息
+    {
+        for(j=0; j<g.vexnum; j++)
+        {
+            g.arcs[i][j].adj=matrix[i][j];
+            g.arcs[i][j].info=NULL;
+
+        }//初始化顶点间的权值和相关信息
+        //默认初始化权值为-1，信息为NULL
+        g.reward[i]=reward[i];
+    }
+    return ok;
+}
+void dfstraverse(mgraph &g)
+{
+    int i,j;
+    for(i=0; i<g.vexnum; i++)
+    {
+        for(j=0; j<g.vexnum; j++)
+            visited[j]=false;//在以每个状态为初始点做深度遍历之前把所有的状态重新置为未访问的标志
+        while(!s.empty())
+        {
+            s.pop();
+        }//由于在上一次使用栈时，防止未能把栈清空，重新清空一下
+        dfs(g,i);
+        cout<<"*****************************************************"<<endl;
+    }
+}
+void dfs(mgraph &g,int i)
+{
+    int j,flag;
+    int lujin[size];
+    visited[i]=true;//访问过后，把访问标志置为true
+    s.push(g.vexs[i]);
+    copys=s;
+    flag=0;
+    for(j=0; j<g.vexnum; j++)
+    {
+        if(g.arcs[i][j].adj!=0&&!visited[j]&&g.reward[i]!=1&&g.reward[i]!=-1)//由第一次传递来的i选第一个相邻的顶点做深度遍历
+            //遍历一次结束后，再选择另一个相邻的顶点做深度遍历，直到主调函数传递来的顶点无相邻的
+            //顶点再返回主调函数做下一次循环
+        {
+            flag=1;
+            dfs(g,j);
+            count++;//递归返回一次count++
+            visited[s.top()-1]=false;//只是把访问标志重新置为false，并不输出
+            s.pop();
+        }
+    }
+    j=0;
+    if(flag==0)//如果某次递归进入该函数时，未执行上面的for，那么就是表示该节点没有其他可到达的节点了，或者是到达了奖励节点
+    //此时，可以进行路径输出，并且计算栈底起点节点经过该路径的累积回报，统计所有的可能路径，不断的更新最大的累积回报，以及该累积回报下的路径
+    {
+        while(!copys.empty())
+        {
+            lujin[j]=copys.top();
+            copys.pop();
+            j++;
+        }
+        int start=j-1;
+        sumreward[lujin[start]-1]=0;
+        for(j; j>0; j--)
+        {
+            sumreward[lujin[start]-1]+=g.reward[lujin[j-1]-1];
+            cout<<lujin[j-1]<<"  ";
+        }
+        //用sumreward，栈底元素为下的数组标作记录栈底元素的累积回报
+        cout<<sumreward[lujin[start]-1]<<endl<<"-----------------------------------"<<endl;
+        if(maxreward[lujin[start]-1]<sumreward[lujin[start]-1])//更新累积回报
+            {
+                maxreward[lujin[start]-1]=sumreward[lujin[start]-1];
+            }
+    }
+}
+*/
+
+/***
+2 状态为16个情况
+
+*/
+
+/*
+#include <iostream>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stack>
+#define max_vertex_num 20
+#define error -1
+#define ok 1
+#define overflow -2
+#define int_max 9999
+#define size 16
+using namespace std;
+typedef struct arccell
+{
+    int adj;//结点间的关系即权
+    char *info;
+} arccell,adjmatrix[max_vertex_num][max_vertex_num];
+typedef struct mgraph
+{
+    int vexs[max_vertex_num];//各顶点名称
+    adjmatrix arcs;//邻接矩阵
+    int vexnum,arcnum;//图当前的顶点数和弧数
+    double reward[max_vertex_num];//每个状态的回报
+} mgraph;
+bool visited[max_vertex_num];
+int matrix[size][size]=
+{
+    {0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0},
+    {1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0},
+    {0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0},
+    {0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0},
+    {1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0},
+    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
+    {0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0},
+    {0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0},
+    {0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0},
+    {0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0},
+    {0,0,0,0,0,0,1,0,0,1,0,1,0,0,1,0},
+    {0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1},
+
+    {0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0},
+    {0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0},
+    {0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1},
+    {0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0}
+
+};
+double reward[size]=
+{
+    -0.02,-0.02,-0.02,1,
+    -0.02,0,-0.02,-1,
+    -0.02,-0.02,-0.02,-0.02,
+    -0.02,-0.02,-0.02,-0.02
+};
+double sumreward[size];
+double maxreward[size]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+int createudn(mgraph &g);
+void dfstraverse(mgraph &g);//深度遍历图
+void dfs(mgraph &g,int i);
+stack<int> s;//该栈定义为全局变量的原因是如果定义在有递归函数的体内部，
+//则每一次都会申请一次栈，每一次操作也不是对同一个栈进行操作
+stack<int>copys;
+int main()
+{
+    mgraph g;
+    createudn(g);
+    int i=0;
+    dfstraverse(g);//深度遍历和广度遍历而选其一，因为公用了全局变量
+    //bfstraverse(g);
+    for(i=0; i<size; i++)
+        cout<<maxreward[i]<<"  ";
+    //int v0=0;//选择到各点的初始点
+    //shortpath_dij(g,v0);
+    return 0;
+}
+int createudn(mgraph &g)
+{
+    int i,j,k;
+    int x,y,w;
+    int a[size]= {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}; //顶点名称
+    g.vexnum=size;
+    for(i=0; i<g.vexnum; ++i)//初始化顶点名称
+    {
+        g.vexs[i]=a[i];
+        cout<<g.vexs[i]<<"  ";
+    }
+    cout<<endl;
+    for(i=0; i<g.vexnum; i++)//初始化没有任何弧和弧的信息
+    {
+        for(j=0; j<g.vexnum; j++)
+        {
+            g.arcs[i][j].adj=matrix[i][j];
+            g.arcs[i][j].info=NULL;
+
+        }//初始化顶点间的权值和相关信息
+        //默认初始化权值为-1，信息为NULL
+        g.reward[i]=reward[i];
+    }
+    return ok;
+}
+void dfstraverse(mgraph &g)
+{
+    int i,j;
+    for(i=0; i<g.vexnum; i++)
+        visited[i]=false;
+    for(i=0; i<g.vexnum; i++)
+    {
+        for(j=0; j<g.vexnum; j++)
+            visited[j]=false;
+        while(!s.empty())
+        {
+            s.pop();
+        }
+        dfs(g,i);
+        cout<<"***************************************"<<endl;
+    }
+}
+void dfs(mgraph &g,int i)
+{
+    int j,flag;
+    int lujin[size];
+    visited[i]=true;
+    s.push(g.vexs[i]);
+    copys=s;
+    flag=0;
+    for(j=0; j<g.vexnum; j++)
+    {
+        if(g.arcs[i][j].adj!=0&&!visited[j]&&g.reward[i]!=1&&g.reward[i]!=-1)//由第一次传递来的i选第一个相邻的顶点做深度遍历
+            //遍历一次结束后，再选择另一个相邻的顶点做深度遍历，直到主调函数传递来的顶点无相邻的
+            //顶点再返回主调函数做下一次循环
+        {
+            flag=1;
+            dfs(g,j);
+            visited[s.top()-1]=false;
+            s.pop();
+        }
+    }
+    j=0;
+    if(flag==0)
+    {
+
+        while(!copys.empty())
+        {
+            lujin[j]=copys.top();
+            copys.pop();
+            j++;
+        }
+        int start=j-1;
+        sumreward[lujin[start]-1]=0;
+        for(j; j>0; j--)
+        {
+            sumreward[lujin[start]-1]+=g.reward[lujin[j-1]-1];
+            cout<<lujin[j-1]<<"  ";
+        }
+        cout<<sumreward[lujin[start]-1]<<endl<<"-----------------------------------"<<endl;
+        if(maxreward[lujin[start]-1]<sumreward[lujin[start]-1])
+            {
+                maxreward[lujin[start]-1]=sumreward[lujin[start]-1];
+                    //cout<<sumreward[lujin[start]-1]<<"&"<<maxreward[lujin[start]-1]<<endl;
+            }
+    }
+}
+
+*/
+
+/***
+
+3 递归精简版
+
+***/
+/*
+
+#include <iostream>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stack>
+#define max_vertex_num 20
+#define error -1
+#define ok 1
+#define overflow -2
+#define int_max 9999
+#define size 12
+using namespace std;
+typedef struct arccell
+{
+    int adj;//结点间的关系即权
+    char *info;
+} arccell,adjmatrix[max_vertex_num][max_vertex_num];
+typedef struct mgraph
+{
+    int vexs[max_vertex_num];//各顶点名称
+    adjmatrix arcs;//邻接矩阵
+    int vexnum,arcnum;//图当前的顶点数和弧数
+    double reward[max_vertex_num];//每个状态的回报
+} mgraph;
+bool visited[max_vertex_num];
+int matrix[size][size]=
+{
+    {0,1,0,0,1,0,0,0,0,0,0,0},
+    {1,0,1,0,0,0,0,0,0,0,0,0},
+    {0,1,0,1,0,0,1,0,0,0,0,0},
+    {0,0,1,0,0,0,0,1,0,0,0,0},
+    {1,0,0,0,0,0,0,0,1,0,0,0},
+    {0,0,0,0,0,0,0,0,0,0,0,0},
+    {0,0,1,0,0,0,0,1,0,0,1,0},
+    {0,0,0,1,0,0,1,0,0,0,0,1},
+    {0,0,0,0,1,0,0,0,0,1,0,0},
+    {0,0,0,0,0,0,0,0,1,0,1,0},
+    {0,0,0,0,0,0,1,0,0,1,0,1},
+    {0,0,0,0,0,0,0,1,0,0,1,0}
+};
+double reward[size]=
+{
+    -0.02,-0.02,-0.02,1,
+    -0.02,0,-0.02,-1,
+    -0.02,-0.02,-0.02,-0.02
+};
+double sumreward[size];
+double maxreward[size]= {0,0,0,0,0,0,0,0,0,0,0,0};
+int count=0;
+int createudn(mgraph &g);
+void dfstraverse(mgraph &g);//深度遍历图
+void dfs(mgraph &g,int i);
+stack<int> s;//该栈定义为全局变量的原因是如果定义在有递归函数的体内部，
+//则每一次都会申请一次栈，每一次操作也不是对同一个栈进行操作
+stack<int>copys;
+int maiwSum=0;n()
+{
+    mgraph g;
+    createudn(g);
+    int i=0;
+    dfstraverse(g);//深度遍历和广度遍历而选其一，因为公用了全局变量
+    for(i=0; i<size; i++)
+        cout<<maxreward[i]<<"  ";
+    cout<<"count="<<count<<endl;
+    return 0;
+}
+int createudn(mgraph &g)
+{
+    int i,j,k;
+    int x,y,w;
+    int a[size]= {1,2,3,4,5,6,7,8,9,10,11,12}; //顶点名称
+    g.vexnum=size;
+    for(i=0; i<g.vexnum; ++i)//初始化顶点名称
+    {
+        g.vexs[i]=a[i];
+    }
+    for(i=0; i<g.vexnum; i++)//初始化没有任何弧和弧的信息
+    {
+        for(j=0; j<g.vexnum; j++)
+        {
+            g.arcs[i][j].adj=matrix[i][j];
+            g.arcs[i][j].info=NULL;
+
+        }//初始化顶点间的权值和相关信息
+        //默认初始化权值为-1，信息为NULL
+        g.reward[i]=reward[i];
+    }
+    return ok;
+}
+int printf(mgraph &g)
+{
+    int i=0,j=0;
+    for(i=0; i<g.vexnum; i++)
+    {
+        for(j=0; j<g.vexnum; j++)
+            cout<<g.arcs[i][j].adj<<"  ";
+        cout<<endl;
+    }
+    return 0;
+}
+void dfstraverse(mgraph &g)
+{
+    int i,j;
+    for(i=0; i<g.vexnum; i++)
+        visited[i]=false;
+    for(i=0; i<g.vexnum; i++)
+    {
+        if(maxreward[i]>0+0.001)
+            continue;
+        for(j=0; j<g.vexnum; j++)
+            visited[j]=false;
+        while(!s.empty())
+        {
+            s.pop();
+        }
+        dfs(g,i);
+        cout<<endl<<"***************************************"<<endl;
+    }
+}
+void dfs(mgraph &g,int i)
+{
+    int j,k,flag=0;
+    int lujin[size];
+    visited[i]=true;
+    s.push(g.vexs[i]);
+    copys=s;
+    for(j=0; j<g.vexnum; j++)
+    {
+        if(g.arcs[i][j].adj!=0&&!visited[j]&&g.reward[i]!=1&&g.reward[i]!=-1)//由第一次传递来的i选第一个相邻的顶点做深度遍历
+            //遍历一次结束后，再选择另一个相邻的顶点做深度遍历，直到主调函数传递来的顶点无相邻的
+            //顶点再返回主调函数做下一次循环
+        {
+            flag=1;
+            dfs(g,j);
+            count++;
+            visited[s.top()-1]=false;
+            s.pop();
+        }
+    }
+    j=0;
+    if(flag==0)//同上，直到递归到某一个节点走不下去了，那么该路径就到了终点，可以输出该路径的累积回报
+    {
+        while(!copys.empty())
+        {
+            lujin[j]=copys.top();
+            copys.pop();
+            j++;
+        }
+        int start=j-1;
+        int l=0;
+        sumreward[lujin[start]-1]=0;
+        for(i=0; i<size; i++)
+            sumreward[i]=0;
+        for(k=0; k<=start; k++)
+        {
+            for(j=start-k; j>=0; j--)
+            {
+                sumreward[lujin[start-k]-1]+=g.reward[lujin[j]-1];//记录累积回报
+                //cout<<lujin[j]<<"  ";
+            }
+            //cout<<sumreward[lujin[k]-1]<<endl<<"-----------------------------------"<<endl;
+        }
+        if(maxreward[lujin[start]-1]<sumreward[lujin[start]-1])//更新累积回报，并且把这条路径上，以每一个状态为起始状态的累积回报保存下来，若对栈底元素为最优的话
+        //那么该条路径上所有的节点都以这条路径为决策达到最优累积回报
+        {
+            //记录这条路径上所有状态为初始状态走该路径的累积回报
+            for(l=0; l<=start; l++)
+            {
+                maxreward[lujin[start-l]-1]=sumreward[lujin[start-l]-1];
+                //cout<<maxreward[lujin[start-l]-1]<<"   ";
+            }
+        }
+        for(k=0; k<=start; k++)
+        {
+            for(j=start-k; j>=0; j--)
+            {
+                //sumreward[lujin[start-k]-1]+=g.reward[lujin[j]-1];
+                cout<<lujin[j]<<"  ";
+            }
+            cout<<maxreward[lujin[start-k]-1]<<endl;
+        }
+    }
+}
+
+*/
+
+/**
+
+4 非递归动态规划
+
+从最终状态出发，采用广度遍历不断的更新其上一状态的累积回报
+*/
+
+/*
+
+#include <iostream>
+using namespace std;
+#include <stdlib.h>
+#define size 12
+typedef struct subset
+{
+    int data;
+    struct subset* next;
+} subset;
+int main()
+{
+    int matrix[size][size]=
+    {
+        {0,1,0,0,1,0,0,0,0,0,0,0},
+        {1,0,1,0,0,0,0,0,0,0,0,0},
+        {0,1,0,1,0,0,1,0,0,0,0,0},
+        {0,0,0,0,0,0,0,0,0,0,0,0},
+        {1,0,0,0,0,0,0,0,1,0,0,0},
+        {0,0,0,0,0,0,0,0,0,0,0,0},
+        {0,0,1,0,0,0,0,1,0,0,1,0},
+        {0,0,0,0,0,0,0,0,0,0,0,0},
+        {0,0,0,0,1,0,0,0,0,1,0,0},
+        {0,0,0,0,0,0,0,0,1,0,1,0},
+        {0,0,0,0,0,0,1,0,0,1,0,1},
+        {0,0,0,0,0,0,0,1,0,0,1,0}
+    };
+    double reward[size]=
+    {
+        -0.02,-0.02,-0.02,1,
+        -0.02,0,-0.02,-1,
+        -0.02,-0.02,-0.02,-0.02
+    };
+    double maxreward[size]= {0,0,0,0,0,0,0,0,0,0,0,0};
+    int i=0,j=0,count=0;
+    struct subset *maxsubset;
+    maxsubset=(subset *)malloc(sizeof(subset)*1);
+    maxsubset->data=-1;
+    maxsubset->next=NULL;
+    struct subset *p,*q;
+    for(i=0; i<size; i++)//初始化0步立即回报为累积回报
+    {
+        maxreward[i]=reward[i];
+        if(reward[i]==1)
+        {
+            p=(subset *)malloc(sizeof(subset)*1);
+            p->data=i;
+            p->next=NULL;
+            q=maxsubset;
+            while((q->next)!=NULL)
+                q=q->next;
+            q->next=p;
+        }
+    }
+    q=maxsubset->next;
+    while(q!=NULL)//这里图的广度遍历没有用到队列，但也用到了队列的思想
+    //对于当前步能到达的节点用链表连接起来，然后逐渐进行下一步的能到达的节点进行入链（入队列），同样是一种先进先出思想
+    {
+        for(i=0; i<size; i++) //由于不是策略迭代，只能遍历所有的状态，找出能到的，且更优的
+        {
+            if(matrix[i][q->data]==1&&maxreward[i]<0)//double类型比较大小的偏差，加上一个小数作为精度
+            {
+                maxreward[i]=reward[i]+maxreward[q->data];
+                p=(subset *)malloc(sizeof(subset)*1);
+                p->data=i;
+                p->next=NULL;
+                q=maxsubset;
+                while((q->next)!=NULL)
+                    q=q->next;
+                q->next=p;
+            }
+            count++;
+        }
+        maxsubset->next=maxsubset->next->next;//删除当前节点，即当前步下能到达的节点都已经走完了，可出队列了
+        q=maxsubset->next;//
+    }
+    for(i=0; i<size; i++)
+        cout<<maxreward[i]<<"  ";
+    cout<<endl<<"count="<<count<<endl;
+    return 0;
+}
+
+*/
diff --git a/kMeans.cpp b/kMeans.cpp
new file mode 100644
index 0000000..87f3ab1
--- /dev/null
+++ b/kMeans.cpp
@@ -0,0 +1,335 @@
+/**
+
+Kmeans算法致命的就是聚成空类的出现，值得分析一下kmeans什么情况下会出现空类，
+该程序中未对此作处理，后面肯定还是会遇到这个问题的，以后再分析
+**/
+#include <iostream>
+#include <stdlib.h>
+using namespace std;
+#include "matrix.h"
+#define MAX 1000000
+#define MIN -100000
+#define random(x) (rand()%x)
+#define MAXK 10
+
+/**
+Kmeans聚类中心数据结构
+*/
+struct CenAndDis
+{
+    Matrix cen;//聚类中心
+    Matrix dis;//每一个样本到其聚类中心的距离，即为一个m行的列向量
+};
+
+///返回一个样本与某一个聚类中心的距离
+double distances(Matrix xOne,Matrix kCen)
+{
+    int i,j;
+    double dis=0;
+    for(i=0; i<xOne.row; i++)
+    {
+        dis+=pow((xOne.mat[0][i]-kCen.mat[0][i]),2);
+    }
+    return dis;
+}
+
+/**
+随机初始化一个聚类中心，初始化的方式有两种，一种是随机从样本中选一个作为聚类中心，
+一种是在样本空间内初始化一个聚类中心，可以不是具体某个样本，类中心的初始化非常关键
+
+下面采用的是从样本中选择作为聚类中心，从样本中选取聚类中心同样也会出现聚成空类的现象，对此解决办法是
+
+**/
+Matrix randCent(Matrix x,int kNum)
+{
+    int i,j,k;
+    Matrix initmeans;
+    initmeans.initMatrix(&initmeans,kNum,x.row);
+
+    double min[2];
+    double max[2];
+
+    /**
+    在样本空间内随机初始化k个类中心，未写完
+    **/
+    for(j=0; j<x.row; j++)
+    {
+        min[j]=MAX;
+        max[j]=MIN;
+        for(i=0; i<x.col; i++)
+        {
+            if(x.mat[i][j]<min[j])
+            {
+                min[j]=x.mat[i][j];
+            }
+            if(x.mat[i][j]>max[j])
+            {
+                max[j]=x.mat[i][j];
+            }
+        }
+    }
+    /**
+    随机从样本中选择k个样本作为类中心
+    */
+    for(k=0; k<kNum; k++)
+    {
+        for(j=0; j<x.row; j++)
+        {
+            //改变初值的选取，得到的聚类中心会不一致，可见初值的选取的关键，
+            initmeans.mat[k][j]=x.mat[k][j];//min[j]+(max[j]-min[j])*(random(10)/10.0);
+            cout<<initmeans.mat[k][j]<<"  ";
+        }
+        cout<<endl;
+    }
+    return initmeans;
+}
+CenAndDis kMeans(Matrix x,int kNum)
+{
+    int i,j,k,d;
+    double dis[MAXK];///记录一个样本到k个类中心的距离，可以采用矩阵动态申请更好，这里默认最多MAXK个类中心
+
+    Matrix kmeans;//聚类中心
+    kmeans.initMatrix(&kmeans,kNum,x.row);
+
+    kmeans=randCent(x,kNum);//随机初始化k个类中心
+
+    Matrix xOne;//存储一个样本
+    xOne.initMatrix(&xOne,1,x.row);
+
+    Matrix kOne;//存储一个聚类中心样本
+    kOne.initMatrix(&kOne,1,x.row);
+
+    Matrix kLabel;//存储每个样本的类别
+    kLabel.initMatrix(&kLabel,x.col,1);
+
+    double minDis=MAX;//最小的距离
+    int dnum=10;//迭代次数，因为收敛速度很快
+
+    for(d=0; d<dnum; d++)
+    {
+        //根据k个聚类中心划分类标签
+        for(i=0; i<x.col; i++)
+        {
+            xOne=xOne.getOneCol(x,i);
+            minDis=MAX;
+            for(k=0; k<kNum; k++)
+            {
+                kOne=kOne.getOneCol(kmeans,k);
+                dis[k]=distances(xOne,kOne);
+                if(dis[k]<minDis)
+                {
+                    kLabel.mat[i][0]=k;
+                    minDis=dis[k];
+                }
+            }
+        }
+        //kmeans清零，当计算类中心采用+=的形式则需要清零，而下面更新kmeans同样是采用+=的形式，因为右边有一项就是kmeans
+        for(k=0; k<kNum; k++)
+        {
+            for(j=0; j<x.row; j++)
+            {
+                kmeans.mat[k][j]=0;
+            }
+        }
+        //更新kmeans
+        for(i=0; i<x.col; i++)
+        {
+            k=kLabel.mat[i][0];
+            for(j=0; j<x.row; j++)
+            {
+                kmeans.mat[k][j]=(kmeans.mat[k][j]*(i)+x.mat[i][j])/(i+1);//采用累加方式求均值，该方法增加计算量
+                //当然也可以把一类的所有样本取出来，求和再取均值，这里没有这样做，而是来一个加一个
+            }
+        }
+        //输出当前次EM后的聚类中心
+        cout<<"--------------------"<<endl;
+        for(k=0; k<kNum; k++)
+        {
+            for(j=0; j<x.row; j++)
+            {
+                cout<<kmeans.mat[k][j]<<"  ";
+            }
+            cout<<endl;
+        }
+    }
+    /**
+    将聚类结果保存到结构体中
+    */
+    CenAndDis cendis;
+    cendis.cen.initMatrix(&cendis.cen,kNum,x.row);
+    cendis.dis.initMatrix(&cendis.dis,x.col,1);
+    cendis.cen.copy(kmeans,&cendis.cen);
+
+    ///保存所有样本到其类中心的距离到结构体中
+    for(i=0; i<x.col; i++)
+    {
+        k=kLabel.mat[i][0];
+        xOne=xOne.getOneCol(x,i);
+        kOne=kOne.getOneCol(kmeans,k);
+        cendis.dis.mat[i][0]=distances(xOne,kOne);
+    }
+    //
+    double sum=0;
+    for(i=0;i<x.col;i++)
+    {
+        sum+=cendis.dis.mat[i][0];
+    }
+    cout<<"sum="<<sum<<endl;
+    return cendis;
+}
+
+
+Matrix subMatrix(Matrix x,Matrix clusterAssment,int label)
+{
+    int i=0,j=0,k=0;
+    Matrix submatrix;
+    submatrix.initMatrix(&submatrix,x.col,x.row);
+    for(i=0; i<x.col; i++)
+    {
+        if(clusterAssment.mat[i][0]==label)
+        {
+            for(j=0; j<x.row; j++)
+            {
+                submatrix.mat[k][j]=x.mat[i][j];
+            }
+            k++;
+        }
+    }
+    submatrix.col=k;
+    return submatrix;
+}
+/***
+二分聚类的思想是每一次都采用一个典型的二类聚类，而在选择把那个子类进行二分的评价标准是SSE，
+即分裂哪一类使得SSE最小就分裂哪一类，SSE是最小平方和误差，即使得聚类结果的距离最小平方和误差最小
+就对哪一类进行二分，直到不再减少SSE，或者有一类为空类，或者到达预设的聚为K类
+
+**/
+int biKmeans(Matrix x,int kNum)
+{
+    int i,j,k,d;
+    Matrix kmeans;
+    kmeans.initMatrix(&kmeans,1,x.row);///初始化聚为一类，
+
+    Matrix xOne;//一个样本
+    xOne.initMatrix(&xOne,1,x.row);
+
+    Matrix kOne;//一个聚类中心
+    kOne.initMatrix(&kOne,1,x.row);
+
+    Matrix clusterAssment;///矩阵的第一列保存其到所属类别，第二列保存样本到所属类别的距离
+    clusterAssment.initMatrix(&clusterAssment,x.col,2);
+
+    CenAndDis cenanddis;///聚类结果
+    cenanddis.cen.initMatrix(&cenanddis.cen,kNum,x.row);
+    cenanddis.dis.initMatrix(&cenanddis.dis,x.col,1);
+
+    CenAndDis bestCenanddis;///记录当前最好的距离结果
+    bestCenanddis.cen.initMatrix(&bestCenanddis.cen,kNum,x.row);
+    bestCenanddis.dis.initMatrix(&bestCenanddis.dis,x.col,1);
+
+    for(i=0; i<x.col; i++)
+    {
+        for(j=0; j<x.row; j++)
+        {
+            kmeans.mat[0][j]=(kmeans.mat[0][j]*i+x.mat[i][j])/(i+1);
+        }
+        clusterAssment.mat[i][0]=0;///初始化聚为一类，类中心为之前初始化为一类的类中心
+    }
+    for(i=0; i<x.col; i++)
+    {
+        xOne=xOne.getOneCol(x,i);
+        clusterAssment.mat[i][1]=distances(xOne,kmeans);///初始化为一类后，所有样本到其所属类的距离
+    }
+
+    Matrix submatrix;///分裂后的子集矩阵
+    submatrix.initMatrix(&submatrix,x.col,x.row);
+
+    double lowestSSE=MAX;///记录当前聚类结果的SSE值
+    double sseSplit=0;///记录分裂后子集的SSE值
+    double sseNosplit=0;///记录没有分裂的自己的SSE值
+    int bestCentToSplit;///记录预分裂子集的类别
+    double dis[2];///记录分裂后两个子集的SSE值
+
+    for(d=1; d<kNum; d++)
+    {
+        lowestSSE=MAX;//如果这个初始距离设置成当前不分裂下的总距离，那么不能保证一定得到kNum个类中心
+        for(k=0; k<d; k++)
+        {
+            cout<<"k="<<k<<endl;
+            submatrix=subMatrix(x,clusterAssment,k);///用于保存属于k类的子集用于下面kmeans尝试进行划分
+            cout<<submatrix.col<<endl;
+            submatrix.print(submatrix);
+            cenanddis=kMeans(submatrix,2);///尝试用kmeans进行二分
+            sseSplit=0;
+            sseNosplit=0;
+            /**
+            分裂类别的SSE值和
+            */
+            for(i=0;i<submatrix.col;i++)
+            {
+                sseSplit+=cenanddis.dis.mat[i][1];
+            }
+            /**
+            未分裂的类别的SSE值和
+            */
+            for(i=0;i<x.col;i++)
+            {
+                if(clusterAssment.mat[i][0]!=k)
+                {
+                     sseNosplit+=clusterAssment.mat[i][1];
+                }
+            }
+            ///与最小的SSE进行比较，选择出最佳的分裂类
+            if(sseSplit+sseNosplit<lowestSSE)//如果将第k个簇进行而划分更好，则记录下来，并更新lowsetSSE
+            {
+                bestCentToSplit=k;
+                bestCenanddis=cenanddis;
+                lowestSSE=sseSplit+sseNosplit;
+            }
+        }
+        ///最后确定选出最好的二划分簇之后，下面开始在x数据上进行更新聚类中心和距离，clusterAssment变量
+        for(i=0;i<x.col;i++)
+        {
+            if(clusterAssment.mat[i][0]==bestCentToSplit)
+            {
+                xOne=xOne.getOneCol(x,i);
+                for(k=0;k<2;k++)
+                {
+                    kOne=kOne.getOneCol(bestCenanddis.cen,k);
+                    dis[k]=distances(kOne,xOne);
+                }
+                if(dis[0]<dis[1])
+                {
+                    clusterAssment.mat[i][0]=bestCentToSplit;///分裂后的两个类，第一个类的类别还是当前类别值
+                    clusterAssment.mat[i][1]=dis[0];
+                }
+                else
+                {
+                    clusterAssment.mat[i][0]=bestCentToSplit+1;///分裂后的两个类，第二个类的类别分配一个新的类别值，一直往上加1
+                    clusterAssment.mat[i][1]=dis[1];
+                }
+            }
+        }
+        ///计算最终的SSE值
+        double sum=0;
+        for(i=0;i<x.col;i++)
+        {
+            sum+=clusterAssment.mat[i][1];
+            cout<<clusterAssment.mat[i][1]<<"   ";
+        }
+        cout<<"sum="<<sum<<endl;
+    }
+}
+
+int main()
+{
+    dataToMatrix dtm;
+    char file[20]="data\\kmeans.txt";
+    dtm.loadData(&dtm,file);
+    Matrix x;
+    x.loadMatrix(&x,dtm);
+    //x.print(x);
+    //kMeans(x,3);
+    biKmeans(x,3);
+}
+
diff --git a/kNN.cpp b/kNN.cpp
new file mode 100644
index 0000000..9894e05
--- /dev/null
+++ b/kNN.cpp
@@ -0,0 +1,195 @@
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <sstream>
+#include <vector>
+#include <math.h>
+#include "matrix.h"
+using namespace std;
+
+/***数据归一化处理，data[i][j]-min[j]/range[j]**/
+int autoNorm(Matrix x)
+{
+    int j=0,i=0;
+
+    Matrix minVals;
+    minVals.initMatrix(&minVals,1,x.row,MAX);
+
+    Matrix maxVals;
+    maxVals.initMatrix(&maxVals,1,x.row,MIN);
+
+    Matrix ranges;
+    ranges.initMatrix(&ranges,1,x.row);
+
+    for(j=0; j<x.row; j++)
+    {
+        minVals.mat[0][j]=x.mat[0][j];
+        maxVals.mat[0][j]=minVals.mat[0][j];
+    }
+    for(i=0; i<x.col; i++)
+    {
+        for(j=0; j<x.row; j++)
+        {
+            if(x.mat[i][j]<minVals.mat[0][j])
+                minVals.mat[0][j]=x.mat[i][j];
+            if(x.mat[i][j]>maxVals.mat[0][j])
+                maxVals.mat[0][j]=x.mat[i][j];
+        }
+    }
+    for(i=0; i<x.row; i++)
+        ranges.mat[0][i]=maxVals.mat[0][i]-minVals.mat[0][i];
+    for(i=0; i<x.col; i++)
+    {
+        for(j=0; j<x.row; j++)
+        {
+            x.mat[i][j]-=minVals.mat[0][j];
+            x.mat[i][j]/=ranges.mat[0][j];
+            //cout<<x.mat[i][j]<<"  ";
+        }
+        //cout<<endl;
+    }
+    return 0;
+}
+/**计算每个测试样本与训练样本的距离，保存在distance矩阵中**/
+Matrix cdistances(Matrix test,Matrix x)
+{
+    int i,j;
+    Matrix distances;
+    distances.initMatrix(&distances,x.col,1,0);
+    for(i=0; i<x.col; i++)
+    {
+        for(j=0; j<x.row; j++)
+        {
+            distances.mat[i][0]+=pow((x.mat[i][j]-test.mat[0][j]),2);
+        }
+        distances.mat[i][0]=sqrt(distances.mat[i][0]);
+        //cout<<"dis="<<distances.mat[i][0]<<endl;
+    }
+    return distances;
+}
+/***选择出K个近邻**/
+Matrix getK(Matrix oneTest,Matrix x,int K)
+{
+    int i,j,k;
+    //为每一个测试样本初始化k个近邻为前k个训练样本，并记录近邻的id
+    Matrix distances;
+    distances.initMatrix(&distances,x.col,1);
+    distances=cdistances(oneTest,x);
+
+    Matrix Kdistances;
+    Kdistances.initMatrix(&Kdistances,K,2);
+    double Max=-1;
+    int Maxi=-1;
+    for(i=0; i<K; i++)
+    {
+        Kdistances.mat[i][0]=distances.mat[i][0];
+        Kdistances.mat[i][1]=i;//记录近邻的id
+        if(Kdistances.mat[i][0]>Max)
+        {
+            Max=Kdistances.mat[i][0];
+            Maxi=i;//选出当前k个近邻中最大的一个
+        }
+    }
+    //为每一个测试样本从第K个训练样本中遍历更新新的k个近邻
+    for(i=K; i<x.col; i++)
+    {
+        if(distances.mat[i][0]<Max)
+        {
+            Kdistances.mat[Maxi][0]=distances.mat[i][0];
+            Max=distances.mat[i][0];//暂时更新当前替换的距离为最大距离，因为已经不能用之前的最大距离了
+            Kdistances.mat[Maxi][1]=i;//记录近邻的id
+            for(k=0; k<K; k++)
+            {
+                if(Kdistances.mat[k][0]>Max)
+                {
+                    Max=Kdistances.mat[k][0];
+                    Maxi=k;//选出当前k个近邻中最大的一个
+                }
+            }
+        }
+    }
+    return Kdistances;
+}
+//KNN决规则，这里采用平局权重投票，且不考虑样本不均衡问题
+/**
+1，knn分类决策函数，首先对训练数据和测试数据进行归一化，
+2，计算每一个测试样本到m个训练样本的距离
+3，从m个距离中选出最小的k个距离，并记录这k个最小距离的样本
+4，由k个样本加权投票得到最终的决策类别
+
+***/
+int classfiy(Matrix testData,Matrix testDatay,Matrix x,Matrix y,int K)
+{
+    int i,j,k;
+    int sumz=0,sumf=0;
+    Matrix knn;
+    knn.initMatrix(&knn,K,2);
+
+    autoNorm(x);
+    autoNorm(testData);
+    for(i=0; i<testData.col; i++)
+    {
+        sumz=0;
+        sumf=0;
+
+        Matrix oneTest;
+        oneTest.initMatrix(&oneTest,1,x.row);
+        oneTest=oneTest.getOneCol(testData,i);
+
+        knn=getK(oneTest,x,10);
+
+        for(j=0; j<K; j++)
+        {
+
+            if(y.mat[int(knn.mat[j][1])][0]==1)
+                sumz++;
+            else
+                sumf++;
+            cout<<y.mat[int(knn.mat[j][1])][0]<<"  ";
+        }
+        if(sumz>sumf)
+            cout<<"juece="<<"1"<<"&"<<"shiji="<<testDatay.mat[i][0]<<endl;
+        else
+            cout<<"juece="<<"-1"<<"&"<<"shiji="<<testDatay.mat[i][0]<<endl;
+    }
+    return 0;
+}
+int main()
+{
+    dataToMatrix dtm;
+    cout<<"loadData"<<endl;
+    cout<<"----------------------"<<endl;
+    char file[20]="data\\knn.txt";
+    dtm.loadData(&dtm,file);
+    //dtm.print(dtm);
+
+    Matrix x;
+    x.loadMatrix(&x,dtm);
+
+    Matrix y;
+    y.initMatrix(&y,x.col,1);
+    y=y.getOneRow(x,x.row);
+
+    x.deleteOneRow(&x,x.row);
+
+
+    dataToMatrix dtmTest;
+    cout<<"loadData"<<endl;
+    cout<<"----------------------"<<endl;
+    char testFile[20]="data\\knnTest.txt";
+    dtmTest.loadData(&dtmTest,testFile);
+    //dtmTest.print(dtmTest);
+
+    Matrix testData;
+    testData.loadMatrix(&testData,dtmTest);
+
+    Matrix testDatay;
+    testDatay.initMatrix(&testDatay,x.col,1);
+    testDatay=testDatay.getOneRow(testData,testData.row);
+
+    testData.deleteOneRow(&testData,testData.row);
+
+
+    classfiy(testData,testDatay,x,y,10);
+    return 0;
+}
diff --git a/loadData.h b/loadData.h
new file mode 100644
index 0000000..f995da4
--- /dev/null
+++ b/loadData.h
@@ -0,0 +1,118 @@
+#include <iostream>
+#include <stdlib.h>
+#include <string>
+#include <math.h>
+#include <fstream>
+#include <sstream>
+#include <stack>
+#include <string>
+using namespace std;
+#define MAX_SIZE_OF_TRAINING_SET 1000
+#define ATTR_NUM 1000
+
+
+struct Data
+{
+    //可以用共用体类型
+    int id;
+    double attr_double[ATTR_NUM];//用于数值型属性
+    string attr_string[ATTR_NUM];//用于数值型属性
+    double weight;
+    Data *next;
+};
+class dataToMatrix
+{
+public:
+    Data *dataSet;
+    int col;
+    int row;
+public:
+
+    /**
+    加载数值型样本数据
+    */
+    int loadData(dataToMatrix *dtm,char *file)
+    {
+        int i=0,j=0;
+        ifstream infile;
+        string tmpstrline;
+        Data *p;
+        dtm->dataSet=new Data;
+        dtm->dataSet->next=NULL;
+        p=dtm->dataSet;
+        Data *datatmp;
+        dtm->col=0;
+        cout<<file<<endl;
+        infile.open(file,ios::in);
+        while(!infile.eof()&&i<MAX_SIZE_OF_TRAINING_SET)
+        {
+            getline(infile,tmpstrline,'\n');//读取文件中一行的数据，保存为string类型
+            stringstream input(tmpstrline);
+            if(tmpstrline!="\0")////由于读取文件结束符同样会继续该操作
+            {
+                datatmp=new Data;
+                datatmp->id=i;
+                datatmp->next=NULL;
+                j=0;
+                while(input>>datatmp->attr_double[j])j++;
+                p->next=datatmp;
+                p=p->next;
+                dtm->col++;
+            }
+        }
+        dtm->row=j;
+        infile.close();
+        return 0;
+    }
+    /**
+    加载字符型样本数据
+    */
+    int loadData(dataToMatrix *dtm,char *file,int type)
+    {
+        int i=0,j=0;
+        ifstream infile;
+        string tmpstrline;
+        Data *p;
+        dtm->dataSet=new Data;
+        dtm->dataSet->next=NULL;
+        p=dtm->dataSet;
+        Data *datatmp;
+        dtm->col=1;
+        cout<<file<<endl;
+        infile.open(file,ios::in);
+        datatmp=new Data;
+        datatmp->next=NULL;
+        while(!infile.eof()&&i<MAX_SIZE_OF_TRAINING_SET)
+        {
+            getline(infile,tmpstrline,'\n');//读取文件中一行的数据，保存为string类型
+            stringstream input(tmpstrline);
+            if(tmpstrline!="\0")////由于读取文件结束符同样会继续该操作
+            {
+                while(input>>datatmp->attr_string[j]){j++;};
+            }
+        }
+        p->next=datatmp;
+        dtm->row=j;
+        infile.close();
+        return 0;
+    }
+    int print(dataToMatrix dtm)
+    {
+        //检测数据加载是否正确
+        int i,j;
+        Data *p=dtm.dataSet->next;
+        for(i=0; i<dtm.col&&p!=NULL; i++)
+        {
+            for(j=0; j<dtm.row; j++)
+            {
+                if(p->attr_string[j]!="")
+                    cout<<p->attr_string[j]<<"  ";
+                else
+                    cout<<p->attr_double[j]<<"  ";
+            }
+            p=p->next;
+            cout<<endl;
+        }
+        return i;
+    }
+};
diff --git a/logRegres.cpp b/logRegres.cpp
new file mode 100644
index 0000000..0e849e2
--- /dev/null
+++ b/logRegres.cpp
@@ -0,0 +1,159 @@
+#include <iostream>
+#include <stdlib.h>
+#include <string>
+#include <math.h>
+#include "matrix.h"
+#include <fstream>
+#include <sstream>
+#include <stack>
+using namespace std;
+#define MAX 1000000
+#define MIN -100000
+
+/**
+sigmad函数,这里没有直接将预测类别转换为整型，而是还是返回一个double值
+*/
+double sigmoid(double z)
+{
+    return 1.0/(1+exp(-z));
+}
+/**
+梯度下降算法，主要是确定负梯度方向，步长，采用迭代的思想迭代n至收敛，
+当目标函数是凸规划问题，那么局部最小值就是全局最小值
+
+**/
+int gradAscent(Matrix x,Matrix y)
+{
+    Matrix weights;
+    weights.initMatrix(&weights,x.row,1,1);///初始化优化参数向量为1
+
+    Matrix xT;
+    xT.initMatrix(&xT,x.row,x.col);
+    xT.transposematrix(x,&xT);
+
+    Matrix z;
+    z.initMatrix(&z,x.col,1);
+
+    Matrix w1;
+    w1.initMatrix(&w1,x.row,y.row);
+
+    double alpha=0.001;///迭代步长
+    double error;///记录错误率
+    int k,c=0;
+    int i,j;
+    for(c=0; c<1000; c++)
+    {
+        z.multsmatrix(&z,x,weights);
+        for(i=0; i<x.col; i++)
+            z.mat[i][0]=sigmoid(z.mat[i][0]);///预测类别
+        z.submatrix(&z,y,z);///计算负梯度方向，同时可以作为预测类别与真实类别的误差
+        error=0;
+        for(k=0; k<x.col; k++)///统计错误率
+            error+=z.mat[k][0];
+        cout<<"error="<<error<<endl;
+        if(error<2&&error>-2)///设置错误率小于一定值时退出迭代
+            break;
+        w1.multsmatrix(&w1,xT,z);///计算负梯度方向
+        for(j=0; j<x.row; j++)
+            w1.mat[j][0]*=alpha;///负梯度方向与步长的乘积确定迭代值
+        weights.addmatrix(&weights,weights,w1);///往负梯度方向走一个步长
+
+    }
+    /**
+    验证算法的正确性
+    **/
+    Matrix test;
+    test.initMatrix(&test,y.col,y.row);
+    test.multsmatrix(&test,x,weights);
+    cout<<"test"<<endl;
+    for(i=0; i<y.col; i++)
+    {
+        if(test.mat[i][0]>0)
+            cout<<1-y.mat[i][0]<<endl;
+        else
+            cout<<0-y.mat[i][0]<<endl;
+    }
+}
+/**
+随机梯度下降与梯度下降法不同的是在负梯度方向的确定，梯度下降是根据所有的样本来确定负梯度方向，
+而随机梯度下降每次只看一个样本点来确定负梯度方向，虽然不完全可信，但随着迭代次数增加，同样收敛
+
+**/
+int stoGradAscent(Matrix x,Matrix y)//随机梯度下降每一次选择m个样本进行求梯度下降方向，该代码中只选择一个样本进行求解梯度下降方向与数值
+{
+    int i,j,c=0;
+    Matrix weights;
+    weights.initMatrix(&weights,x.row,1,1);
+
+    Matrix z;
+    z.initMatrix(&z,1,1);
+
+    Matrix xOne;
+    xOne.initMatrix(&xOne,1,x.row);
+
+    Matrix xOneT;
+    xOneT.initMatrix(&xOneT,xOne.row,xOne.col);
+
+    Matrix w1;
+    w1.initMatrix(&w1,x.row,y.row);
+
+    double alpha=0.01;///步长
+    double error;
+    for(c=0; c<500; c++)
+    {
+        for(i=0; i<x.col; i++)
+        {
+            xOne=xOne.getOneCol(x,i);///随机选择一个样本点，这里没有作随机选择，而是按序选择
+            z.multsmatrix(&z,xOne,weights);
+            z.mat[0][0]=sigmoid(z.mat[0][0]);
+            z.mat[0][0]=y.mat[i][0]-z.mat[0][0];
+            xOneT.transposematrix(xOne,&xOneT);
+            w1.multsmatrix(&w1,xOneT,z);///根据一样样本的预测误差来确定负梯度方向
+            for(j=0; j<w1.row; j++)
+                w1.mat[j][0]*=alpha;
+            weights.addmatrix(&weights,weights,w1);///迭代
+        }
+        cout<<"weights"<<endl;
+        weights.print(weights);
+    }
+    /**
+    验证算法的正确性
+    */
+    Matrix test;
+        test.initMatrix(&test,y.col,y.row);
+        test.multsmatrix(&test,x,weights);
+        for(i=0; i<y.col; i++)
+        {
+            if(test.mat[i][0]>0)
+                cout<<1-y.mat[i][0]<<endl;
+            else
+                cout<<0-y.mat[i][0]<<endl;
+        }
+}
+
+/**
+逻辑回归，这里主要考虑其常用的两种求参数算法，一种是梯度下降，一种是随机梯度下降
+
+*/
+
+int main()
+{
+    dataToMatrix dtm;
+    cout<<"loadData"<<endl;
+    cout<<"----------------------"<<endl;
+    char file[20]="data\\logReg.txt";
+    dtm.loadData(&dtm,file);
+
+    Matrix x;
+    x.loadMatrix(&x,dtm);
+
+    Matrix y;
+    y.initMatrix(&y,x.col,1);
+    y=y.getOneRow(x,x.row);
+
+    x.deleteOneRow(&x,x.row);
+
+    //gradAscent(x,y);
+    stoGradAscent(x,y);
+    return 0;
+}
diff --git a/matrix.h b/matrix.h
new file mode 100644
index 0000000..ce0f713
--- /dev/null
+++ b/matrix.h
@@ -0,0 +1,467 @@
+#include <iostream>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include "loadData.h"
+#include <fstream>
+#include <sstream>
+#include <stack>
+#define MAX 1000000
+#define MIN -100000
+#define MAX_MATRIX_COL 1000
+#define MAX_MATRIX_ROW 100
+using namespace std;
+class Matrix
+{
+public:
+    double **mat;
+    int col,row;
+public:
+    int loadMatrix(Matrix *matrix,dataToMatrix dtm)
+    {
+        int i,j;
+        Data *p;
+        p=dtm.dataSet->next;
+        matrix->mat=(double **)malloc(sizeof(double*)*dtm.col);
+        if(!matrix->mat)
+        {
+            cout<<"loadMatrix fail"<<endl;
+            exit(-1);
+        }
+        for(i=0; i<dtm.col&&p!=NULL; i++)
+        {
+            matrix->mat[i]=(double *)malloc(sizeof(double)*dtm.row);
+            if(!matrix->mat[i])
+            {
+                cout<<"loadmatrix fail"<<endl;
+                exit(-1);
+            }
+            for(j=0; j<dtm.row; j++)
+            {
+                matrix->mat[i][j]=p->attr_double[j];
+            }
+            p=p->next;
+        }
+        matrix->row=dtm.row;
+        matrix->col=dtm.col;
+        return 0;
+    }
+
+    /**
+    new和malloc的本质区别在于，前者是针对对象而言，无论是基本类型还是类类型，结构体类型都可以看作对象，
+    使用new是会调用对象的构造函数，初始化对象，即首先得分配内存，后初始化，分配内存这事内部实现可能是调用malloc
+    而malloc只是分配内存，对于基本类型而言，这是没问题的，后期可以继续初始化，而对于对象而言，malloc只分配内存
+    不调用构造函数，所以不会对对象进行初始化
+    **/
+
+    int initMatrix(Matrix *matrix,int col,int row)
+    {
+        initMatrix(matrix,col,row,0);
+    }
+    int initMatrix(Matrix *matrix,int col,int row,double lam)
+    {
+        if(col==0||row==0)
+        {
+            cout<<"matrix row or col no can 0"<<endl;
+            exit(-1);
+        }
+        matrix->col=col;
+        matrix->row=row;
+        matrix->mat=(double **)malloc(sizeof(double*)*col);
+        if(!matrix->mat)
+        {
+            cout<<"initMatrix fail"<<endl;
+            exit(-1);
+        }
+        int i=0,j=0;
+        for(i=0; i<col; i++)
+        {
+            matrix->mat[i]=(double *)malloc(sizeof(double)*row);
+            if(!matrix->mat[i])
+            {
+                cout<<"initMatrix fail"<<endl;
+                exit(-1);
+            }
+            for(j=0; j<row; j++)
+            {
+                matrix->mat[i][j]=0;
+                if(i==j)
+                matrix->mat[i][j]=lam;
+            }
+        }
+        return 0;
+    }
+    int print(Matrix matrix)
+    {
+        int i,j;
+        for(i=0; i<matrix.col; i++)
+        {
+            for(j=0; j<matrix.row; j++)
+            {
+                cout<<matrix.mat[i][j]<<"  ";;
+            }
+            cout<<endl;
+        }
+    }
+    int copy(Matrix matrixA,Matrix *matrixB)
+    {
+        if(!matrixB)//还应该考虑a
+        {
+            cout<<"matrixB is null"<<endl;
+            exit(-1);
+        }
+        if(matrixB->col!=matrixA.col||matrixB->row!=matrixA.row)
+        {
+            cout<<"matrixA matrixB is no "<<endl;
+            exit(-1);
+        }
+        int i,j;
+        for(i=0; i<matrixA.col; i++)
+        {
+            for(j=0; j<matrixA.row; j++)
+            {
+                matrixB->mat[i][j]=matrixA.mat[i][j];
+            }
+        }
+        return 0;
+    }
+    Matrix getOneRow(Matrix matrix,int iRow)
+    {
+        Matrix oneRow;
+        oneRow.col=matrix.col;
+        oneRow.row=1;
+        initMatrix(&oneRow,oneRow.col,oneRow.row);
+        int i=0;
+        for(i=0; i<oneRow.col; i++)
+        {
+            oneRow.mat[i][0]=matrix.mat[i][iRow-1];
+        }
+        return oneRow;
+    }
+    Matrix getOneCol(Matrix matrix,int iCol)
+    {
+        Matrix oneCol;
+        oneCol.row=matrix.row;
+        oneCol.col=1;
+        initMatrix(&oneCol,oneCol.col,oneCol.row);
+        int i=0;
+        for(i=0; i<oneCol.row; i++)
+        {
+            oneCol.mat[0][i]=matrix.mat[iCol][i];
+        }
+        return oneCol;
+    }
+    int deleteOneRow(Matrix *matrix,int iRow)
+    {
+        if(matrix->row==1)
+        {
+            cout<<"matrix is vec"<<endl;
+            exit(-1);
+        }
+        int i,j;
+        for(i=iRow; i<matrix->row; i++)
+        {
+            for(j=0;j<matrix->col;j++)
+            {
+                matrix->mat[j][i]=matrix->mat[j][i+1];
+            }
+        }
+        matrix->row--;
+        return 0;
+    }
+    void transposematrix(Matrix matrix,Matrix *matrixT)//矩阵形式的转置
+    {
+        if(matrixT->col!=matrix.row||matrixT->row!=matrix.col)
+        {
+            cout<<"matrix matrixT is no "<<endl;
+            exit(-1);
+        }
+        int i=0,j=0;
+        for(i=0; i<matrixT->col; i++)
+        {
+            for(j=0; j<matrixT->row; j++)
+            {
+                matrixT->mat[i][j]=matrix.mat[j][i];
+            }
+        }
+    }
+    int addmatrix(Matrix *addMatrix,Matrix matrix1,Matrix matrix2)
+    {
+        if(matrix1.col!=matrix2.col||matrix1.row!=matrix2.row||addMatrix->col!=matrix1.col||addMatrix->row!=matrix1.row)
+        {
+            cout<<"addMatrix matrix1 matrix2 is no"<<endl;
+            exit(-1);
+        }
+        int i,j;
+        for(i=0; i<matrix1.col; i++)
+        {
+            for(j=0; j<matrix1.row; j++)
+            {
+                addMatrix->mat[i][j]=matrix1.mat[i][j]+matrix2.mat[i][j];
+            }
+        }
+        return 0;
+    }
+
+    int submatrix(Matrix *subMatrix,Matrix matrix1,Matrix matrix2)
+    {
+        if(matrix1.col!=matrix2.col||matrix1.row!=matrix2.row||subMatrix->col!=matrix1.col||subMatrix->row!=matrix1.row)
+        {
+            cout<<"subMatrix matrix1 matrix2 is no"<<endl;
+            exit(-1);
+        }
+        int i,j;
+        subMatrix->col=matrix1.col;
+        subMatrix->row=matrix1.row;
+        for(i=0; i<matrix1.col; i++)
+        {
+            for(j=0; j<matrix1.row; j++)
+            {
+                subMatrix->mat[i][j]=matrix1.mat[i][j]-matrix2.mat[i][j];
+            }
+        }
+        return 0;
+    }
+
+    int multsmatrix(Matrix *multsMatrix,Matrix matrix1,Matrix matrix2)//矩阵形式的相乘
+    {
+        if(matrix1.row!=matrix2.col||multsMatrix->col!=matrix1.col||multsMatrix->row!=matrix2.row)
+        {
+            cout<<"multsmatrix error"<<endl;
+            exit(-1);
+        }
+        int i,j,k,l;
+        for(i=0; i<matrix1.col; i++)
+        {
+            for(j=0; j<matrix2.row; j++)
+            {
+                multsMatrix->mat[i][j]=0;
+            }
+        }
+        for(i=0; i<matrix1.col; i++)
+        {
+            for(j=0; j<matrix2.row; j++)
+            {
+                for(k=0; k<matrix1.row; k++)
+                {
+                    multsMatrix->mat[i][j]+=matrix1.mat[i][k]*matrix2.mat[k][j];
+                }
+            }
+        }
+        return 0;
+    }
+    //行列式
+    double detmatrix(Matrix matrix)
+    {
+        if(matrix.col!=matrix.row)
+        {
+            cout<<"matrix det is no"<<endl;
+            exit(-1);
+        }
+        Matrix matrixCopy;
+        matrixCopy.initMatrix(&matrixCopy,matrix.col,matrix.row);
+        matrixCopy.copy(matrix,&matrixCopy);
+        double det=1;
+        int i=0,j,k;
+        double max=MIN;
+        int swap=-1;
+        double temp;
+        double aij[MAX_MATRIX_COL][MAX_MATRIX_ROW];//这里用矩阵就更好了
+        for(k=0; k<matrixCopy.row-1; k++)//k表示第k次消元，一共需要n-1次
+        {
+            for(i=0; i<matrixCopy.col; i++)
+            {
+                if(matrixCopy.mat[i][k]>max)//每一次消元都是比较第k列的元素，选出第k列中最大的一行
+                {
+                    swap=i;
+                }
+            }//找到第k次列主元消去的最大行的下标
+            if(swap==-1||matrixCopy.mat[swap][k]==0)
+                return -1;//最大主元为0
+            for(j=0; j<matrixCopy.row; j++)
+            {
+                temp=matrixCopy.mat[k][j];
+                matrixCopy.mat[k][j]=matrixCopy.mat[swap][j];
+                matrixCopy.mat[swap][j]=temp;
+            }//第k次消元，选出最大的一行是swap行，与第k行交换
+            for(i=k+1; i<matrixCopy.col; i++)
+            {
+                aij[i][k]=matrixCopy.mat[i][k]/matrixCopy.mat[k][k];// 第k次消元，主元素为第k行第k列，把第k行以下的行都进行消元
+                for(j=k; j<matrixCopy.row; j++)//对于k行以下的每一行的每一列元素都减去主行与消元因子的乘积
+                {
+                    matrixCopy.mat[i][j]-=aij[i][k]*matrixCopy.mat[k][j];
+                }
+            }
+        }
+        for(i=0; i<matrixCopy.col; i++)
+        {
+            det*=matrixCopy.mat[i][i];
+        }
+        cout<<"det="<<det<<endl;
+        return det;
+    }
+    //高斯消元矩阵求逆,特别注意，LU分解不能进行行列式变换
+    int nimatrix(Matrix *niMatrix,Matrix matrix)
+    {
+        if(matrix.col!=matrix.row)
+        {
+            cout<<"matrix ni is no "<<endl;
+            exit(-1);
+        }
+        if(detmatrix(matrix)==0)//这里调用求行列式进行了列主元消去改变了参数矩阵，如何传递不改变是一个问题
+        {
+            cout<<"matrix det is no so ni is no "<<endl;
+            exit(-1);
+        }
+        int i=0,j,k;
+        double temp;
+        Matrix cpMatrix;
+        Matrix uMatrix;
+        Matrix lMatrix;
+        Matrix uniMatrix;
+        Matrix lniMatrix;
+        initMatrix(&uniMatrix,matrix.col,matrix.row);
+        initMatrix(&lniMatrix,matrix.col,matrix.row);
+        initMatrix(&cpMatrix,matrix.col,matrix.row);
+        initMatrix(&uMatrix,matrix.col,matrix.row);
+        initMatrix(&lMatrix,uMatrix.col,uMatrix.row);
+        copy(matrix,&cpMatrix);
+        double aij[MAX_MATRIX_COL][MAX_MATRIX_ROW];
+        for(k=0; k<matrix.row-1; k++)//k表示第k次消元，一共需要n-1次
+        {
+            for(i=k+1; i<matrix.col; i++)
+            {
+                aij[i][k]=matrix.mat[i][k]/matrix.mat[k][k];// 第k次消元，主元素为第k行第k列，把第k行以下的行都进行消元
+                for(j=k; j<matrix.row; j++)//对于k行以下的每一行的每一列元素都减去主行与消元因子的乘积
+                {
+                    matrix.mat[i][j]-=aij[i][k]*matrix.mat[k][j];
+                }
+            }
+        }
+        copy(matrix,&uMatrix);
+        cout<<"uMatrix"<<endl;
+        print(uMatrix);
+        for(j=0; j<matrix.row; j++)
+        {
+            for(i=j+1; i<matrix.col; i++)
+            {
+                temp=0;
+                for(k=0; k<j; k++)
+                {
+                    temp=lMatrix.mat[i][k]*uMatrix.mat[k][j];
+                }
+                lMatrix.mat[i][j]=1/uMatrix.mat[j][j]*(cpMatrix.mat[i][j]-temp);
+            }
+        }
+        for(i=0; i<lMatrix.col; i++)
+        {
+            for(j=0; j<lMatrix.row; j++)
+            {
+                if(i==j)
+                    lMatrix.mat[i][j]=1;
+                if(j>i)
+                    lMatrix.mat[i][j]=0;
+            }
+        }
+        cout<<"lMatrix"<<endl;
+        print(lMatrix);
+        Matrix multsMatrix;
+        multsMatrix.initMatrix(&multsMatrix,lMatrix.col,uMatrix.row);
+        matrix.multsmatrix(&multsMatrix,lMatrix,uMatrix);
+        cout<<"lu"<<endl;
+        print(multsMatrix);
+        //计算u逆
+        for(j=0; j<uMatrix.row; j++)
+        {
+            for(i=j; i>=0; i--)
+            {
+                if(i==j)
+                    uniMatrix.mat[i][j]=1/uMatrix.mat[i][j];
+                else
+                {
+                    temp=0;
+                    for(k=j; k>i; k--)
+                    {
+                        temp+=uMatrix.mat[i][k]*uniMatrix.mat[k][j];
+                    }
+                    uniMatrix.mat[i][j]=-1/uMatrix.mat[i][i]*temp;
+                }
+            }
+        }
+        cout<<"uniMatrix"<<endl;
+        print(uniMatrix);
+        //计算l逆
+        for(j=0; j<lMatrix.row; j++)
+        {
+            for(i=0; i<lMatrix.col; i++)
+            {
+                if(j==i)
+                    lniMatrix.mat[i][j]=1;
+                else
+                {
+                    temp=0;
+                    for(k=j; k<i; k++)
+                    {
+                        temp+=(lMatrix.mat[i][k]*lniMatrix.mat[k][j]);
+                    }
+                    lniMatrix.mat[i][j]=-temp;
+                }
+            }
+        }
+        cout<<"lniMatrix"<<endl;
+        print(lniMatrix);
+        multsmatrix(&multsMatrix,uniMatrix,lniMatrix);
+        cout<<"luni"<<endl;
+        print(multsMatrix);
+        copy(multsMatrix,niMatrix);
+        multsmatrix(&multsMatrix,cpMatrix,*niMatrix);
+        cout<<"luluni"<<endl;
+        print(multsMatrix);
+        copy(cpMatrix,&matrix);
+    }
+    int LDL(Matrix x)//矩阵的LDL分解，不知道怎样用于矩阵特征值，特征向量求解
+    {
+        Matrix l;
+        l.initMatrix(&l,x.col,x.row);
+        Matrix d;
+        d.initMatrix(&d,x.col,x.row);
+        int i,j,k;
+        Matrix temp;
+        temp.initMatrix(&temp,x.col,x.row);
+        for(i=0;i<x.col;i++)
+        {
+            l.mat[i][i]=1;
+            for(j=0;j<i;j++)
+            {
+                for(k=0;k<j;k++)
+                {
+                    temp.mat[i][k]=l.mat[i][k]*d.mat[k][k];
+                    temp.mat[i][j]-=temp.mat[i][k]*l.mat[j][k];
+                }
+                temp.mat[i][j]=temp.mat[i][j]+x.mat[i][j];
+                l.mat[i][j]=temp.mat[i][j]/d.mat[j][j];
+            }
+            d.mat[i][i]=x.mat[i][i];
+            for(k=0;k<i;k++)
+            {
+                d.mat[i][i]-=temp.mat[i][k]*l.mat[i][k];
+            }
+        }
+        for(i=0;i<x.col;i++)
+        {
+            for(j=0;j<x.row;j++)
+            {
+                cout<<l.mat[i][j]<<"  ";
+            }
+            cout<<endl;
+        }
+        for(i=0;i<x.col;i++)
+        {
+            for(j=0;j<x.row;j++)
+            {
+                cout<<d.mat[i][j]<<"  ";
+            }
+            cout<<endl;
+        }
+    }
+};
diff --git a/regression.cpp b/regression.cpp
new file mode 100644
index 0000000..cb803cf
--- /dev/null
+++ b/regression.cpp
@@ -0,0 +1,222 @@
+#include <iostream>
+#include <stdlib.h>
+#include <string>
+#include <math.h>
+#include "matrix.h"
+#include <fstream>
+#include <sstream>
+#include <stack>
+using namespace std;
+#define MAX 1000000
+#define MIN -100000
+
+
+/**
+
+线性回归函数的实现，考虑一般的线性回归，最小平方和作为损失函数，则目标函数是一个无约束的凸二次规划问题，
+由凸二次规划问题的极小值在导数为0处取到，且极小值为全局最小值，且有闭式解。根据数学表达式实现矩阵之间的运算求得参数w。
+**/
+int regression(Matrix x,Matrix y)
+{
+    int i=0;
+    Matrix xT;
+    xT.initMatrix(&xT,x.row,x.col);
+    x.transposematrix(x,&xT);
+    //xT.print(xT);
+
+    Matrix xTx;
+    xTx.initMatrix(&xTx,xT.col,x.row);
+    xTx.multsmatrix(&xTx,xT,x);///x的转置乘上x
+    //xTx.print(xTx);
+
+    Matrix xTx_1;
+    xTx_1.initMatrix(&xTx_1,xTx.row,xTx.col);
+    xTx_1.nimatrix(&xTx_1,xTx);///x的转置乘上x之后求逆
+    //xTx_1.print(xTx_1);
+
+    Matrix xTx_1xT;
+    xTx_1xT.initMatrix(&xTx_1xT,xTx_1.col,xT.row);
+    xTx_1xT.multsmatrix(&xTx_1xT,xTx_1,xT);///逆再乘上x的转置
+    //xTx_1.print(xTx_1xT);
+
+    Matrix ws;
+    ws.initMatrix(&ws,xTx_1xT.col,y.row);
+    ws.multsmatrix(&ws,xTx_1xT,y);///再乘上y就是权重权重向量，而且是一个列向量
+
+    cout<<"ws"<<endl;
+    ws.print(ws);
+    return 0;
+}
+/**
+局部加权线性回归是在线性回归的基础上对每一个测试样本（训练的时候就是每一个训练样本）在其已有的样本进行一个加权拟合，
+权重的确定可以通过一个核来计算，常用的有高斯核（离测试样本越近，权重越大，反之越小），这样对每一个测试样本就得到了不一样的
+权重向量，所以最后得出的拟合曲线不再是线性的了，这样就增加的模型的复杂度来更好的拟合非线性数据。
+
+**/
+//需要注意的是局部加权线性回归是对每一个样本进行权重计算，所以对于每一个样本都有一个权重w，所以下面的函数只是局部线性回归的一个主要辅助函数
+Matrix locWeightLineReg(Matrix test,Matrix x,Matrix y,double k)
+{
+    Matrix w;
+    w.initMatrix(&w,x.col,x.col);
+    double temp=0;
+    int i,j;
+
+    /**
+    根据测试样本点与整个样本的距离已经选择的核确定局部加权矩阵，采用对角线上为局部加权值
+    **/
+    for(i=0;i<x.col;i++)
+    {
+        temp=0;
+        for(j=0;j<x.row;j++)
+        {
+            temp+=(test.mat[0][j]-x.mat[i][j])*(test.mat[0][j]-x.mat[i][j]);
+        }
+        w.mat[i][i]=exp(temp/-2.0*k*k);
+    }
+
+    Matrix xT;
+    xT.initMatrix(&xT,x.row,x.col);
+    xT.transposematrix(x,&xT);
+
+    Matrix wx;
+    wx.initMatrix(&wx,w.col,x.row);
+    wx.multsmatrix(&wx,w,x);
+
+    Matrix xTwx;
+    xTwx.initMatrix(&xTwx,xT.col,x.row);
+    xTwx.multsmatrix(&xTwx,xT,wx);
+
+    Matrix xTwx_1;
+    xTwx_1.initMatrix(&xTwx_1,xTwx.row,xTwx.col);
+    xTwx_1.nimatrix(&xTwx_1,xTwx);
+
+    //xTwx_1.print(xTwx_1);
+
+    Matrix xTwx_1xT;
+    xTwx_1xT.initMatrix(&xTwx_1xT,xTwx_1.col,xT.row);
+    xTwx_1xT.multsmatrix(&xTwx_1xT,xTwx_1,xT);
+
+    Matrix xTwx_1xTw;
+    xTwx_1xTw.initMatrix(&xTwx_1xTw,xTwx_1xT.col,w.row);
+    xTwx_1xTw.multsmatrix(&xTwx_1xTw,xTwx_1xT,w);
+
+    Matrix ws;
+    ws.initMatrix(&ws,xTwx_1xTw.col,y.row);
+    ws.multsmatrix(&ws,xTwx_1xTw,y);
+
+    cout<<"ws"<<endl;
+    ws.print(ws);
+    return ws;
+}
+/**
+通过调用上面的局部加权线性回归函数实现对每一个测试样例确定最后的参数，同样以列向量的形式存储，对n个特征的样本就n行，对m个样本就一个m列，
+**/
+
+int lwlrtest(Matrix x,Matrix y,double k)
+{
+    int i,j;
+    Matrix test;
+    test.initMatrix(&test,1,x.row);
+    Matrix wsOne;
+    wsOne.initMatrix(&wsOne,x.row,1);
+    Matrix ws;
+    ws.initMatrix(&ws,x.row,x.col);
+
+    /**
+    每一个样本单独调用局部加权线性回归
+    **/
+    for(i=0;i<ws.row;i++)///ws以列为一个权重参数向量，m列表示m个样本
+    {
+        test=test.getOneCol(x,i);
+        wsOne=locWeightLineReg(test,x,y,k);
+        for(j=0;j<ws.col;j++)
+        {
+            ws.mat[j][i]=wsOne.mat[j][0];
+        }
+    }
+    for(i=0;i<ws.row;i++)
+    {
+        for(j=0;j<ws.col;j++)
+        {
+            cout<<ws.mat[j][i]<<"  ";
+        }
+        cout<<endl;
+    }
+
+    /**验证局部加权线性回归的正确性*/
+    double yy;
+    for(i=0;i<ws.row;i++)
+    {
+        yy=0;
+        for(j=0;j<ws.col;j++)
+        {
+            yy+=ws.mat[j][i]*x.mat[i][j];
+        }
+        cout<<"y="<<yy<<endl;
+    }
+    return 0;
+}
+/**
+下面的岭回归函数只是在一般的线性回归函数的基础上在对角线上引入了岭的概念，不仅有解决矩阵不可逆的线性，同样也有正则项的目的，
+采用常用的二范数就得到了直接引入lam的形式。
+**/
+
+int ridgeRegres(Matrix x,Matrix y,double lam)
+{
+    int i=0;
+    Matrix xT;
+    xT.initMatrix(&xT,x.row,x.col);
+    x.transposematrix(x,&xT);
+    xT.print(xT);
+
+    Matrix xTx;
+    xTx.initMatrix(&xTx,xT.col,x.row);
+    xTx.multsmatrix(&xTx,xT,x);
+    xTx.print(xTx);
+
+    Matrix denom;
+    denom.initMatrix(&denom,xTx.col,xTx.row,lam);
+    xTx.addmatrix(&xTx,xTx,denom);
+    xTx.print(xTx);
+
+    Matrix xTx_1;
+    xTx_1.initMatrix(&xTx_1,xTx.row,xTx.col);
+    xTx_1.nimatrix(&xTx_1,xTx);
+
+    Matrix xTx_1xT;
+    xTx_1xT.initMatrix(&xTx_1xT,xTx_1.col,xT.row);
+    xTx_1xT.multsmatrix(&xTx_1xT,xTx_1,xT);
+
+    Matrix ws;
+    ws.initMatrix(&ws,xTx_1xT.col,y.row);
+    ws.multsmatrix(&ws,xTx_1xT,y);
+
+    cout<<"ws"<<endl;
+    ws.print(ws);
+    return 0;
+}
+int main()
+{
+    dataToMatrix dtm;
+    cout<<"loadData"<<endl;
+    cout<<"----------------------"<<endl;
+    char file[20]="data\\lineReg.txt";
+    dtm.loadData(&dtm,file);
+    dtm.print(dtm);
+
+    cout<<"x,y"<<endl;
+    cout<<"----------------------"<<endl;
+    Matrix x;
+    x.loadMatrix(&x,dtm);
+    Matrix y;
+    y.initMatrix(&y,x.col,1);
+    y=y.getOneRow(x,x.row);
+    y.print(y);
+    x.deleteOneRow(&x,x.row);
+    x.print(x);
+
+    regression(x,y);///调用线性回归函数
+    //lwlrtest(x,y,1.0);///调用局部加权线性回归函数
+    //ridgeRegres(x,y,0.1);///调用岭回归函数
+    return 0;
+}
