clustermain.cpp

著名的基因芯片表达数据聚类软件。esein编写

             TempMask[Row][Column] = GeneMask[Row][Column];
         }

         TempID[Row]     = UniqID[Row];
         TempName[Row]   = GeneName[Row];
         TempOrder[Row]  = GeneOrder[Row];
         TempWeight[Row] = GeneWeight[Row];
    }


    for (int Row=0;Row<Rows;Row++)
    {
         delete GeneData[Row];
         delete GeneMask[Row];
         UniqID[Row] = "";
         GeneName[Row] = "";
    }

    delete GeneData;
    delete GeneMask;
    delete UniqID;
    delete GeneName;
    delete GeneOrder;
    delete GeneWeight;

    UniqID      = new AnsiString[2*UseRows-1];
    GeneName    = new AnsiString[2*UseRows-1];
    GeneOrder   = new double[2*UseRows-1];
    GeneWeight  = new double[2*UseRows-1];
    GeneData    = new double*[2*UseRows-1];
    GeneMask    = new bool*[2*UseRows-1];

    for (int Row=0;Row<2*UseRows-1;Row++)
    {
        GeneData[Row] = new double[Columns];
        GeneMask[Row] = new bool[Columns];
    }

    int Counter = 0;

    for (int Row=0;Row<Rows;Row++)
    {
         if (Use[Row])
         {
            for (int Column=0;Column<Columns;Column++)
            {
                GeneData[Counter][Column] = TempData[Row][Column];
                GeneMask[Counter][Column] = TempMask[Row][Column];
            }

            UniqID[Counter]       = TempID[Row];
            GeneName[Counter]     = TempName[Row];
            GeneOrder[Counter]    = TempOrder[Row];
            GeneWeight[Counter]   = TempWeight[Row];

            Counter++;
         }
    }


    for (int Row=0;Row<Rows;Row++)
    {
        delete TempData[Row];
        delete TempMask[Row];
        TempName[Row] = "";
        TempID[Row] = "";
    }

    delete TempData;
    delete TempMask;
    delete TempID;
    delete TempName;
    delete TempOrder;
    delete TempWeight;

    Rows = Counter;

    /* Update SOM defaults to reflect new number of rows */

    SOMGenesYDim = 1 + sqrt((double)Rows);
    SOMGenesYDimEdit->Text = SOMGenesYDim;

    SOMArraysYDim = 1 + sqrt((double)Columns);
    SOMArraysYDimEdit->Text = SOMArraysYDim;

}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

void __fastcall TMainForm::FilterPercentEditExit(TObject *Sender)
{
        double TempVal = FilterPercentVal;

        try
        {
                FilterPercentVal = FilterPercentEdit->Text.ToDouble();
        }
        catch (EConvertError &E)
        {
                FilterPercentVal = TempVal;
                FilterPercentEdit->Text =  FilterPercentVal;
        }
}
//---------------------------------------------------------------------------



void __fastcall TMainForm::FilterSDEditExit(TObject *Sender)
{
        double TempVal = FilterSDVal;

        try
        {
                FilterSDVal = FilterSDEdit->Text.ToDouble();
        }
        catch (EConvertError &E)
        {
                FilterSDVal = TempVal;
                FilterSDEdit->Text =  FilterSDVal;
        }
}
//---------------------------------------------------------------------------

void __fastcall TMainForm::FilterAbsValCountEditExit(TObject *Sender)
{
        int TempVal = FilterAbsValCount;

        try
        {
                FilterAbsValCount = FilterAbsValCountEdit->Text.ToDouble();
        }
        catch (EConvertError &E)
        {
                FilterAbsValCount = TempVal;
                FilterAbsValCountEdit->Text =  FilterAbsValCount;
        }
}
//---------------------------------------------------------------------------

void __fastcall TMainForm::FilterAbsValEditExit(TObject *Sender)
{
        double TempVal = FilterAbsValVal;

        try
        {
                FilterAbsValVal = FilterAbsValEdit->Text.ToDouble();
        }
        catch (EConvertError &E)
        {
                FilterAbsValVal = TempVal;
                FilterAbsValEdit->Text =  FilterAbsValVal;
        }
}
//---------------------------------------------------------------------------

void __fastcall TMainForm::FilterMaxMinEditExit(TObject *Sender)
{
        double TempVal = FilterMaxMinVal;

        try
        {
                FilterMaxMinVal = FilterMaxMinEdit->Text.ToDouble();
        }
        catch (EConvertError &E)
        {
                FilterMaxMinVal = TempVal;
                FilterMaxMinEdit->Text =  FilterMaxMinVal;
        }
}
//---------------------------------------------------------------------------

/* Adjust data values in various ways */

void __fastcall TMainForm::AdjustDataButtonClick(TObject *Sender)
{

    for (int Row=0; Row<Rows; Row++)
    {
        StatusBar1->SimpleText = "Adjusting Data for Gene " + AnsiString(Row+1)
            + " of " + AnsiString(Rows);

        float *DataPoints = vector(1,Columns);
        int CountDataPoints = 0;
        float DataSum = 0;

        for (int Column=0;Column<Columns;Column++)
        {
            if ( LogTransformCheckBox->Checked && GeneMask[Row][Column] )
            {
                if (GeneData[Row][Column] > 0)
                {
                    GeneData[Row][Column] = log(GeneData[Row][Column])/log(2);
                }
                else
                {
                    GeneMask[Row][Column] = 0;
                }
            }

            if (GeneMask[Row][Column])
            {
                CountDataPoints++;
                DataPoints[CountDataPoints] = GeneData[Row][Column];
                DataSum += GeneData[Row][Column];
            }
        }

        if (MeanCenterGenesCheckBox->Checked)
        {
            if (CountDataPoints > 0)
            {
                float DataMean = DataSum / (float) CountDataPoints;

                for (int Column=0;Column<Columns;Column++)
                {
                    GeneData[Row][Column] -= DataMean;
                }
            }
        }
        else if (MedianCenterGenesCheckBox->Checked)
        {
            float Median;

            if (CountDataPoints > 1)
            {
                if ( (CountDataPoints % 2) == 0)
                {
                    Median = 0.5 * ( select((CountDataPoints/2),CountDataPoints,DataPoints)
                    + select(1+(CountDataPoints/2),CountDataPoints,DataPoints));
                }
                else
                {
                    Median = select(((CountDataPoints+1)/2),CountDataPoints,DataPoints);
                }

            }
            else if (CountDataPoints == 1)
            {
                Median = DataPoints[0];
            }

            for (int Column=0;Column<Columns;Column++)
            {
                if (GeneMask[Row][Column])
                {
                    GeneData[Row][Column] -= Median;
                }
            }
        }

        if (NormalizeGenesCheckBox->Checked)
        {
            float DataSum2 = 0;

            for (int Column=0;Column<Columns;Column++)
            {
                if (GeneMask[Row][Column])
                {
                    DataSum2 += pow(GeneData[Row][Column],2);
                }
            }

            float DataMag = sqrt(DataSum2);

            if (DataMag > 0)
            {
                for (int Column=0;Column<Columns;Column++)
                {
                    if (GeneMask[Row][Column])
                    {
                        GeneData[Row][Column] /= DataMag;
                    }
                }
            }
        }

        free_vector(DataPoints,1,Columns);
     }

    for (int Column=0; Column<Columns; Column++)
    {
        StatusBar1->SimpleText = "Adjusting Data for Sample " + AnsiString(Column+1)
            + " of " + AnsiString(Columns);

        float *DataPoints = vector(1,Rows);
        int CountDataPoints = 0;
        float DataSum = 0;

        for (int Row=0;Row<Rows;Row++)
        {
            if (GeneMask[Row][Column])
            {
                CountDataPoints++;
                DataPoints[CountDataPoints] = GeneData[Row][Column];
                DataSum += GeneData[Row][Column];
            }
        }

        if (MeanCenterArraysCheckBox->Checked)
        {
            if (CountDataPoints > 0)
            {
                float DataMean = DataSum / (float) CountDataPoints;

                for (int Row=0;Row<Rows;Row++)
                {
                    GeneData[Row][Column] -= DataMean;
                }
            }
        }
        else if (MedianCenterArraysCheckBox->Checked)
        {
            float Median;

            if (CountDataPoints > 1)
            {
                if ( (CountDataPoints % 2) == 0)
                {
                    Median = 0.5 * ( select((CountDataPoints/2),CountDataPoints,DataPoints)
                    + select(1+(CountDataPoints/2),CountDataPoints,DataPoints));
                }
                else
                {
                    Median = select(((CountDataPoints+1)/2),CountDataPoints,DataPoints);
                }

            }
            else if (CountDataPoints == 1)
            {
                Median = DataPoints[0];
            }

            for (int Row=0;Row<Rows;Row++)
            {
                if (GeneMask[Row][Column])
                {
                    GeneData[Row][Column] -= Median;
                }
            }
        }

        if (NormalizeArraysCheckBox->Checked)
        {
            float DataSum2 = 0;

            for (int Row=0;Row<Rows;Row++)
            {
                if (GeneMask[Row][Column])
                {
                    DataSum2 += pow(GeneData[Row][Column],2);
                }
            }

            float DataMag = sqrt(DataSum2);

            if (DataMag > 0)
            {
                for (int Row=0;Row<Rows;Row++)
                {
                    if (GeneMask[Row][Column])
                    {
                        GeneData[Row][Column] /= DataMag;
                    }
                }
            }
        }

        free_vector(DataPoints,1,Rows);
     }

     StatusBar1->SimpleText = "Done Adjusting Data";
}

/* Distance Functions for Clustering */

/* Old Function that returns only Pearson Correlation */

unsigned short TMainForm::Distance(double **Data, bool **Mask, double *Weight,
    bool Centered, bool Absolute, int elem1, int elem2, int DataColumns)
{
    return Correlation(Data,Mask,Weight,Centered,Absolute,elem1,elem2,DataColumns);
}

unsigned short TMainForm::Distance(int Metric, double **Data, bool **Mask, double *Weight,
    int elem1, int elem2, int DataColumns)
{
    int i;
    int k;
    float *Vector1;
    float *Vector2;
    float d,zd,probd,rs,probrs;
    float tau, tauz, taup;

    switch (Metric)
    {
        /* Uncentered correlation */
        case 0:
        default:

            return Correlation(Data,Mask,Weight,false,false,elem1,elem2,DataColumns);
            break;

        case 2:

            return Correlation(Data,Mask,Weight,false,true,elem1,elem2,DataColumns);
            break;

        /* Centered correlation */
        case 1:

            return Correlation(Data,Mask,Weight,true,false,elem1,elem2,DataColumns);
            break;

        case 3:

            return Correlation(Data,Mask,Weight,true,true,elem1,elem2,DataColumns);
            break;

        /* Euclidean distance */
        //case 4:

        /* Spearman Rank */

        case 4:

            rs = 0;

#ifdef NUMREC

            Vector1 = vector(1,DataColumns);
            Vector2 = vector(1,DataColumns);

            k=0;

            for (i=0; i<DataColumns; i++)
            {
                if ( (Mask[elem1][i] == true) && (Mask[elem2][i] == true) )
                {
                    k++;
                    Vector1[k] = Data[elem1][i];
                    Vector2[k] = Data[elem2][i];
                }
            }

            if (k > 1)
            {
                spear(Vector1,Vector2,k,&d,&zd,&probd,&rs,&probrs);
            }
            else
            {
                rs = 0;
            }

            free_vector(Vector1,1,DataColumns);
            free_vector(Vector2,1,DataColumns);

#endif

            return (unsigned short) (16384.0 * (1.0 - rs));
            break;

        /* Kendall's Tau */
        case 5:

            k = 0;

            tau = 0;

#ifdef NUMREC

            Vector1 = vector(1,DataColumns);
            Vector2 = vector(1,DataColumns);