intvect.hpp

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

//defines vector template class which can used to every data type

#ifndef __INTVECTOR_HPP
#define __INTVECTOR_HPP
#include "matdef.hpp"

class IntMatrix;
class IntVector
{

	protected:

        //IntVector data structure
		struct vrep
		{
             int *f;
			 int refcnt;
			 int length;
		} *p;


	public:
        //friend classes.
        friend class IntMatrix;

		//iresult=v.vlen() or iresult=vlen(v) or iresult=vlen(pv)
		//retrieves dada member.
        friend int vlen(IntVector& v){ return v.p->length;}
        friend int vlen(IntVector   *v){ return v->p->length;}
		int vlen(){ return p->length;}

//        static void SetErrorHandler(ErrorReporter &er);


         //IntVector()
		 //default constructor.
         IntVector();

         //IntVector(i,c) or IntVector(i)
		 //constructor with the length and/or initial data.
         IntVector(int size, int init=0);
         initial(int size);

         //IntVector(pt,i)
		 //constructor with a c/c++ array and its length.
         IntVector(int   *a,int length);

         //IntVector(v1,v2)
         //constructor with two IntVectors.
         IntVector(IntVector& a1,IntVector& a2);

         //IntVector(v,i1,i2)
         //constructor with part of a IntVector.
         IntVector(IntVector& a,int first,int last);

         //IntVector(v)
		 //copy constructor.
         IntVector(IntVector& x);

		 //destructor.
         ~IntVector();

		 //vresult=v
         IntVector&  operator=(IntVector& v);

		 //vresult=x
         IntVector&  operator=(int x);

		 //vresult=copy(v) or vresult=x.copy()
         //produces a new IntVector which has the same order and elements.
         //this IntVector has its own data structure.
         friend IntVector   copy(IntVector& v);
         IntVector    copy();

		 //pt=v
         //converts IntVector to int *.
         operator int *(){return p->f;}
         int operator()(){return p->length;}

		//vresult=v1+v2
        friend IntVector    operator+(IntVector& v1, IntVector& v2);

		//vresult=v1-v2
        friend IntVector    operator-(IntVector& v1, IntVector& v2);

		//vresult=v1*v2
        friend IntVector    operator*(IntVector& v1, IntVector& v2);

		//vresult=v1/v2
        friend IntVector    operator/(IntVector& v1, IntVector& v2);

		//vresult=v1+x
        friend IntVector    operator+(IntVector& v1,int x);

		//vresult=v1-x
        friend IntVector    operator-(IntVector& v1,int x);

		//vresult=v1*x
        friend IntVector    operator*(IntVector& v1, int x);

		//vresult=v1/x
        friend IntVector    operator/(IntVector& v1, int x);

		//vresult=x+v1
        friend IntVector    operator+(int x, IntVector& v1);

		//vresult=x-v1
        friend IntVector    operator-(int x, IntVector& v1);

		//vresult=x*v1
        friend IntVector    operator*(int x, IntVector& v1);

		//vresult=x/v1
        friend IntVector    operator/(int x, IntVector& v1);

		//vresult=+v1
        friend IntVector    operator+(IntVector& v1);

		//vresult=-v1
        friend IntVector    operator-(IntVector& v1);

		//vresult+=v1
        IntVector&  operator+=(IntVector& v1);

		//vresult-=v1
        IntVector&  operator-=(IntVector& v1);

		//vresult*=v1
        IntVector&  operator*=(IntVector& v1);

		 //vresult/=v1
        IntVector&  operator/=(IntVector& v1);

		//vresult+=x
        IntVector&  operator+=(int x);

		//vresult-=x
        IntVector&  operator-=(int x);

		//vresult*=x
        IntVector&  operator*=(int x);

		//vresult/=x
        IntVector&  operator/=(int x);

		//xresult=v[i]
        int&  operator[](int i);

		//iresult=(v1==v2)
        friend int    operator==(IntVector& v1,
                     IntVector& v2);

		//iresult=(v1!=v2)
        friend int    operator!=(IntVector& v1,
                     IntVector& v2);

		//cin>>v
        friend istream&  operator>>(istream&,IntVector& v);

		//cout<<v
        friend ostream&  operator<<(ostream&,IntVector& v);

		//result=sum(v) or result=v.sum()
		//returns the sum of all elements.
        friend int    sum(IntVector& v);
        int    sum();

		//result=v1.dot(v2)
        int    dot(IntVector& v2);

		//vresult=v.slice(len) or  vresult=slice(v,len)
        //returns a subIntVector of v. it has len elements and vresult[0]=x[0].
        IntVector    slice(int len);
        friend IntVector    slice(IntVector& v,int len);

		//vresult=v.slice(lstart,length) or vresult=slice(v,lstart,length)
        //returns a subIntVector of v. it has length elements
		//and vresult[0]=v[lstart].
        IntVector    slice(int lstart,int length);
        friend IntVector    slice(IntVector& v, int lstart,
							int length);

		//vresult=v1.comvec(v2) or vresult=comvec(v1,v2)
        //combines two IntVectors.
        friend IntVector    comvec(IntVector& v1,IntVector& v2);
        IntVector    comvec(IntVector& v2);

         //result=any(v) or result=v.any()
         //if all elements of IntVector are zero, returns 0. otherwise, returns 1.
         friend int  any(IntVector  & v);
         int  any();

		 //result=max(v) or result=v.max()
         friend int  vmax(IntVector  & v);
         int  vmax();

		 //vresult=max(v1,v2) or vresult=v1.max(v2)
		 //vresult[i]=max(v1[i],v2[i]).
         friend IntVector  vmax(IntVector  & v1,
                    IntVector  & v2);
         IntVector  vmax(IntVector  & v2);

		 //result=min(v) or result=v.min()
         friend int  vmin(IntVector  & v);
         int  vmin();

		 //vresult=min(v1,v2) or vresult=v1.min(v2)
		 //vresult[i]=min(v1[i],v2[i]).
         friend IntVector  vmin(IntVector  & v1,
                    IntVector  & v2);
         IntVector  vmin(IntVector  & v2);

		 //vresult=abs(v) or vresult=v.abs()
         friend IntVector  abs(IntVector  & v);
         IntVector  abs();

		//result=dot(v1,v2)
        friend int  dot(IntVector  & v1,IntVector  & v2);

        void sort(int flag=1);
};
class SetCounter
{

	protected:

        //SetCounter data structure
		struct vrep
		{
             int *f;
			 int refcnt;
			 int length;
		} *p;
        int m_UnitMax;


	public:
		//iresult=v.vlen() or iresult=vlen(v) or iresult=vlen(pv)
		//retrieves dada member.
        friend int vlen(SetCounter& v){ return v.p->length;}
        friend int vlen(SetCounter   *v){ return v->p->length;}
		int vlen(){ return p->length;}

         //SetCounter()
		 //default constructor.
         SetCounter();

         //SetCounter(i,c) or SetCounter(i)
		 //constructor with the length and/or initial data.
         SetCounter(int size, int init=0);
         initial(int size);


		 //destructor.
         ~SetCounter();
         void SetUnitMax(int s){m_UnitMax=s;};
		 //vresult=v
         SetCounter&  operator=(SetCounter& v);

		 //vresult=x
         SetCounter&  operator=(int x);

		 //vresult=copy(v) or vresult=x.copy()
         //produces a new SetCounter which has the same order and elements.
         //this SetCounter has its own data structure.
         friend SetCounter   copy(SetCounter& v);
         SetCounter    copy();

		 //pt=v
         //converts SetCounter to int *.
         operator int *(){return p->f;}
         int operator()(){return p->length;}


        //vresult ++
        void operator++();

		//xresult=v[i]
        int&  operator[](int i);

		//iresult=(v1==v2)
        friend int    operator==(SetCounter& v1,
                     SetCounter& v2);
        long GetCountNum();

		//iresult=(v1!=v2)
        friend int    operator!=(SetCounter& v1,
                     SetCounter& v2);
		//cin>>v
        friend istream&  operator>>(istream&,SetCounter& v);

		//cout<<v
        friend ostream&  operator<<(ostream&,SetCounter& v);
};


//returns -Vo and -po to initial state which is set by compiler.
//#if defined( __BCOPT__ ) && !defined( _ALLOW_po )
//#pragma option -po.
//#endif
//#pragma option -Vo.

#endif //  __INTVECTOR_HPP