wzjarray.cpp

在工程交通行业如测绘部门经常用到角度单位的转换

	New2Array(dArray, m_nRow, m_nColumn);	
	for (int i = 0; i < m_nRow; i++)
	{
		for (int j = 0; j < m_nColumn; j++)
		{			
			dArray[i][j] = pow(m_dUnitData[i][j], dPow);
		}
	}
	return CWzjArray(dArray, m_nRow, m_nColumn);
}

//获得转置矩阵
CWzjArray CWzjArray::GetTransposeArray()
{
	int ro = m_nColumn;
	int col = m_nRow;
	
	int r,c;
//存放转置的数组
	double **fArray;  
	New2Array(fArray,ro,col);
	for(r = 0;r < ro;r++)
	{
		for(c = 0;c < col;c++)
		{
			fArray[r][c] = m_dUnitData[c][r];
		}
	}
	return CWzjArray(fArray, ro, col);		
}

//求逆矩阵
BOOL CWzjArray::GetContralArray(CWzjArray& arrControl) 
{
	BOOL bIsSuc = TRUE;
	int ro = m_nRow;
	int col = m_nColumn;	
	if (ro != col)
	{
		AfxMessageBox("所求逆的矩阵不是方阵，返回空矩阵", MB_ICONERROR);
		bIsSuc = FALSE;
	}
	int r,c,k;
	double fTemp;

	//左边为原矩阵，右边为单位阵的构造矩阵
	double **fAddArray ;
	New2Array(fAddArray,ro,2*col);
	for (r = 0; r < ro; r++)
	{
		for (c=0;c<col;c++)
		{
			fAddArray[r][c]	= m_dUnitData[r][c];
		}
		for (c=col;c<2*col;c++)
		{
			if ((c-r)==ro)
			{
				fAddArray[r][c]=1.0;
			}
			else
			{
				fAddArray[r][c]=0.0;
			}
		}
	}
	
	BOOL bIsError = FALSE;
//使矩阵左下三角为0
	for (k=0; k<ro; k++) //第k行第k列的数字一定要是1,从0列开始处理,现在正在处理第k列,从第k行开始处理,k行之前主位为1,副位为0了
	{
		for (r = k; r<ro; r++) //下面从第k行开始看，如果k行k列是0，在下面的行中找到第k列不为0行的交换,然后变为1就可以了
		{
			if (fabs(fAddArray[k][k]) < 1e-8) //如果k行k列为0，在下面的行寻找不该列不为0的行，交换	
			{
				if (k + 1 == ro) //如果是最后一列主位为0的话
				{
					bIsSuc = FALSE;
				}
				for (int vr = k+1; vr<ro; vr++) //寻找下面在这一列上不为0的行
				{
					if (fabs(fAddArray[vr][k]) > 1e-8)  //如果找到不为0的行
					{
						for(int j=2*col-1; j>=k; j--) //交换,不为0的行与该行整行交换
						{
							fTemp = fAddArray[r][j];
							fAddArray[r][j] = fAddArray[vr][j];
							fAddArray[vr][j] = fTemp;
						}
						break; //找到了，并且交换后，再不找了
					}
					else 
					{
						bIsSuc = FALSE;
						
					}
				}
			}
			if ((fabs(fAddArray[r][k]) > 1e-8) && (fabs(fAddArray[r][k] - 1) > 1e-8)) //如果第k列为0或1，不做任何变化,如果不为0,把k列变为1，其他相应列除以第k列 
			{
				for (c=2*col-1; c>=k; c--)  //如果第一个不为0的元素不为0,或者经过交换后成为不为0(经过上面的if语句) 
				{				
					fAddArray[r][c] /= fAddArray[r][k];
				}
			}
		}
		
		for(r=k+1; r<ro; r++) //下行减去k行对应列，消去首行元素1
		{
			if (fabs(fAddArray[r][k]) > 1e-8 ) //如果主位不为0，则减去k行相应列;如果主位为0,就不用减了
			{
				for(c=k;c<2*ro;c++)
				{
					fAddArray[r][c] -= fAddArray[k][c];
				}
			}
		}
	}
//使左部分除了主对角线为1外，其他上行减去每一个下行与本身第二个应该不为0的元素乘积,这个不为0的元素有时为0,就在主位的右边
//主要是从第1行开始,把k行k列的为1,k行其他列变为0,具体来说是k列之后的变为0,k列之前的已经为0了
	for(k=0; k<ro; k++) //遍历每一个行,将起变为标准行
	{               
		for(r=k+1; r<ro; r++) //遍历将要变化的行的下面所有行,将要减去下面所有行一遍,把每个k列后的副位变为0
		{
			for (c = 2 * col - 1; c >= 0; c--) //每次减下面个行的时候,从最后一列开始
			{
				fAddArray[k][c] -= fAddArray[r][c] * fAddArray[k][r];
			}
		}
	}
//提取右部分的逆距阵
	double** fContralArray;		
	New2Array(fContralArray,ro,col);
	for(r=0;r<ro;r++)
	{
		for(c=0;c<col;c++)
		{
			fContralArray[r][c]=fAddArray[r][c+(int)col];
		}
	}	
	Delete2Array(fAddArray, ro);
	arrControl.SetArrayData(fContralArray, ro, col);	
	return bIsSuc;		
}

//指针数组删除一列
void CWzjArray::DeleteColumn(int nColumn)
{	
	if (nColumn < 0 || nColumn >= m_nColumn)
	{
		AfxMessageBox("指定删除的列号不正确,\r\n\r\n数据不改变!",MB_ICONERROR);
		return ;
	}

	for (int r = 0; r < m_nRow; r++)
	{
		for (int c = nColumn; c < m_nColumn - 1; c++)
		{
			if (m_dUnitData)
			{
				m_dUnitData[r][c] = m_dUnitData[r][c + 1];
			}
			if (m_szUnitData)
			{
				m_szUnitData[r][c] = m_szUnitData[r][c + 1];
			}
		}
	}
	m_nColumn--;
}

//指针数组删除指定行，这里的行号从0开始
void CWzjArray::DeleteRow(int nRow)
{
	if ((nRow >= m_nRow) || (nRow < 0))
	{
		AfxMessageBox("指定删除的行号不正确,\r\n\r\n数据不改变!",MB_ICONERROR);
		return ;
	}
	for (int r = nRow; r < m_nRow - 1; r++)
	{
		for (int c = 0; c < m_nColumn; c++)
		{
			if (m_dUnitData)
			{
				m_dUnitData[r][c] = m_dUnitData[r+1][c];
			}
			if (m_szUnitData)
			{
				m_szUnitData[r][c] = m_szUnitData[r+1][c];
			}
		}		
	}
	m_nRow--;
}

//通过指针定义的对象距阵格式化成整体字符串形式
void CWzjArray::FormatToTotalArray(int nPre /*= 6*/, int nInt /*= 0*/, CString szInterStr /*=","*/)
{
	CString ArrayStr;
	CString strTemp;
	for(int row = 0;row < m_nRow;row++)
	{
		for(int col = 0;col < m_nColumn;col++)
		{			
			ArrayStr += GetStr(*(*(m_dUnitData+row)+col), nPre, nInt) + szInterStr;
		}
		ArrayStr.TrimRight(szInterStr);
		ArrayStr += "\r\n";
	}
	ArrayStr.TrimRight();
	m_WzjArrayData = ArrayStr;
}

//通过指针定义的对象格式化成单元字符串的形式
void CWzjArray::FormatToUnitData()
{
	New2Array(m_szUnitData, m_nRow, m_nColumn);
	for (int row = 0; row < m_nRow; row++)
	{
		for (int col = 0; col < m_nColumn; col++)
		{
			m_szUnitData[row][col] = GetStr(m_dUnitData[row][col]);
		}
	}
}

//通过整体字符串形式定义的矩阵对象获得指针数组形式
void CWzjArray::Atof()
{
	New2Array(m_dUnitData, m_nRow, m_nColumn);
	for (int row = 0; row < m_nRow; row++)
	{
		for (int col = 0; col < m_nColumn; col++)
		{
			m_dUnitData[row][col] = atof(m_szUnitData[row][col]);
		}
	}
}

//手动删除指针成员变量
void CWzjArray::DeleteWzjArray()
{
	if (m_dUnitData)
	{
		Delete2Array(m_dUnitData, m_nRow);
	}
	if (m_szUnitData)
	{
		Delete2Array(m_szUnitData, m_nRow);
	}
}

//拷贝矩阵
BOOL CWzjArray::CopyFrom(CWzjArray arrSource, BOOL bIsAutoDel /*= FALSE*/)
{
	BOOL bIsCopyed = FALSE;
	int nRow = arrSource.m_nRow;
	int nCol = arrSource.m_nColumn;
	
	double** dObj;	
	New2Array(dObj, nRow, nCol);	
	if (arrSource.m_dUnitData) 
	{
		for (int i = 0; i < nRow; i++)
		{
			for (int j = 0; j < nCol; j++)
			{
				dObj[i][j] = arrSource.m_dUnitData[i][j];
			}
		}
		bIsCopyed = TRUE;
	}	
	SetArrayData(dObj, nRow, nCol);	
	m_szInterStr = m_szInterStr;		
	return bIsCopyed;
}

//清空矩阵为空或为0
void CWzjArray::Reset(BOOL bIsValOrStr /*= TRUE*/)
{
	for (int i = 0; i < m_nRow; i++)
	{
		for (int j = 0; j < m_nColumn; j++)
		{
			if (TRUE == bIsValOrStr)
			{
				m_dUnitData[i][j] = 0.0;
			}
			else
			{
				m_szUnitData[i][j] = "";
			}
		}
	}
}
//实现

//创建二维double指针
BOOL CWzjArray::New2Array(double** &pdArray, int nRow, int nColumn)
{
	BOOL bIsNew = FALSE;
	pdArray = new double* [nRow];
	for (int i = 0; i < nRow; i++)
	{
		pdArray[i] = new double[nColumn];
	}
	bIsNew = TRUE;
	return bIsNew;
}

//释放二维double指针
BOOL CWzjArray::Delete2Array(double** &pdArray, int nRow)
{
	BOOL bIsDelete = FALSE;
	for (int i = 0; i < nRow; i++)
	{
		if (pdArray[i])
		{
			delete []pdArray[i];
			pdArray[i] = NULL;
		}
	}	
	if (pdArray)
	{
		delete []pdArray;
		pdArray = NULL;
	}
	bIsDelete = TRUE;
	return bIsDelete;
}

//创建二维CString指针
BOOL CWzjArray::New2Array(CString** &pszArray, int nRow, int nColumn)
{
	BOOL bIsNew = FALSE;	
	pszArray = new CString *[nRow];
	for (int i = 0; i < nRow; i++)
	{
		pszArray[i] = new CString[nColumn];
	}
	bIsNew = TRUE;
	return bIsNew;
}

BOOL CWzjArray::Delete2Array(CString** &pszArray, int nRow)
{
	BOOL bIsDelete = FALSE;
	for (int i = 0; i < nRow; i++)
	{
		if (pszArray[i])
		{
			delete []pszArray[i];
			pszArray[i] = NULL;
		}
	}
	if (pszArray)
	{
		delete []pszArray;
		pszArray = NULL;
	}
	bIsDelete = TRUE;
	return bIsDelete;
}


CString CWzjArray::GetStr(double dData,int nPri /*= 6*/,int nInt /*= 0*/)
{
	CString szFormat;
	szFormat.Format("%d.%d",nInt,nPri);
	szFormat = "%" + szFormat + "f";
	CString szReturn;
	szReturn.Format(szFormat,dData);
	return szReturn;
}