svmview.cpp

支持向量基预测的小数据量的预测方法。包括数据拟合

// svmView.cpp : implementation of the CSvmView class
//

#include "stdafx.h"
#include "svm.h"

#include "svmDoc.h"
#include "svmView.h"
//#include <stdio.h>
//
//#include <stdlib.h>

// #include <malloc.h>

#include <math.h>

#include "Dialog_Congress_Paramter.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CSvmView

IMPLEMENT_DYNCREATE(CSvmView, CEditView)

BEGIN_MESSAGE_MAP(CSvmView, CEditView)
	//{{AFX_MSG_MAP(CSvmView)
	ON_COMMAND(ID_REGRESS, OnRegress)
	ON_COMMAND(ID_REGRESS_Paremter, OnREGRESSParemter)
	ON_COMMAND(ID_GRESS_DRAW, OnGressDraw)
	//}}AFX_MSG_MAP
	// Standard printing commands
	ON_COMMAND(ID_FILE_PRINT, CEditView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CEditView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CEditView::OnFilePrintPreview)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CSvmView construction/destruction

CSvmView::CSvmView()
{
}

CSvmView::~CSvmView()
{
}

BOOL CSvmView::PreCreateWindow(CREATESTRUCT& cs)
{
	return CEditView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CSvmView drawing

void CSvmView::OnDraw(CDC* pDC)
{
	CSvmDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
    // TOD add draw code for native data here
	
}

/////////////////////////////////////////////////////////////////////////////
// CSvmView printing

BOOL CSvmView::OnPreparePrinting(CPrintInfo* pInfo)
{
	// default preparation
	return DoPreparePrinting(pInfo);
}

void CSvmView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
}

void CSvmView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
}

/////////////////////////////////////////////////////////////////////////////
// CSvmView diagnostics

#ifdef _DEBUG
void CSvmView::AssertValid() const
{
	CEditView::AssertValid();
}

void CSvmView::Dump(CDumpContext& dc) const
{
	CEditView::Dump(dc);
}

CSvmDoc* CSvmView::GetDocument() // non-debug version is inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CSvmDoc)));
	return (CSvmDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CSvmView message handlers
// 曲线拟合：

//简单的讲，所谓拟合是指已知某函数的若干离散函数值{f1,f2,…,fn}，通
//          过调整该函数中若干待定系数f(λ1, λ2,…,λ3), 使得该函数与已知点集的
//          差别(最小二乘意义)最小。如果待定函数是线性，就叫线性拟合或者
//          线性回归(主要在统计中)，否则叫作非线性拟合或者非线性回归。表
//          达式也可以是分段函数，这种情况下叫作样条拟合。

/*Smooth(double *,double *,double *,int,int, double *,double *,double *);*/

// double *x;                /*实型一维数组，输入参数，存放节点的xi值*/
//
// double *y;                /*实型一维数组，输入参数，存放节点的yi值*/
//
// double *a;                /*双精度实型一维数组，长度为m。返回m一1次拟合多项式的m个系数*/
//
// int n;                    /*整型变量，输入参数，给定数据点的个数*/
//
// int m;                    /*整型变量，输入参数，拟合多项式的项数*/
//
// double *dt1;              /*实型变量，输出参数，拟合多项式与数据点偏差的平方和*/
//
// double *dt2;              /*实型变量，输出参数，拟合多项式与数据点偏差的绝对值之和*/
//
// double *dt3;             /*实型变量，输出参数，拟合多项式与数据点偏差的绝对值最大值*/
double X1,X2,X3,X4,X5,X6;

Smooth(double *x,double *y,double *a,int n,int m,double *dt1,double *dt2,double *dt3)

  {
                 int i,j,k;

                 double *s,*t,*b,z,d1,p,c,d2,g,q,dt;

                   /*分别为s,t,b分配存贮空间*/

                   s = (double *)calloc(n,sizeof(double));

                   if(s == NULL)

                   {
                        AfxMessageBox("内存分配失败\n");

                        exit (0);
                   }

                   t = (double *)calloc(n,sizeof(double));

                   if(t == NULL)

                   {
                       AfxMessageBox("内存分配失败\n");

                       exit (0);
                   }

                   b = (double *)calloc(n,sizeof(double));

                   if(b == NULL)

                   {
                       AfxMessageBox("内存分配失败\n");

                       exit (0);
                   }

                   z = 0;

                  for(i=1;i<=n;i++)

                            z=z+x[i-1]/n;   /*z为各个x的平均值*/

                   b[0]=1;

                   d1=n;

                   p=0;

                   c=0;

                  for(i=1;i<=n;i++)

                   {
                       p=p+x[i-1]-z;

                       c=c+y[i-1];
                   }

                  c=c/d1;

                  p=p/d1;

                  a[0]=c*b[0];

                   if(m>1)

                   {

                            t[1]=1;

                            t[0]=-p;

                            d2=0;

                            c=0;

                            g=0;

                            for(i=1;i<=n;i++)

                            {

                                     q=x[i-1]-z-p;

                                     d2=d2+q*q;

                                     c=y[i-1]*q+c;

                                     g=(x[i-1]-z)*q*q+g;

                            }

                            c=c/d2;

                            p=g/d2;

                            q=d2/d1;

                            d1=d2;

                            a[1]=c*t[1];

                            a[0]=c*t[0]+a[0];

                   }

                  for(j=3;j<=m;j++)

                   {

                            s[j-1]=t[j-2];

                            s[j-2]=-p*t[j-2]+t[j-3];

                            if(j>=4)

                                     for(k=j-2;k>=2;k--)

                                              s[k-1]=-p*t[k-1]+t[k-2]-q*b[k-1];

                                     s[0]=-p*t[0]-q*b[0];

                                     d2=0;

                                     c=0;

                                     g=0;

                                     for(i=1;i<=n;i++)

                                     {

                                              q=s[j-1];

                                              for(k=j-1;k>=1;k--)

                                                        q=q*(x[i-1]-z)+s[k-1];

                                              d2=d2+q*q;

                                              c=y[i-1]*q+c;

                                              g=(x[i-1]-z)*q*q+g;

                                     }

                                     c=c/d2;

                                     p=g/d2;

                                     q=d2/d1;

                                     d1=d2;

                                     a[j-1]=c*s[j-1];

                                     t[j-1]=s[j-1];

                                     for(k=j-1;k>=1;k--)

                                     {
                                         a[k-1]=c*s[k-1]+a[k-1];

                                         b[k-1]=t[k-1];

                                         t[k-1]=s[k-1];
                                     }

                   }

                  *dt1=0;

                  *dt2=0;

                  *dt3=0;

                  for(i=1;i<=n;i++)

                   {
                            q=a[m-1];

                            for(k=m-1;k>=1;k--)

                                     q=q*(x[i-1]-z)+a[k-1];

                           dt=q-y[i-1];

                            if(fabs(dt)>*dt3)

                                     *dt3=fabs(dt);

                            *dt1=*dt1+dt*dt;

                            *dt2=*dt2+fabs(dt);

                   }
//         CString str1,str2,str3;
//	     str1.Format("拟合多项式与数据点偏差的平方和＝%.10e",dt1);
//	     AfxMessageBox(str1);
//
//		 str2.Format("拟合多项式与数据点偏差的绝对值之和为＝%.10e",dt2);
//	     AfxMessageBox(str2);
//
//		 str3.Format("拟合多项式与数据点偏差的绝对值最大值为＝%.10e",dt3);
//	     AfxMessageBox(str3);

                   /*释放存储空间*/

                   free(s);

                   free(t);

                   free(b);

                  return(1);
 }
 
void CSvmView::OnRegress() 
{
	// TODO: Add your command handler code here
	 int i,n,m;

         double *x,*y,*a,dt1,dt2,dt3,b;

         n = 20;