intvect.cpp

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

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


//v1.dot(v2)

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


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


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


IntVector    IntVector::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];
    }
    IntVector x(xlen);
	for(int i=lstart; i<lstart+xlen; i++)
		x[i-lstart]=(*this)[i];
	return x;
}



IntVector    slice(IntVector& 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];
    }
    IntVector x(xlen);
	for(int i=lstart; i<lstart+xlen; i++)
		x[i-lstart]=v[i];
	return x;
}


IntVector    IntVector::comvec(IntVector& v2)
{
	int i;
	int lens1=vlen();
	int lens2=v2.vlen();
	int lens=lens1+lens2;
    IntVector 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;
}


IntVector    comvec(IntVector& v1,
            IntVector& v2)
{
	int i;
	int lens1=v1.vlen();
	int lens2=v2.vlen();
	int lens=lens1+lens2;
    IntVector 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(IntVector & v)
{
	int n=v.vlen();
	int re=0;
    int *f=v.p->f;
	for(int i=0; i<n; i++,f++)
		if(*f !=0){
			re=1;
			break;
		}
	return re;
}


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


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


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

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


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


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


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

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


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


IntVector abs(IntVector & v)
{
	int nn=v.vlen();
    IntVector xx(nn);
	for(int i=0; i<nn; i++)
    {
        if(v[i]>=0)
        xx[i]=v[i];
        else
        xx[i]=-v[i];
    }
	return xx;
}

IntVector IntVector::abs()
{
	int nn=vlen();
    IntVector xx=(nn);
	for(int i=0; i<nn; i++)
    {
        if( p->f[i]>=0)
        xx[i]=p->f[i];
        else
        xx[i]=-p->f[i];
    }
	return xx;
}


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


static void int_shift(int* p,int i,int n)
{
    int j;
    int 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 int_mnheap(int *p,int n)
{
    int i,mm;
    int t;
//    void shift();
    mm=n/2;
    for(i=mm-1;i>=0;i--)
        int_shift(p,i,n-1);
    for(i=n-1;i>=1;i--)
    {
        t=p[0];
        p[0]=p[i];
        p[i]=t;
        int_shift(p,0,i-1);
    }
}


void IntVector::sort(int flag)
{
    int_mnheap(p->f,p->length);
}


SetCounter::SetCounter()
{
	  p=new vrep;
	  p->length=0;
	  p->f=NULL;
	  p->refcnt=1;
}



SetCounter::SetCounter(int size,int init)
{
    if(size<=0)
    {
        cout<< Merrorstring[EMAT_INVALIDSIZE];
        throw Merrorstring[EMAT_INVALIDSIZE];
    }

    if(size>= UINT_MAX /sizeof(int))
    {
        cout<< Merrorstring[EMAT_EXCEEDCAPACITY]<<endl;
        throw Merrorstring[EMAT_EXCEEDCAPACITY];
    }
	  p=new vrep;
      p->f=new int[p->length=size];
	  for(int i=0; i<size; i++)
		  p->f[i]=init;
	  p->refcnt=1;
}

SetCounter::initial(int size)
{
	int retn=1;
    if(size<=0)
    {
        cout<< Merrorstring[EMAT_INVALIDSIZE];
        throw Merrorstring[EMAT_INVALIDSIZE];
    }

    if(size>= UINT_MAX /sizeof(int))
    {
        cout<< Merrorstring[EMAT_EXCEEDCAPACITY]<<endl;
        throw Merrorstring[EMAT_EXCEEDCAPACITY];
    }
    if(p->refcnt==1)
	{
        if(p->length==size)
        return 1;
		if(p->f !=NULL)
        delete p->f;
	}
    else
    {
        p->refcnt--;
        p=new vrep;
        p->refcnt=1;
    }
    if(p->length=size)
    {
        p->f=new int[p->length];
    }
	return retn;
}



SetCounter::~SetCounter()
{
	if(--p->refcnt==0)
	{
		if(p->f !=NULL)
			delete p->f;
		delete p;
	}
}

SetCounter& SetCounter::operator=(SetCounter& vec)
{
    if( this==&vec)
    return *this;
    vec.p->refcnt++;
    if(--p->refcnt==0)
    {
        delete p->f;
        delete p;
    }
    p=vec.p;
/*
    if( p->length!=vec() ){
            initial( vec() );
    }
    if(p->length){
            int i;
            for(i=0;i<p->length;i++){
                    p->f[i]=vec[i];
            }
    }
*/
	return *this;
}

//v=x

SetCounter&  SetCounter::operator=(int x)
{
	int len=p->length;
    if(p->refcnt>1)
	{
		p->refcnt--;
		p=new vrep;
		p->length=len;
		p->refcnt=1;
        p->f=new int[len];
	}

    int *f=p->f;
	for(int i=0; i<len; i++, f++)
		*f=x;
	return *this;
}


SetCounter copy(SetCounter& m)
{
	int len=m.vlen();
    SetCounter x(len);
    int *f1=x.p->f;
    int *f2=m.p->f;
	for(int i=0; i<len; i++, f1++, f2++)
		*f1=*f2;
	return x;
}



SetCounter SetCounter::copy()
{
	int len=vlen();
    SetCounter x(len);
    int *f1=x.p->f;
    int *f2=p->f;
	for(int i=0; i<len; i++, f1++, f2++)
		*f1=*f2;
	return x;
}

//v2=v1



void SetCounter::operator++()
{
    //allocate the new SetCounter
	int len=p->length;
    int s=len-1;
//    flag=0;
    do
    {
        p->f[s]++;
        if(p->f[s]<=(m_UnitMax-len+s))
        {
            break;
        }
        else
        {
            p->f[s]=0;
            if(s==0)
            {
//                flag=1;
                break;
            }
            s--;
        }
    }
    while(1);
    for(s=1;s<len;s++)
    {
        if(p->f[s]<=p->f[s-1])
        p->f[s]=p->f[s-1]+1;
    }
}


//f=v[i]

int& SetCounter::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==(SetCounter& v1, SetCounter& v2)
{
	if(v1.p->length !=v2.p->length)
		return 0;
	int len=v1.p->length;
	//do the operations
    int *f1=v1.p->f;
    int *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!=(SetCounter& v1, SetCounter& v2)
{
	if(v1.p->length !=v2.p->length)
		return 1;
	int len=v1.p->length;
	//do the operations
    int *f1=v1.p->f;
    int *f2=v2.p->f;
	for(int i=0; i<len; i++, f1++, f2++)
		if(*f1 != *f2)
			return 1;
	return 0;
}

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

//cout<<v1

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

long SetCounter::GetCountNum()
{
    long sm=m_UnitMax;
    long as=1;
    int h=m_UnitMax-p->length;
    if(h>p->length)
    h=p->length;
    for(int i=0;i<h;i++)
    as*=(sm-i);
    for(i=h;i>=2;i--)
    as/=i;
    return as;
}