mssriicc.cc

一种聚类算法,名字是cocluster

    for (int r = 0; r < numRow; r++){
      tempValue = colCentroid[cc][r];
      if (tempValue != 0)
        temp += (tempValue * tempValue) / colCS[cc];
    }
  }
  return temp;
}


double MssrIIcc::computeColQuality4CentroidNormalized(int cc)
{
  double tempValue = 0, temp = 0;
  if (colCS[cc] > 0){
    for (int r = 0; r < numRow; r++){
      tempValue = colCentroid[cc][r];
      if (tempValue != 0)
        temp += (tempValue * tempValue) * colCS[cc];
    }
  }
  return temp;
}


double MssrIIcc::computeColQuality4CentroidUnnormalized(double *col1Way, int colClusterSize)
{
  double tempValue = 0, temp = 0;
  if (colClusterSize > 0){
    for (int r = 0; r < numRow; r++){
      tempValue = col1Way[r];
      if (tempValue != 0)
        temp += (tempValue * tempValue) / colClusterSize;
    }
  }
  return temp;
}


double MssrIIcc::computeColQuality4CentroidNormalized(double *col1Way, int colClusterSize)
{
  double tempValue = 0, temp = 0;
  if (colClusterSize > 0){
    for (int r = 0; r < numRow; r++){
      tempValue = col1Way[r];
      if (tempValue != 0)
        temp += (tempValue * tempValue) * colClusterSize;
    }
  }
  return temp;
}


void MssrIIcc::computeRowAP(int r)
{
//  assert(isNormalizedColCentroid);
  myCRS->computeRowAP(r, colCentroid, colCL, rowAP);
}

void MssrIIcc::computeRowAP(int r, bool *isReversed)
{
//  assert(isNormalizedColCentroid);
  myCRS->computeRowAP(r, colCentroid, colCL, rowAP, isReversed);
}


void MssrIIcc::computeColAP(int c)
{
//  assert(isNormalizedRowCentroid);
  myCCS->computeColAP(c, rowCentroid, rowCL, colAP);
}


void MssrIIcc::computeColAP(int c, bool *isReversed)
{
//  assert(isNormalizedRowCentroid);
  myCCS->computeColAP(c, rowCentroid, rowCL, colAP, isReversed);
}


void MssrIIcc::computeObjectiveFunction4Unnormalized()
{
  checkDumpLevel4Cocluster(dumpFile);
  objValue = squaredFNormA - computeQuality4RowCentroidUnnormalized() - computeQuality4ColCentroidUnnormalized() + computeQuality4CompressedUnnormalized();
}


void MssrIIcc::computeObjectiveFunction4Normalized()
{
  checkDumpLevel4Cocluster(dumpFile);
  objValue = squaredFNormA - computeQuality4RowCentroidNormalized() - computeQuality4ColCentroidNormalized() + computeQuality4CompressedNormalized();
}


void MssrIIcc::computeObjectiveFunction4Normalized(double **Acompressed)
{
  checkDumpLevel4Cocluster(dumpFile);
  objValue = myCCS->computeObjectiveFunctionValue(rowCL, colCL, Acompressed, rowCentroid, colCentroid);
}


void MssrIIcc::computeObjectiveFunction4Normalized(double **Acompressed, bool *isReversed)
{
  checkDumpLevel4Cocluster(dumpFile);
  objValue = myCCS->computeObjectiveFunctionValue(rowCL, colCL, Acompressed, rowCentroid, colCentroid, isReversed);
}


void MssrIIcc::computeObjectiveFunction4RowCluster()
{
  // It should be implemented... Currently it's left as it is. ==> Done...
  objValue4RowCluster = myCRS->computeObjectiveFunctionValue4RowCluster(rowCL, rowCentroid);
}


void MssrIIcc::computeObjectiveFunction4ColCluster()
{
  objValue4ColCluster = myCCS->computeObjectiveFunctionValue4ColCluster(colCL, colCentroid);
}


void MssrIIcc::computeRowQuality4Compressed2WayUnnormalized()
{
  double tempValue = 0;
  for (int rc = 0; rc < numRowCluster; rc++)
    rowQuality4Compressed[rc] = 0;
  for (int rc = 0; rc < numRowCluster; rc++)
    if (rowCS[rc] > 0)
      for (int cc = 0; cc < numColCluster; cc++){
        tempValue = Acompressed[rc][cc];
        if (tempValue != 0 && colCS[cc] > 0)
          rowQuality4Compressed[rc] += (tempValue * tempValue) / (rowCS[rc] * colCS[cc]);
      }
}


void MssrIIcc::computeRowQuality4Compressed2WayNormalized()
{
  double tempValue = 0;
  for (int rc = 0; rc < numRowCluster; rc++)
    rowQuality4Compressed[rc] = 0;
  for (int rc = 0; rc < numRowCluster; rc++)
    if (rowCS[rc] > 0)
      for (int cc = 0; cc < numColCluster; cc++){
        tempValue = Acompressed[rc][cc];
        if (tempValue != 0 && colCS[cc] > 0)
          rowQuality4Compressed[rc] += (tempValue * tempValue) * (rowCS[rc] * colCS[cc]);
      }
}


double MssrIIcc::computeRowQuality4Compressed2WayUnnormalized(int rc)
{
  double tempValue = 0, temp = 0;
  if (rowCS[rc] > 0){
    for (int cc = 0; cc < numColCluster; cc++){
      tempValue = Acompressed[rc][cc];
      if (tempValue != 0 && colCS[cc] > 0)
        temp += (tempValue * tempValue) / (rowCS[rc] * colCS[cc]);
    }
  }
  return temp;
}


double MssrIIcc::computeRowQuality4Compressed2WayNormalized(int rc)
{
  double tempValue = 0, temp = 0;
  if (rowCS[rc] > 0){
    for (int cc = 0; cc < numColCluster; cc++){
      tempValue = Acompressed[rc][cc];
      if (tempValue != 0 && colCS[cc] > 0)
        temp += (tempValue * tempValue) * (rowCS[rc] * colCS[cc]);
    }
  }
  return temp;
}


double MssrIIcc::computeRowQuality4Compressed2WayUnnormalized(double *row2Way, int rowClusterSize)
{
  double tempValue = 0, temp = 0;
  if (rowClusterSize > 0){
    for (int cc = 0; cc < numColCluster; cc++){
      tempValue = row2Way[cc];
      if (tempValue != 0 && colCS[cc] > 0)
        temp += (tempValue * tempValue) / (rowClusterSize * colCS[cc]);
    }
  }
  return temp;
}


double MssrIIcc::computeRowQuality4Compressed2WayNormalized(double *row2Way, int rowClusterSize)
{
  double tempValue = 0, temp = 0;
  if (rowClusterSize > 0){
    for (int cc = 0; cc < numColCluster; cc++){
      tempValue = row2Way[cc];
      if (tempValue != 0 && colCS[cc] > 0)
        temp += (tempValue * tempValue) * (rowClusterSize * colCS[cc]);
    }
  }
  return temp;
}


void MssrIIcc::computeColQuality4Compressed2WayUnnormalized()
{
  double tempValue = 0;
  for (int cc = 0; cc < numColCluster; cc++)
    colQuality4Compressed[cc] = 0;
  for (int cc = 0; cc < numColCluster; cc++)
    if (colCS[cc] > 0)
      for (int rc = 0; rc < numRowCluster; rc++){
        tempValue = Acompressed[rc][cc];
        if (tempValue != 0 && rowCS[rc] > 0)
          colQuality4Compressed[cc] += (tempValue * tempValue) / (rowCS[rc] * colCS[cc]);
      }
}


void MssrIIcc::computeColQuality4Compressed2WayNormalized()
{
  double tempValue = 0;
  for (int cc = 0; cc < numColCluster; cc++)
    colQuality4Compressed[cc] = 0;
  for (int cc = 0; cc < numColCluster; cc++)
    if (colCS[cc] > 0)
      for (int rc = 0; rc < numRowCluster; rc++){
        tempValue = Acompressed[rc][cc];
        if (tempValue != 0 && rowCS[rc] > 0)
          colQuality4Compressed[cc] += (tempValue * tempValue) * (rowCS[rc] * colCS[cc]);
      }
}


double MssrIIcc::computeColQuality4Compressed2WayUnnormalized(int cc)
{
  double tempValue = 0, temp = 0;
  if (colCS[cc] > 0){
    for (int rc = 0; rc < numRowCluster; rc++){
      tempValue = Acompressed[rc][cc];
      if (tempValue != 0 && rowCS[rc] > 0)
        temp += (tempValue * tempValue) / (rowCS[rc] * colCS[cc]);
    }
  }
  return temp;
}


double MssrIIcc::computeColQuality4Compressed2WayNormalized(int cc)
{
  double tempValue = 0, temp = 0;
  if (colCS[cc] > 0){
    for (int rc = 0; rc < numRowCluster; rc++){
      tempValue = Acompressed[rc][cc];
      if (tempValue != 0 && rowCS[rc] > 0)
        temp += (tempValue * tempValue) * (rowCS[rc] * colCS[cc]);
    }
  }
  return temp;
}


double MssrIIcc::computeColQuality4Compressed2WayUnnormalized(double *col2Way, int colClusterSize)
{
  double tempValue = 0, temp = 0;
  if (colClusterSize > 0){
    for (int rc = 0; rc < numRowCluster; rc++){
      tempValue = col2Way[rc];
      if (tempValue != 0 && rowCS[rc] > 0)
        temp += (tempValue * tempValue) / (rowCS[rc] * colClusterSize);
    }
  }
  return temp;
}


double MssrIIcc::computeColQuality4Compressed2WayNormalized(double *col2Way, int colClusterSize)
{
  double tempValue = 0, temp = 0;
  if (colClusterSize > 0){
    for (int rc = 0; rc < numRowCluster; rc++){
      tempValue = col2Way[rc];
      if (tempValue != 0 && rowCS[rc] > 0)
        temp += (tempValue * tempValue) * (rowCS[rc] * colClusterSize);
    }
  }
  return temp;
}


double MssrIIcc::computeQuality4CompressedUnnormalized()
{
  double tempValue = 0, temp = 0;
  for (int rc = 0; rc < numRowCluster; rc++)
    if (rowCS[rc] > 0)
      for (int cc = 0; cc < numColCluster; cc++){
        tempValue = Acompressed[rc][cc];
        if (tempValue != 0 && colCS[cc] > 0)
          temp += (tempValue * tempValue) / (rowCS[rc] * colCS[cc]);
      }
  return temp;
}


double MssrIIcc::computeQuality4CompressedNormalized()
{
  double tempValue = 0, temp = 0;
  for (int rc = 0; rc < numRowCluster; rc++)
    if (rowCS[rc] > 0)
      for (int cc = 0; cc < numColCluster; cc++){
        tempValue = Acompressed[rc][cc];
        if (tempValue != 0 && colCS[cc] > 0)
          temp += (tempValue * tempValue) * (rowCS[rc] * colCS[cc]);
      }
  return temp;
}

void MssrIIcc::doRowFarthestInitialization()
{

}

void MssrIIcc::doColFarthestInitialization()
{

}

void MssrIIcc::doRowRandomPerturbInitialization()
{
}

void MssrIIcc::doColRandomPerturbInitialization()
{
}

double MssrIIcc::rowDistance(int r, int rc)
{
  // rowAR contains mR'A - mR'ACC'
//  assert(isNormalizedCompressed);
//  assert(isNormalizedRowCentroid);
//  assert(isNormalizedColCentroid);
  double temp = 0;
  for (int c = 0; c < numCol; c++)
    temp += rowAP[c] * rowAR[rc][c];
  return (-2 * temp + rowQuality4Compressed[rc]);
}


double MssrIIcc::colDistance(int c, int cc)
{
  // colAC contains nAC - nRR'AC.
//  assert(isNormalizedCompressed);
//  assert(isNormalizedRowCentroid);
//  assert(isNormalizedColCentroid);
  double temp = 0;
  for (int r = 0; r < numRow; r++)
    temp += colAP[r] * colAC[cc][r];
  return (-2 * temp + colQuality4Compressed[cc]);
}


void MssrIIcc::reassignRC()
{
  int rowClusterChange = 0;
  int tempRowCL, minCL;
  double tempDistance, minDistance;
  if (rowAR == NULL){
    rowAR = new double*[numRowCluster];
    for (int rc = 0; rc < numRowCluster; rc++)
      rowAR[rc] = new double[numCol];
  }
  computeRowCentroid();			// rowCentroid, in R^(numRowCluster * numCol)
  normalizeRowCentroid();
  computeColCentroid();			// colCentroid, in R^(numRow * numColCluster)
  normalizeColCentroid();
  computeRowAR();			// rowAR = mA^R = mR'A - mR'ACC', in R^(numRowCluster * numCol)
  computeQuality4RowAR();		// rowQuality4Compressed[r] = sum_j(mA^R_rj)^2 = sum_j(m_r^(-1/2) * A^R_rj)^2 

  for (int r = 0; r < numRow; r++){
    tempRowCL = rowCL[r];
    minCL = tempRowCL;
    computeRowAP(r);			// rowAP_i = (A - ACC')_i, in R^(1*numCol)
    minDistance = MY_DBL_MAX;
    for (int rc = 0; rc < numRowCluster; rc++){
      if (rowCS[rc] > 0){
        tempDistance = rowDistance(r, rc); 
        updateVariable(minDistance, minCL, tempDistance, rc);
      }
    }
    if (minCL != tempRowCL)
      rowClusterChange++;
    rowCL[r] = minCL;
  }
  if (rowAR != NULL){
    for (int rc = 0; rc < numRowCluster; rc++)
      delete [] rowAR[rc];
    delete [] rowAR;
    rowAR = NULL;
  }
  checkDumpLevel4NumOfChange("row(s)", rowClusterChange);
}

	
void MssrIIcc::reassignRC(bool *isReversed)
{
  bool tempIsReversed;
  int rowClusterChange = 0;
  int tempRowCL, minCL;
  double tempDistance, minDistance;

  if (rowAR == NULL){
    rowAR = new double*[numRowCluster];