vector.cpp

基于线性规划的回归支持向量机源程序

    //allocate the new vector
	int len=p->length;
	//do the operations
    double *f=p->f;
	for(int i=0; i<len; i++, f++)
		*f *=x;
	return *this;
}

//v/=x

vector& vector::operator/=(double x)
{
    //allocate the new vector
	int len=p->length;
	//do the operations
    double *f=p->f;
	for(int i=0; i<len; i++, f++)
		*f /=x;
	return *this;
}


//f=v[i]

double& vector::operator[](int i)
{
	if((i>=0)&&(i<p->length))
		return p->f[i];
	else{
      {
        cout<< Merrorstring[EMAT_OUTOFRANGE];
//        throw Merrorstring[EMAT_OUTOFRANGE];
    }
//next statement has no effect. the only function is avoid warnning message.
		return p->f[0];
	}
}

//x=(v1==v2): returns 1 when v1==v2. otherwise, returns 0.

int     operator==(vector& v1, vector& v2)
{
	if(v1.p->length !=v2.p->length)
		return 0;
	int len=v1.p->length;
	//do the operations
    double *f1=v1.p->f;
    double *f2=v2.p->f;
	for(int i=0; i<len; i++, f1++, f2++)
		if(*f1 != *f2)
			return 0;
	return 1;
}

//x=(v1 !=v2): returns 1 when v1 !=v2. otherwise, returns 0.

int     operator!=(vector& v1, vector& v2)
{
	if(v1.p->length !=v2.p->length)
		return 1;
	int len=v1.p->length;
	//do the operations
    double *f1=v1.p->f;
    double *f2=v2.p->f;
	for(int i=0; i<len; i++, f1++, f2++)
		if(*f1 != *f2)
			return 1;
	return 0;
}

//cin>>v1

istream&  operator>>(istream& in, vector& v1)
{
	int n=v1.vlen();
	for(int i=0; i<n; i++){
		 in>>v1[i];
	}
	return in;
}

//cout<<v1

ostream&  operator<<(ostream& out, vector& v1)
{
    double *f=v1.p->f;
    int len=v1.p->length;
	for(int i=0; i<len; i++, f++)
    out<<*f<<"  ";
    out<<"\n";
    return out;
}

//sum(v): returns the sum of every elements.

double     vector::sum()
{
	int n=vlen();
    double re=0;
    double *f=p->f;
	for(int i=0; i<n; i++, f++)
		re +=*f;
	return re;
}



double    sum(vector& v)
{
	int n=v.vlen();
    double re=0;
    double *f1=v.p->f;
	for(int i=0; i<n; i++, f1++)
		re +=*f1;
	return re;
}


//v1.dot(v2)

double    vector::dot(vector& v2)
{
    if(v2()!=vlen())
    {
        cout<<"vector's dim are not equal";
    }
	int len=MIN(p->length,v2.p->length);
	//do the operations
    double sum=0;
    double *f1=p->f;
    double *f2=v2.p->f;
	for(int i=0; i<len; i++, f1++, f2++)
		sum += *f1 * *f2;
	return sum;
}


vector    vector::slice(int xlen)
{
	int lens=p->length;
    if((xlen>lens)||(xlen<0))
      {
        cout<< Merrorstring[EMAT_OUTOFRANGE];
//        throw Merrorstring[EMAT_OUTOFRANGE];
    }
    vector x(xlen);
	for(int i=0; i<xlen; i++)
		x[i]=(*this)[i];
	return x;
}


vector    slice(vector& v,int xlen)
{
	int lens=v.p->length;
    if((xlen>lens)||(xlen<0))
      {
        cout<< Merrorstring[EMAT_OUTOFRANGE];
//        throw Merrorstring[EMAT_OUTOFRANGE];
    }
    vector x(xlen);
	for(int i=0; i<xlen; i++)
		x[i]=v[i];
	return x;
}


vector    vector::slice(int lstart,int xlen)
{
	int lens=p->length;
    if(xlen<0)
      {
        cout<<Merrorstring[EMAT_ASSIGNDATAERR];
        //throw Merrorstring[EMAT_ASSIGNDATAERR];
    }
    if((lstart+xlen>lens)||(lstart<0))
      {
        cout<< Merrorstring[EMAT_OUTOFRANGE];
//        throw Merrorstring[EMAT_OUTOFRANGE];
    }
    vector x(xlen);
	for(int i=lstart; i<lstart+xlen; i++)
		x[i-lstart]=(*this)[i];
	return x;
}



vector    slice(vector& v,int lstart,int xlen)
{
	int lens=v.p->length;
    if(xlen<0)
      {
        cout<<Merrorstring[EMAT_ASSIGNDATAERR];
        //throw Merrorstring[EMAT_ASSIGNDATAERR];
    }
    if(((lstart+xlen)>lens)||(lstart<0))
      {
        cout<< Merrorstring[EMAT_OUTOFRANGE];
//        throw Merrorstring[EMAT_OUTOFRANGE];
    }
    vector x(xlen);
	for(int i=lstart; i<lstart+xlen; i++)
		x[i-lstart]=v[i];
	return x;
}


vector    vector::comvec(vector& v2)
{
	int i;
	int lens1=vlen();
	int lens2=v2.vlen();
	int lens=lens1+lens2;
    vector x(lens);
	for(i=0; i<lens1; i++)
		x[i]=(*this)[i];
	for(i=0; i<lens2; i++)
		x[i+lens1]=v2[i];
	return x;
}


vector    comvec(vector& v1,
            vector& v2)
{
	int i;
	int lens1=v1.vlen();
	int lens2=v2.vlen();
	int lens=lens1+lens2;
    vector x(lens);
	for(i=0; i<lens1; i++)
		x[i]=v1[i];
	for(i=0; i<lens2; i++)
		x[i+lens1]=v2[i];
	return x;
}

int any(vector & v)
{
	int n=v.vlen();
	int re=0;
	double *f=v.p->f;
	for(int i=0; i<n; i++,f++)
		if(*f !=0){
			re=1;
			break;
		}
	return re;
}


int vector::any()
{
	int n=vlen();
	int re=0;
	double *f=p->f;
	for(int i=0; i<n; i++,f++)
		if(*f !=0){
			re=1;
			break;
		}
	return re;
}


double vmax(vector & v)
{
	double xx;
	int nn=v.vlen();
	double *f=v.p->f;
	xx=*f;
	f++;
	for(int i=1; i<nn; i++,f++)
		if(*f>xx)
			xx=*f;
	return xx;
}


double vector::vmax()
{
	double xx;
	int nn=vlen();
	double *f=p->f;
	xx=*f;
	f++;
	for(int i=1; i<nn; i++,f++)
		if(*f>xx)
			xx=*f;
	return xx;
}

vector vmax(vector & v1,vector & v2)
{
	int nn=v1.vlen();
    if(v2.vlen() !=nn)
    {
        cout<<Merrorstring[EMAT_INVALIDORDER];
//        throw Merrorstring[EMAT_INVALIDORDER];
    }
    vector xx(nn);
	double *f=xx.p->f;
	double *f1=v1.p->f;
	double *f2=v2.p->f;
	for(int i=0; i<nn; i++,f++,f1++,f2++)
		if(*f1>*f2)
			*f=*f1;
		else
			*f=*f2;
	return xx;
}


vector vector::vmax(vector & v2)
{
	int nn=vlen();
    if(v2.vlen() !=nn)
    {
        cout<<Merrorstring[EMAT_INVALIDORDER];
//        throw Merrorstring[EMAT_INVALIDORDER];
    }
    vector xx(nn);
	double *f=xx.p->f;
	double *f1=p->f;
	double *f2=v2.p->f;
	for(int i=0; i<nn; i++,f++,f1++,f2++)
		if(*f1>*f2)
			*f=*f1;
		else
			*f=*f2;
	return xx;
}


double vmin(vector & v)
{
	double xx;
	int nn=v.vlen();
	double *f=v.p->f;
	xx=*f;
	f++;
	for(int i=1; i<nn; i++,f++)
		if(*f<xx)
			xx=*f;
	return xx;
}


double vector::vmin()
{
	double xx;
	int nn=vlen();
	double *f=p->f;
	xx=*f;
	f++;
	for(int i=1; i<nn; i++,f++)
		if(*f<xx)
			xx=*f;
	return xx;
}

vector vmin(vector & v1,vector & v2)
{
	int nn=v1.vlen();
    if(v2.vlen() !=nn)
    {
        cout<<Merrorstring[EMAT_INVALIDORDER];
//        throw Merrorstring[EMAT_INVALIDORDER];
    }
    vector xx(nn);
	double *f=xx.p->f;
	double *f1=v1.p->f;
	double *f2=v2.p->f;
	for(int i=0; i<nn; i++,f++,f1++,f2++)
		if(*f1<*f2)
			*f=*f1;
		else
			*f=*f2;
	return xx;
}


vector vector::vmin(vector & v2)
{
	int nn=vlen();
    if(v2.vlen() !=nn)
    {
        cout<<Merrorstring[EMAT_INVALIDORDER];
//        throw Merrorstring[EMAT_INVALIDORDER];
    }
    vector xx(nn);
	double *f=xx.p->f;
	double *f1=p->f;
	double *f2=v2.p->f;
	for(int i=0; i<nn; i++,f++,f1++,f2++)
		if(*f1<*f2)
			*f=*f1;
		else
			*f=*f2;
	return xx;
}


vector abs(vector & v)
{
	int nn=v.vlen();
    vector xx(nn);
	for(int i=0; i<nn; i++)
		xx[i]=::fabs(v[i]);
	return xx;
}

vector vector::abs()
{
	int nn=vlen();
    vector xx=(nn);
	for(int i=0; i<nn; i++)
		xx[i]=::fabs((*this)[i]);
	return xx;
}


double dot(vector & v1,vector & v2)
{
    if(v1()!=v2())
    {
        cout<<"vector's dim are not equal";
    }
	int len=MIN(v1.p->length,v2.p->length);
	//do the operations
	double sum=0;
	double *f1=v1.p->f;
	double *f2=v2.p->f;
	for(int i=0; i<len; i++, f1++, f2++)
		sum += *f1 * *f2;
	return sum;
}


vector & vector::rand()
{
	int nr=vlen();
	double *f=p->f;
	for(int i=0; i<nr; i++, f++)
		*f=(double)::rand()/(double)RAND_MAX;
	return *this;
}


vector & rand(vector & v)
{
	int nr=v.vlen();
	double *f=v.p->f;
	for(int i=0; i<nr; i++, f++)
		*f=(double)::rand()/(double)RAND_MAX;
	return v;
}


//constructs and returns a m*n random matrix
vector vector::rand(int m)
{
    vector v(m);
	double *f=v.p->f;
	for(int i=0; i<m; i++, f++)
		*f=(double)::rand()/(double)RAND_MAX;
   return v;
}

void vector::rndnorm(double mu,double sigma)
{
	int len=p->length;
    if(p->refcnt>1)
	{
		p->refcnt--;
		p=new vrep;
		p->length=len;
		p->refcnt=1;
        p->f=new double[len];
	}

    double *f=p->f;
	for(int i=0; i<len; i++, f++)
        *f=::rndnorm(mu,sigma);
}
static void shift(double* p,int i,int n)
{
    int j;
    double t;
    t=p[i];
    j=2*(i+1)-1;
    while(j<=n)
    {
        if( (j<n)&&(p[j]<p[j+1]) )
        j=j+1;
        if(t<p[j])
        {
            p[i]=p[j];
            i=j;
            j=2*(i+1)-1;
        }
        else
        j=n+1;
    }
    p[i]=t;
    return;
}
void mnheap(double *p,int n)
{
    int i,mm;
    double t;
//    void shift();
    mm=n/2;
    for(i=mm-1;i>=0;i--)
        shift(p,i,n-1);
    for(i=n-1;i>=1;i--)
    {
        t=p[0];
        p[0]=p[i];
        p[i]=t;
        shift(p,0,i-1);
    }
}


void vector::SortByHeap(int flag)
{
	mnheap(p->f,p->length);
}
IntVector vector::Sort(int flag)
{
    IntVector v;
    v.initial(p->length);
    double d1,d2;
    for(int k=0;k<v();k++)
    v[k]=k;
    for(k=0;k<(p->length-1);k++)
    {
        d1=p->f[k];
        int i=k;

        for(int s=k+1;s<p->length;s++)
        {
            d2=p->f[s];
            if(d2<d1)
            {
                d1=d2;
                i=s;
            }
        }
        if(i>k)
        {
            p->f[i]=p->f[k];
            p->f[k]=d1;
            int t=v[k];
            v[k]=v[i];
            v[i]=t;
        }
    }
    return v;
}