static int L2LU(const int M, const int N, TYPE *A, const int lda, int *ipiv)
/*
* Level 2 based left-looking LU
*/
{
TYPE *Ac=A;
TYPE t0;
const int MN=Mmin(M,N), MN_1=MN-1;
int ip, j, jn, iret=0;
if (N == 2) return(LU2(M, A, lda, ipiv));
for (j=0, jn=1; j != MN; j=jn++)
{
ipiv[j] = ip = j + cblas_iamax(M-j, Ac+j, 1);
t0 = Ac[ip];
if (t0 != ATL_rzero)
{
MySwap(N, A+j, lda, ip-j);
cblas_scal(M-jn, ATL_rone/t0, Ac+jn, 1);
if (j != MN_1)
{
Ac += lda;
cblas_trsv(CblasColMajor, CblasLower, CblasNoTrans, CblasUnit, jn,
A, lda, Ac, 1);
cblas_gemv(CblasColMajor, CblasNoTrans, M-jn, jn, ATL_rnone,
A+jn, lda, Ac, 1, ATL_rone, Ac+jn, 1);
}
}
else if (!iret) iret = jn;
}
return(iret);
}
/*选择排序*/
void ChooseSort(int nArray[], int nCount)
{
int i,j, k;
for(i=0; i<nCount; i++)
{
k = i;
for(j=i+1; j<nCount; j++)
{
if(nArray[j] < nArray[k])
{
k=j;
}
}
MySwap(&nArray[i], &nArray[k]);
}
}
/*冒泡排序*/
void BubbleSort(int nArray[], int nCount)
{
int i,j, nSwapFlag;
for(i=0; i<nCount; i++)
{
nSwapFlag = 0;
for(j=nCount-1;j>i;j--)
{
if(nArray[j]<nArray[j-1])
{
MySwap(&nArray[j], &nArray[j-1]);
nSwapFlag = 1;
}
}
if(!nSwapFlag) break; /*前一次排序没有发生过交换，说明已经排序完成*/
}
}
void AdjastHeap(DATA dataArray[], uint length, uint startPos){
uint leftChild = startPos * 2 + 1;
uint rightChild = startPos * 2 + 2;
uint nonLeafNode = (int)length / 2 -1;
uint maxNode = startPos;
if(leftChild < length && dataArray[maxNode] <= dataArray[leftChild]){
maxNode = leftChild;
}
if(rightChild < length && dataArray[maxNode] <= dataArray[rightChild]){
maxNode = rightChild;
}
if(maxNode != startPos){
MySwap(dataArray[startPos], dataArray[maxNode]);
}
if(leftChild <= nonLeafNode){
AdjastHeap(dataArray, length, leftChild);
}
if(rightChild <= nonLeafNode){
AdjastHeap(dataArray, length, rightChild);
}
}
