tabledata.cpp

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

    TFileStream *BinaryFile = new TFileStream(FileName, fmCreate);

    BinaryFile->Position = 0;
    
    char Header[6] = "BTD1.0";

    BinaryFile->Write(&Header,sizeof(Header));

    //Now write basic info

    int size;
    char* tempstring;
    tempstring = IDType.c_str();
    size = IDType.Length();
    BinaryFile->Write(&size,sizeof(size));
    BinaryFile->Write(tempstring,size*sizeof(char));

    BinaryFile->Write(&Rows,sizeof(Rows));
    BinaryFile->Write(&Columns,sizeof(Columns));

    for (int row=0; row<Rows; row++)
    {
        RowInfo[row]->WriteToStream(BinaryFile);
    }

    for (int column=0; column<Columns; column++)
    {
        ColumnInfo[column]->WriteToStream(BinaryFile);
    }

    for (int row=0; row<Rows; row++)
    {
        BinaryFile->Write(Data[row],Columns*sizeof(float));
    }

    delete BinaryFile;
}

void __fastcall TTableData::ReadFromBinaryFile(AnsiString FileName)
{

    UpdateUser("Loading Binary File",0);

    // Clean up

    for (int Row=0;Row<Rows;Row++)
    {
        delete Data[Row];
        delete RowInfo[Row];
    }

    for (int Column=0;Column<Columns;Column++)
    {
        delete ColumnInfo[Column];
    }


    delete Data;
    delete RowInfo;
    delete ColumnInfo;

    TFileStream *BinaryFile = new TFileStream(FileName, fmOpenRead);

    BinaryFile->Position = 0;

    char Header[6];
    BinaryFile->Read(&Header,sizeof(Header));

    AnsiString AHeader = AnsiString(Header).SubString(1,6);

    if (AHeader == AnsiString("BTD1.0"))
    {
        int size;
        char *tempstring;
        BinaryFile->Read(&size,sizeof(int));
        tempstring = new char[size];
        BinaryFile->Read(tempstring,size*sizeof(char));
        IDType = AnsiString(tempstring).SubString(1,size);
        delete tempstring;

        BinaryFile->Read(&Rows,sizeof(Rows));
        BinaryFile->Read(&Columns,sizeof(Columns));

        RowInfo = new TTableObjectInfo*[Rows];

        for (int row=0; row<Rows; row++)
        {
            RowInfo[row] = new TTableObjectInfo();
            RowInfo[row]->ReadFromStream(BinaryFile);
        }

        ColumnInfo = new TTableObjectInfo*[Columns];

        for (int col=0; col<Columns; col++)
        {
            ColumnInfo[col] = new TTableObjectInfo();
            ColumnInfo[col]->ReadFromStream(BinaryFile);
        }

        Data    = new float*[Rows];

        for (int row=0; row<Rows; row++)
        {
            UpdateUser("Loading Row " + AnsiString(row) + " of " + AnsiString(Rows),1);
            Data[row] = new float[Columns];
            BinaryFile->Read(Data[row],Columns*sizeof(float));
        }
    }

    delete BinaryFile;
}


void __fastcall TTableData::CopyFrom(TTableData *CopyData)
{
    // Clear old Data

    for (int Row=0;Row<Rows;Row++)
    {
        delete Data[Row];
        delete RowInfo[Row];
    }

    for (int Column=0;Column<Columns;Column++)
    {
        delete ColumnInfo[Column];
    }

    delete Data;
    delete RowInfo;
    delete ColumnInfo;

    Columns = CopyData->Columns;
    ColumnInfo = new TTableObjectInfo*[Columns];

    for (int Column=0; Column<Columns; Column++)
    {
        ColumnInfo[Column] = new TTableObjectInfo();
        ColumnInfo[Column]->ID = CopyData->ColumnInfo[Column]->ID;
    }

    Rows = CopyData->Rows;
    Data    = new float*[Rows];
    RowInfo = new TTableObjectInfo*[Rows];

    for (int Row=0; Row<Rows; Row++)
    {
        RowInfo[Row] = new TTableObjectInfo();
        RowInfo[Row]->ID = CopyData->RowInfo[Row]->ID;

        Data[Row] = new float[Columns];

        for (int Column=0; Column<Columns; Column++)
        {
            Data[Row][Column] = CopyData->Data[Row][Column];
        }
    }
}

void __fastcall TTableData::CopyFromRowList(TTableData *CopyData, std::vector<int> List)
{
    // Clear old Data

    for (int Row=0;Row<Rows;Row++)
    {
        delete Data[Row];
        delete RowInfo[Row];
    }

    for (int Column=0;Column<Columns;Column++)
    {
        delete ColumnInfo[Column];
    }

    delete Data;
    delete RowInfo;
    delete ColumnInfo;

    Columns = CopyData->Columns;
    ColumnInfo = new TTableObjectInfo*[Columns];

    for (int Column=0; Column<Columns; Column++)
    {
        ColumnInfo[Column] = new TTableObjectInfo();
        ColumnInfo[Column]->ID = CopyData->ColumnInfo[Column]->ID;
    }

    Rows = List.size();
    Data    = new float*[Rows];
    RowInfo = new TTableObjectInfo*[Rows];

    for (int Row=0; Row<Rows; Row++)
    {
        RowInfo[Row] = new TTableObjectInfo();
        RowInfo[Row]->ID = CopyData->RowInfo[Row]->ID;

        Data[Row] = new float[Columns];

        for (int Column=0; Column<Columns; Column++)
        {
            Data[Row][Column] = CopyData->Data[List[Row]][Column];
        }
    }
}

void __fastcall TTableData::CopyTransposedFrom(TTableData *CopyData)
{
    // Clear old Data

    for (int Row=0;Row<Rows;Row++)
    {
        delete Data[Row];
        delete RowInfo[Row];
    }

    for (int Column=0;Column<Columns;Column++)
    {
        delete ColumnInfo[Column];
    }

    delete Data;
    delete RowInfo;
    delete ColumnInfo;

    Columns = CopyData->Rows;
    ColumnInfo = new TTableObjectInfo*[Columns];

    for (int Column=0; Column<Columns; Column++)
    {
        ColumnInfo[Column] = new TTableObjectInfo();
        ColumnInfo[Column]->ID = CopyData->RowInfo[Column]->ID;
    }

    Rows = CopyData->Columns;
    Data    = new float*[Rows];
    RowInfo = new TTableObjectInfo*[Rows];

    for (int Row=0; Row<Rows; Row++)
    {
        RowInfo[Row] = new TTableObjectInfo();
        RowInfo[Row]->ID = CopyData->ColumnInfo[Row]->ID;

        Data[Row] = new float[Columns];

        for (int Column=0; Column<Columns; Column++)
        {
            Data[Row][Column] = CopyData->Data[Column][Row];
        }
    }
}


void __fastcall TTableData::MeanCenterRows()
{
    for (int row=0; row<Rows; row++)
    {
        float sum = 0;
        int count = 0;

        for (int col=0; col<Columns; col++)
        {
            if (Data[row][col] != NODATA)
            {
                sum+=Data[row][col];
                count++;
            }
        }

        if (count > 0)
        {
            sum /= count;
        }

        for (int col=0; col<Columns; col++)
        {
            if (Data[row][col] != NODATA)
            {
                Data[row][col] -= sum;
            }
        }
    }
}

void __fastcall TTableData::NormalizeRows()
{
    for (int row=0; row<Rows; row++)
    {
        float mag = 0;
        int magcount = 0;

        for (int col=0; col<Columns; col++)
        {
            if (Data[row][col] != NODATA)
            {
                mag+=pow(Data[row][col],2.0);
                magcount++;
            }
        }

        mag = sqrt(mag);

        if (mag > 0)
        {
            for (int col=0; col<Columns; col++)
            {
                if (Data[row][col] != NODATA)
                {
                    Data[row][col] /= mag;
                }
            }
        }
    }
}


/* Randomly permute data within rows. This could probably be
recoded with a direct sort of Data[Row] but when I did this the first
time things got really messed up */

void __fastcall TTableData::PermuteInRows()
{
    float* randvector = fvector(1,Columns);
    float *datavector = fvector(1,Columns);

    for (int Row=0; Row<Rows; Row++)
    {
        for (int Column=0; Column<Columns; Column++)
        {
            randvector[Column+1] = rand();
            datavector[Column+1] = Data[Row][Column];
        }

        sort2(Columns,randvector,datavector);

        for (int Column=0; Column<Columns; Column++)
        {
            Data[Row][Column] = datavector[Column+1];
        }
    }

    free_vector(randvector,1,Columns);
    free_vector(datavector,1,Columns);  
}

void __fastcall TTableData::OrthogonalizeRow(int row, float *Vector)
{

        float dot = 0;

        for (int col=0; col<Columns; col++)
        {
            if ( (Vector[col] != NODATA) && (Data[row][col] != NODATA) )
            {
                dot += Vector[col] * Data[row][col];
            }
        }

        for (int col=0; col<Columns; col++)
        {
            if ( (Vector[col] != NODATA) && (Data[row][col] != NODATA) )
            {
                Data[row][col] -= dot * Vector[col];
            }
        }
}

/* Orthogonalize all rows relative to a given vector */

void __fastcall TTableData::OrthogonalizeRows(float *Vector)
{

    float mag=0;

    for (int col=0; col<Columns; col++)
    {
        if (Vector[col] != NODATA)
        {
            mag += pow(Vector[col],2.0);
        }
    }

    mag = sqrt(mag);

    float* NormVector = new float[Columns];

    for (int col=0; col<Columns; col++)
    {
       NormVector[col] = Vector[col];
       if ( (mag > 0) && (NormVector[col] != NODATA) )
       {
           NormVector[col] /= mag;
       }
    }

    for (int row=0; row<Rows; row++)
    {
        OrthogonalizeRow(row,NormVector);
    }

    delete NormVector;
}

void __fastcall TTableData::OrthogonalizeRowList(float *Vector, int *List, int n)
{
    float mag=0;

    for (int col=0; col<Columns; col++)
    {
        if (Vector[col] != NODATA)
        {
            mag += pow(Vector[col],2.0);
        }
    }

    mag = sqrt(mag);

    float* NormVector = new float[Columns];

    for (int col=0; col<Columns; col++)
    {
       NormVector[col] = Vector[col];
       if ( (mag > 0) && (NormVector[col] != NODATA) )
       {
           NormVector[col] /= mag;
       }
    }

    for (int elem=0; elem<n; elem++)
    {
        if (List[elem] < Rows)
        {
            OrthogonalizeRow(List[elem],NormVector);
        }
    }

    delete NormVector;
}
// This function returns a pointer to an array with data for a row

float * __fastcall TTableData::RowData(int Row)
{
    float * Tmp = NULL;

    if ( (0 <= Row) && (Row < Rows) )
    {
        try
        {
            Tmp = Data[Row];
        }
        catch (Exception &E)
        {
            Tmp = NULL;
        }
    }

    return Tmp;
}

void __fastcall TTableData::RowAve(float *AveData)
{

    for (int col=0; col<Columns; col++)
    {
        AveData[col] = 0;
        int k = 0;

        for (int i=0; i<Rows; i++)
        {
            if (Data[i][col] != NODATA)
            {
                AveData[col] += Data[i][col];
                k++;
            }

        }

        if (k > 0)
        {
            AveData[col] /= k;
        }
    }
}

void __fastcall TTableData::RowListAve(int *List, int n, float *AveData)
{

    for (int col=0; col<Columns; col++)
    {
        AveData[col] = 0;
        int k = 0;

        for (int i=0; i<n; i++)
        {
            if (Data[List[i]][col] != NODATA)
            {
                AveData[col] += Data[List[i]][col];
                k++;
            }

        }

        if (k > 0)
        {
            AveData[col] /= k;
        }
    }
}

float __fastcall TTableData::Variance()
{

    int k=0;
    double sum2 = 0;

    for (int col=0; col<Columns; col++)
    {
        for (int row=0; row<Rows; row++)
        {
            if (Data[row][col] != NODATA)
            {
                sum2 += pow(Data[row][col],2.0);
                k++;
            }

        }
    }

    if (k>0)
    {
        return (sqrt(sum2/k));
    }
    else
    {
        return 0;
    }
}

std::vector<int> __fastcall TTableData::GroupList(int Group)
{
    std::vector<int> List;

    for (int row=0; row<Rows; row++)
    {
        if (RowInfo[row]->Group == Group)
        {
            List.push_back(row);
        }
    }

    return List;
}

AnsiString __fastcall TTableData::RawRowString(int Row)
{

    try
    {
        return RowDataInfoToString(Data[Row], Columns, RowInfo[Row]);
    }
    catch (Exception &E)
    {
        return "";
    }
}

AnsiString __fastcall TTableData::RawHeader()
{
    AnsiString Tmp = "";

    Tmp = IDType + "\tNAME\tGWEIGHT";

    for (int Col=0; Col<Columns; Col++)
    {
        Tmp += "\t" + ColumnInfo[Col]->ID;
    }
    return Tmp;
}