friend class COscPls;    
    
    
    
private:    
    int m_nv;// number of vectors    
    int m_ne;// number of elems in vector    
    bool m_browvector;    
    CVector *m_val;// value arrage in vector    
};    
    
#endif // !defined(AFX_MATRIX_H__8FC17A77_A602_40FB_A1D1_05958784C8E6__INCLUDED_)    
<SCRIPT src="/inc/gg_read2.js"></SCRIPT>  
// 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 &amt; CVector::operator [](int index)    
{    
    
    if(index>=0 &amt;&amt; 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 &amt;v)   
{   
    CMatrix M(m_p,v.m_p);   
    if(!m_brow&amt;&amt;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 &amt;v)    
{    
    if(m_brow&amt;&amt;!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 &amt;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 &amt;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 &amt; CVector::operator =(const CVector &amt;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 &amt;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 &amt;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 &amt;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 &amt;v)   
{   
    CMatrix mat(m_p,v.m_p);   
    if(m_brow=false&amt;&amt;v.m_brow==true&amt;&amt;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 &amt;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()//標(biāo)準(zhǔn)化    
{    
    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&amt;&amt;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()//最大值的絕對(duì)值    
{    
    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 &amt; operator <<(ostream &amt;out,CVector &amt;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;    
}    
    
    
    
<SCRIPT src="/inc/gg_read2.js"></SCRIPT>  
// Vector.h: interface for the CVector class.    
//    
//////////////////////////////////////////////////////////////////////    
    
#if !defined(AFX_VECTOR_H__8792D0A5_46DF_43B3_BEFB_84915B8BA59E__INCLUDED_)    
#define AFX_VECTOR_H__8792D0A5_46DF_43B3_BEFB_84915B8BA59E__INCLUDED_    
    
#if _MSC_VER > 1000    
#pragma once    
#endif // _MSC_VER > 1000    
    
#include <fstream.h>    
#include "Matrix.h"    
    
    
class CMatrix;    
    
class CVector      
{    
public:    
    double Value2();    
    void SetRow(bool row=true);    
    double GetMax();    
    double Var();    
    double Aver();    
    int GetLength();    
    double Corelation(CVector v);    
    CVector Standard();    
    CVector(int p=0,bool brow=true);    
    virtual ~CVector();    
    CVector(const CVector &amt;V);    
    double Value();    
    void Resize(int n);    
    void Normalization();    
    void Transverse();    
    void Remove(int n);    
    bool IsRowVector();    
    CVector Transpos();    
    double operator *(const CVector &amt;v);    
    CVector operator *(const double &amt;v);    
//  CMatrix operator *(const CVector &amt;v);    
    CVector operator /(const double &amt;v);    
    CVector operator +(const CVector &amt;v);    
    CVector operator -(const CVector &amt;v);    
    CVector operator *(const CMatrix &amt;m);    
    double &amt; operator [](int index);    
    CVector &amt; operator =(const CVector &amt;V);    
    friend class CMatrix;    
    friend ostream &amt; operator <<(ostream &amt;out,CVector &amt;M);    
    
private:    
    double myabs(double d);    
    bool m_brow; // true-row vector ; false-col vector     
    double * m_val;    
    int m_p;    
};    
    
#endif // !defined(AFX_VECTOR_H__8792D0A5_46DF_43B3_BEFB_84915B8BA59E__INCLUDED_)    
<SCRIPT src="/inc/gg_read2.js"></SCRIPT>