vector.cpp

非线形最小二乘程序,希望对大家有用哈,我现在急需APRIOR算法的C++程序,有的请给我发啊一份,

// Vector.cpp: implementation of the CVector class.
//
//////////////////////////////////////////////////////////////////////

#include "Vector.h"
#include "Matrix.h"
#include <math.h>



//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CVector::CVector(int p,bool brow)
{
	m_brow=brow;
	m_p=p;
	m_val=new double[p];
}

CVector::~CVector()
{
	delete []m_val;

}


double & CVector::operator [](int index)
{

	if(index>=0 && index<m_p)
		return m_val[index];
	else 
		throw("out of index");
	

}

bool CVector::IsRowVector()
{
	return m_brow;

}

void CVector::Transverse()
{
	m_brow=!m_brow;
}
/*
CMatrix CVector::operator *(const CVector &v)
{
	CMatrix M(m_p,v.m_p);
	if(!m_brow&&v.m_brow)
	{
		for(int i=0;i<m_p;i++)
			for(int j=0;j<v.m_p;j++)
				M[i][j]=m_val[i]*v[j];
	}
	else
		throw("not row*col error");
	return M;
}
*/
double CVector::operator *(const CVector &v)
{
	if(m_brow&&!v.m_brow)
	{
		if(m_p==v.m_p)
		{
			double temp=0.0;
			for(int i=0;i<m_p;i++)
				temp+=m_val[i]*v.m_val[i];
			return temp;
		}
		else
			throw("not same size error");
	}
	else
		throw("not row*col error");
}
CVector CVector::operator *(const CMatrix &m)
{		
	CVector vec(m.m_ne);

	if(m_p==m.m_nv)
	{
		for(int i=0;i<m.m_ne;i++)
		{
			double temp=0.0;
			for(int j=0;j<m_p;j++)
                temp+=m_val[j]*m.m_val[j][i];
			vec.m_val[i]=temp;
		}
	}
    else
		throw("error");
	return vec;

}

void CVector::Normalization()//归一化
{
	double val=Value();
	for(register i=0;i<m_p;i++)
		m_val[i]/=val;
}

double CVector::Value()
{
	double val=0;
	for(register i=0;i<m_p;i++)
		val+=m_val[i]*m_val[i];
	return sqrt(val);
}

void CVector::Resize(int n)
{
	delete[] m_val;
	m_p=n;
	m_val=new double[n];
}

CVector::CVector(const CVector &V)
{
//	delete[] m_val;
	m_p=V.m_p;
	m_brow=V.m_brow;
	m_val=new double[m_p];
	for(int i=0; i<m_p;i++)
		m_val[i]=V.m_val[i];
}

CVector & CVector::operator =(const CVector &V)
{
	m_p=V.m_p;
	m_brow=V.m_brow;
	m_val=new double[m_p];
	for(int i=0; i<m_p;i++)
		m_val[i]=V.m_val[i];
	return *this;
}

CVector CVector::Transpos()
{
	CVector vec(m_p);
	for(int i=0;i<m_p;i++)
		vec[i]=m_val[i];
	if(m_brow)
		vec.m_brow=false;
	else
		vec.m_brow=true;
	return vec;
}
		
void CVector::Remove(int n)
{
	for(int i=n;i<m_p;i++)
		m_val[i]=m_val[i+1];
	m_p=m_p-1;
}
CVector CVector::operator +(const CVector &m)
{
	CVector vec(m_p);
	CVector v=m;
	vec.m_brow=m_brow;
	for(int i=0;i<m_p;i++)
		vec[i]=m_val[i]+v[i];
	return vec;
}
CVector CVector::operator -(const CVector &m)
{
	CVector vec(m_p);
	CVector v=m;
	vec.m_brow=m_brow;
	for(int i=0;i<m_p;i++)
		vec[i]=m_val[i]-v[i];
	return vec;
}
CVector CVector::operator *(const double &m)
{
     CVector vec(m_p);
	 vec.m_brow=m_brow;
	 for(int i=0;i<m_p;i++)
		 vec[i]=m_val[i]*m;
	 return vec;

}
/*
CMatrix CVector::operator *(const CVector &v)
{
	CMatrix mat(m_p,v.m_p);
	if(m_brow=false&&v.m_brow==true&&m_p=v.m_p)
	{
		for(int i=0;i<m_p;i++)
			for(int j=0;j<m_p;j++)
				mat[i][j]=m_val[i]*v[j];
			return mat;
	}
	else
		throw("error");
}
*/
CVector CVector::operator /(const double &m)
{
     CVector vec(m_p);
	 vec.m_brow=m_brow;
	 for(int i=0;i<m_p;i++)
		 vec[i]=m_val[i]/m;
	 return vec;

}

CVector CVector::Standard()//标准化
{
    CVector vec(m_p);
	vec.m_brow=m_brow;
	double s=0;
	double aver=0;
	for(int i=0;i<m_p;i++)
		aver+=m_val[i];
	aver/=m_p;
	for(i=0;i<m_p;i++)
		s+=(m_val[i]-aver)*(m_val[i]-aver);
	s=sqrt(s/m_p);
	for(i=0;i<m_p;i++)
		vec[i]=(m_val[i]-aver)/s;
	return vec;

           
}

double CVector::Corelation(CVector v)
{
       if(v.m_p==m_p&&v.m_brow==m_brow)
	   {
		   double c=0.0;
		   for(int i=0;i<m_p;i++)
			   c+=v[i]*m_val[i];
		   return c/(Value()*v.Value());
	   }
	   else
		   throw("errow");
}

int CVector::GetLength()
{
    return m_p;
}

double CVector::Aver()
{
    double aver=0;
	for(int i=0;i<m_p;i++)
		aver+=m_val[i];
	aver/=m_p;
	return aver;
}

double CVector::Var()
{
   double var=0;
   for(int i=0;i<m_p;i++)
	   var+=(m_val[i]-Aver())*(m_val[i]-Aver());
   var/=m_p;
   return var;
}

double CVector::GetMax()//最大值的绝对值
{
	double max=myabs(m_val[0]);
	for(int i=1;i<m_p;i++)
	{
		if(myabs(m_val[i])>max)
			max=myabs(m_val[i]);
	}
	return max;
}

double CVector::myabs(double d)
{
	if(d<0)
		return 0-d;
	else
		return d;
	
}

ostream & operator <<(ostream &out,CVector &M)
{
	for(int i=0;i<M.m_p;i++)
		out<<M.m_val[i]<<" ";
	return out;
}

void CVector::SetRow(bool row)
{
	m_brow=row;
}

double CVector::Value2()
{
	double val=0;
	for(register i=0;i<m_p;i++)
		val+=m_val[i]*m_val[i];
	return val;
}