开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
ClusterMain.cpp
资源名称：ClusterTreeViewCode.zip　[点击查看]
上传用户：szb0815
上传日期：2007-06-13
资源大小：338k
文件大小：150k
源码类别：

生物技术

开发平台：

C++ Builder

ClusterMain.cpp：源码内容
  1.                 if (Dist[i][j] < minval[i])
  2.                 {
  3.                     minval[i] = Dist[i][j];
  4.                     minpair[i] = j;
  5.                 }
  7.                 if (Dist[i][j] < minval[j])
  8.                 {
  9.                     minval[j] = Dist[i][j];
  10.                     minpair[j] = i;
  11.                 }
  12.             }
  13.             StatusBar->SimpleText = "Calculating Distances " + AnsiString(i*(i+1)/2) + " of "
  14.                 + AnsiString(TotalDistance);
  15.             Application->ProcessMessages();
  16.         }
  18.         TStringList *MinList = new TStringList();
  20.         for (i=0;i<ClusterRows;i++)
  21.         {
  22.             MinList->Add(AnsiString(minval[i]));
  23.         }
  25.         MinList->SaveToFile("minlist.txt");
  27.         delete MinList;
  29.         bool *Active;
  30.         Active = new bool[2*ClusterRows-1];
  32.         for (i=0;i<ClusterRows;i++)
  33.         {
  34.             Active[i] = true;
  35.         }
  37.         for (i=ClusterRows;i<2*ClusterRows-1;i++)
  38.         {
  39.             Active[i] = false;
  40.         }
  42.         unsigned short minminval;
  44.         int min1, min2;
  46.         int nodeindex;
  48.         //int node;
  50.         /* Now we join nodes */
  52.         /* If we are going to return TNode, need to set up TNodes */
  54.         TNode **Nodes;
  55.         if (ReturnTNode)
  56.         {
  57.            Nodes = new TNode*[2*ClusterRows-1];
  59.            for (i=0;i<2*ClusterRows-1;i++)
  60.            {
  61.                Nodes[i] = new TNode();
  63.                if (i < ClusterRows)
  64.                {
  65.                    Nodes[i]->IsNode = false;
  66.                    Nodes[i]->ID = AnsiString(i);
  67.                }
  68.                else
  69.                {
  70.                    Nodes[i]->IsNode = true;
  71.                }
  72.            }
  73.         }
  75.         for (nodeindex=ClusterRows; nodeindex<2*ClusterRows-1;nodeindex++)
  77.         {
  78.             ID[nodeindex] = "NODE" + AnsiString(nodeindex-ClusterRows+1) + "X";
  80.             minminval = 32769;
  82.             for (i=0;i<2*ClusterRows-1;i++)
  83.             {
  84.                 if (Active[i] == true)
  85.                 {
  86.                     if (minval[i] < minminval)
  87.                     {
  88.                         minminval = minval[i];
  89.                         min1 = i;
  90.                         min2 = minpair[i];
  91.                     }
  92.                 }
  93.             }
  95.             /* When we get here min1 and min2 are the elements that are to be joined */
  98.         Active[min1] = false;
  99.         Active[min2] = false;
  101.         if (Order[min1] > Order[min2])
  102.         {
  103.             NodeElement[nodeindex][0] = min1;
  104.             NodeElement[nodeindex][1] = min2;
  105.         }
  106.         else
  107.         {
  108.             NodeElement[nodeindex][1] = min1;
  109.             NodeElement[nodeindex][0] = min2;
  110.         }
  112.         NodeDistance[nodeindex] = ((double) minminval)/16384.0;
  113.         NodeDistance[nodeindex] = max(NodeDistance[nodeindex],NodeDistance[min1]);
  114.         NodeDistance[nodeindex] = max(NodeDistance[nodeindex],NodeDistance[min2]);
  116.         if (ReturnTNode)
  117.         {
  118.                Nodes[nodeindex]->Child1 = Nodes[NodeElement[nodeindex][0]];
  119.                Nodes[nodeindex]->Child2 = Nodes[NodeElement[nodeindex][1]];
  120.                Nodes[nodeindex]->Length = 1.0 - NodeDistance[nodeindex];
  121.         }
  123.         if (CalcInferredDistances == true)
  124.         {
  125.             int elem1,elem2,ielem1,ielem2;
  127.             for (elem1=0;elem1<MemberList[min1]->Count;elem1++)
  128.             {
  129.                 for (elem2=0;elem2<MemberList[min2]->Count;elem2++)
  130.                 {
  131.                     ielem1 = (MemberList[min1]->Strings[elem1]).ToInt();
  132.                     ielem2 = (MemberList[min2]->Strings[elem2]).ToInt();
  133.                     TreeDist[ielem1][ielem2] = (NodeDistance[nodeindex] * 16384);
  134.                     TreeDist[ielem2][ielem1] = (NodeDistance[nodeindex] * 16384);
  135.                 }
  136.             }
  138.             MemberList[nodeindex]->AddStrings(MemberList[min1]);
  139.             MemberList[nodeindex]->AddStrings(MemberList[min2]);
  141.             delete MemberList[min1];
  142.             delete MemberList[min2];
  143.         }
  145.         OutString = ID[nodeindex] + AnsiString("t") + ID[NodeElement[nodeindex][0]]
  146.                 + AnsiString("t") + ID[NodeElement[nodeindex][1]] + AnsiString("t")
  147.                 + AnsiString(1.0 - NodeDistance[nodeindex]);
  149.         TreeFile->Add(OutString);
  151.         StatusBar->SimpleText = "Generating Node " + AnsiString(nodeindex-ClusterRows+1) + " of " + AnsiString(ClusterRows-1);
  152.         Application->ProcessMessages();
  154.         elements[nodeindex] = elements[min1] + elements[min2];
  156.         for (k=0;k<ClusterColumns;k++)
  157.         {
  158.             if ( (ClusterMask[min1][k] == true) && (ClusterMask[min2][k] == true) )
  159.             {
  160.                 ClusterData[nodeindex][k] =
  161.                     (elements[min1] * ClusterData[min1][k] +
  162.                         elements[min2] * ClusterData[min2][k]) /
  163.                     (elements[min1] + elements[min2]);
  164.                 ClusterMask[nodeindex][k] = true;
  165.             }
  166.             else if (ClusterMask[min1][k] == true)
  167.             {
  168.                 ClusterData[nodeindex][k] = ClusterData[min1][k];
  169.                 ClusterMask[nodeindex][k] = true;
  170.             }
  171.             else if (ClusterMask[min2][k] == true)
  172.             {
  173.                 ClusterData[nodeindex][k] = ClusterData[min2][k];
  174.                 ClusterMask[nodeindex][k] = true;
  175.             }
  176.             else
  177.             {
  178.                 ClusterMask[nodeindex][k] = false;
  179.             }
  180.         }
  182.         Order[nodeindex] = (elements[min1]*Order[min1] + elements[min2]*Order[min2])/(elements[min1] + elements[min2]);
  183.         Dist[nodeindex] = new unsigned short[2*ClusterRows-1];
  185.         if (SaveDistances == false)
  186.         {
  187.             delete Dist[min1];
  188.             delete Dist[min2];
  189.         }
  191.         List1->Clear();
  192.         Nodes[nodeindex]->SetList(List1);
  194.         int NumList1 = List1->Count;
  196.         for (int i1=0;i1<NumList1;i1++)
  197.         {
  198.             iList1[i1] = List1->Strings[i1].ToInt();
  199.         }
  202.         for (l=0;l<2*ClusterRows-1;l++)
  203.         {
  204.             if (Active[l] == true)
  205.             {
  207.                 // OK. Here's where it gets tricky
  209.                 List2->Clear();
  211.                 if (l < ClusterRows)
  212.                 {
  213.                     List2->Add(AnsiString(l));
  214.                 }
  215.                 else
  216.                 {
  217.                     Nodes[l]->SetList(List2);
  218.                 }
  220.                 int NumList2 = List2->Count;
  222.                 for (int i2=0;i2<NumList2;i2++)
  223.                 {
  224.                     iList2[i2] = List2->Strings[i2].ToInt();
  225.                 }
  228.                 Dist[nodeindex][l] = 0;
  230.                 for (int i1=0; i1 < NumList1; i1++)
  231.                 {
  232.                     for (int i2=0; i2 < NumList2; i2++)
  233.                     {
  234.                          Dist[nodeindex][l] = max(Dist[nodeindex][l],Dist[iList1[i1]][iList2[i2]]);
  235.                     }
  236.                 }
  238.                 Dist[l][nodeindex] = Dist[nodeindex][l];
  240.                 if (Dist[nodeindex][l] < minval[nodeindex])
  241.                 {
  242.                     minval[nodeindex] = Dist[nodeindex][l];
  243.                     minpair[nodeindex] = l;
  244.                 }
  246.                 //Rescan for min if minpair was one of the fused elements
  248.                 if ( (minpair[l] == min1) || (minpair[l] == min2) )
  249.                 {
  250.                     minval[l] = 32769;
  252.                     for (m=0;m<2*ClusterRows-1;m++)
  253.                     {
  254.                         if ( (Active[m] == true) && (l != m) )
  255.                         {
  256.                             if (Dist[l][m] < minval[l])
  257.                             {
  258.                                 minval[l] = Dist[l][m];
  259.                                 minpair[l] = m;
  260.                             }
  261.                         }
  262.                     }
  263.                 }
  265.                 //otherwise check new distance to see if it is new min
  267.                 else if (Dist[nodeindex][l] < minval[l])
  268.                 {
  269.                     minval[l] = Dist[nodeindex][l];
  270.                     minpair[l] = nodeindex;
  271.                 }
  272.             }
  273.         }
  275.         Active[nodeindex] = true;
  276.         }
  278.         if (SaveDistances == false)
  279.         {
  280.             delete Dist[2*ClusterRows-2];
  281.         }
  283.         TList *NewList = new TList();
  284.         TList *OutList = new TList();
  286.         int **Elements;
  287.         Elements = new int*[2*ClusterRows-1];
  288.         for (i=0;i<2*ClusterRows-1;i++)
  289.         {
  290.             Elements[i] = new int;
  291.             *Elements[i] = i;
  292.         }
  294.         OutList->Clear();
  296.         OutList->Add((void *)Elements[2*ClusterRows-2]);
  298.         int Position;
  300.         bool Replaced;
  302.         Replaced = true;
  304.         while (Replaced == true)
  305.         {
  306.             Replaced = false;
  308.             for (Position = 0; Position < OutList->Count; Position ++)
  309.             {
  310.                 nodeindex =  *(int *) OutList->Items[Position];
  311.                 if (nodeindex >= 0)
  312.                 {
  313.                     if (nodeindex < ClusterRows)
  314.                     {
  315.                         NewList->Add((void *) Elements[nodeindex]);
  316.                     }
  317.                     else
  318.                     {
  319.                         element1 =  NodeElement[nodeindex][0];
  320.                         element2 =  NodeElement[nodeindex][1];
  322.                         NewList->Add((void *) Elements[element1]);
  323.                         NewList->Add((void *) Elements[element2]);
  325.                         Replaced = true;
  326.                     }
  327.                 }
  328.             }
  330.             OutList->Clear();
  331.             for (i=0;i<NewList->Count;i++)
  332.             {
  333.                 OutList->Add(NewList->Items[i]);
  334.             }
  335.             NewList->Clear();
  336.         }
  338.         int index;
  340.         ClusterOrder->Clear();
  342.         if (SaveDistances == true)
  343.         {
  345.             /*
  346.             if (DistFileDialogBox->Execute())
  347.             {
  349.                 TFileStream *DistFile = new TFileStream(DistFileDialogBox->FileName,fmCreate);
  351.                 int ii, ij;
  353.                 for (i=0;i<OutList->Count;i++)
  354.                 {
  355.                     ii = *(int *)OutList->Items[i];
  356.                     for (j=0;j<OutList->Count;j++)
  357.                     {
  358.                         {
  359.                             ij = *(int *)OutList->Items[j];
  360.                             DistFile->Write(&Dist[ii][ij],2);
  361.                         }
  362.                     }
  363.                 }
  364.                 delete DistFile;
  367.             } */
  369.             for (i=0;i<2*ClusterRows-1;i++)
  370.                 {
  371.                     delete Dist[i];
  372.                 }
  373.         }
  375.         if (CalcInferredDistances == true)
  376.         {
  377.             if (DistFileDialogBox->Execute())
  378.             {
  380.                 TFileStream *DistFile = new TFileStream(DistFileDialogBox->FileName,fmCreate);
  382.                 int ii, ij;
  384.                 for (i=0;i<OutList->Count;i++)
  385.                 {
  386.                     ii = *(int *)OutList->Items[i];
  387.                     for (j=0;j<OutList->Count;j++)
  388.                     {
  389.                         {
  390.                             ij = *(int *)OutList->Items[j];
  391.                             DistFile->Write(&TreeDist[ii][ij],2);
  392.                         }
  393.                     }
  394.                 }
  396.                 delete DistFile;
  398.                 for (i=0;i<ClusterRows;i++)
  399.                 {
  400.                     delete TreeDist[i];
  401.                 }
  402.             }
  404.             delete TreeDist;
  405.         }
  407.         for (i=0;i<OutList->Count;i++)
  408.         {
  409.             index = *(int *)OutList->Items[i];
  410.             ClusterOrder->Add(index);
  411.         }
  413.         for (i=0;i<2*ClusterRows-1;i++)
  414.         {
  415.             delete NodeElement[i];
  416.             delete Elements[i];
  417.         }
  419.         if (CalculateWeights == true)
  420.         {
  421.             for (i=0;i<ClusterRows;i++)
  422.             {
  423.                 RowWeight[i] = 1/CalcWeight[i];
  424.             }
  425.         }
  427.         delete Dist;
  428.         delete NodeElement;
  429.         delete Elements;
  430.         delete NodeDistance;
  431.         delete elements;
  432.         delete minval;
  433.         delete minpair;
  434.         delete NewList;
  435.         delete OutList;
  436.         delete Active;
  437.         delete CalcWeight;
  439.         delete iList1;
  440.         delete iList2;
  441.         delete List1;
  442.         delete List2;
  443. }
  445. void __fastcall TMainForm::SingleLinkageClusterButtonClick(TObject *Sender)
  446. {
  447.     int i,j;
  448.     StatusBar1->SimpleText = "Initializing";
  450.     // Get ClusterID for file names from user input
  452.     JobName = AnsiString(ClusterName);
  454.     if (JobNameEdit->Text.Length() > 0)
  455.     {
  456.         JobName = JobNameEdit->Text;
  457.     }
  459.     bool ClusterGenes = ClusterGenesCheckBox->Checked;
  460.     bool ClusterArrays = ClusterArraysCheckBox->Checked;
  461.     bool CalculateGeneWeights = CalculateGeneWeightsCheckBox->Checked;
  462.     bool CalculateArrayWeights = CalculateArrayWeightsCheckBox->Checked;
  464.     int *ColumnOrder = new int[Columns];
  465.     AnsiString *ArrayID = new AnsiString[2*Columns-1];
  467.     for (i=0;i<Columns;i++)
  468.     {
  469.         ColumnOrder[i] = i;
  470.         ArrayID[i] = "ARRY" + AnsiString(i) + "X";
  471.     }
  473.     if (CalculateGeneWeights == true)
  474.     {
  476.         // Generate array data structures
  477.         // This is a wasteful way of doing it, but makes
  478.         // the coding easier for me
  480.         double **ArrayData = new double*[2*Columns-1];
  481.         bool   **ArrayMask = new bool*[2*Columns-1];
  483.         for (i=0;i<2*Columns-1;i++)
  484.         {
  485.             ArrayData[i] = new double[Rows];
  486.             ArrayMask[i] = new bool[Rows];
  487.             if (i<Columns)
  488.             {
  489.                for (j=0;j<Rows;j++)
  490.                {
  491.                    ArrayData[i][j] = GeneData[j][i];
  492.                    ArrayMask[i][j] = GeneMask[j][i];
  493.                }
  494.             }
  495.         }
  497.         TStringList *ArrayTreeFile = new TStringList();
  498.         TStringList *ArrayClusterOrder = new TStringList();
  500.         SingleCluster(ArrayData,ArrayMask,Columns,Rows,
  501.             ArrayTreeFile,ArrayOrder,ArrayWeight,GeneWeight,ArrayID,
  502.             ArrayMetricComboBox->ItemIndex,
  503.             true,ArrayWeightCutoff,ArrayWeightExp,
  504.             ArrayClusterOrder,StatusBar1,false,NULL);
  506.         delete ArrayClusterOrder;
  508.         for (i=0;i<2*Columns-1;i++)
  509.         {
  510.             delete ArrayData[i];
  511.             delete ArrayMask[i];
  512.         }
  514.         delete ArrayData;
  515.         delete ArrayMask;
  516.     }
  518.     int *RowOrder = new int[Rows];
  520.     AnsiString *GeneID = new AnsiString[2*Rows-1];
  522.     for (i=0;i<Rows;i++)
  523.     {
  524.         RowOrder[i] = i;
  525.         GeneID[i] = AnsiString("GENE") + AnsiString(i) + AnsiString("X");
  526.     }
  528.     if (ClusterGenes == true)
  529.     {
  530.         TStringList *GeneTreeFile = new TStringList();
  531.         TStringList *GeneClusterOrder = new TStringList();
  533.         if (CalculateArrayWeights == true)
  534.         {
  535.             SingleCluster(GeneData,GeneMask,Rows,Columns,
  536.                 GeneTreeFile,GeneOrder,GeneWeight, ArrayWeight,GeneID,
  537.                 GeneMetricComboBox->ItemIndex,
  538.                 true,GeneWeightCutoff,GeneWeightExp,
  539.                 GeneClusterOrder,StatusBar1,false,NULL);
  540.         }
  541.         else
  542.         {
  543.             double *NullGeneWeight = new double[Rows];
  545.             SingleCluster(GeneData,GeneMask,Rows,Columns,
  546.                 GeneTreeFile,GeneOrder,NullGeneWeight,ArrayWeight,GeneID,
  547.                 GeneMetricComboBox->ItemIndex,
  548.                 false,1.0,1.0,
  549.                 GeneClusterOrder,StatusBar1,false,NULL);
  551.             delete NullGeneWeight;
  552.         }
  554.         for (i=0;i<GeneClusterOrder->Count;i++)
  555.         {
  556.             RowOrder[i] = GeneClusterOrder->Strings[i].ToInt();
  557.         }
  559.         AnsiString TreeFileName = JobName + ".gtr";
  560.         GeneTreeFile->SaveToFile(TreeFileName);
  561.     }
  563.     if (ClusterArrays == true)
  564.     {
  566.         // Generate array data structures
  567.         // This is a wasteful way of doing it, but makes
  568.         // the coding easier for me
  570.         double **ArrayData = new double*[2*Columns-1];
  571.         bool   **ArrayMask = new bool*[2*Columns-1];
  573.         for (i=0;i<2*Columns-1;i++)
  574.         {
  575.             ArrayData[i] = new double[Rows];
  576.             ArrayMask[i] = new bool[Rows];
  577.             if (i<Columns)
  578.             {
  579.             for (j=0;j<Rows;j++)
  580.             {
  581.                 ArrayData[i][j] = GeneData[j][i];
  582.                 ArrayMask[i][j] = GeneMask[j][i];
  583.             }
  584.             }
  585.         }
  587.         TStringList *ArrayTreeFile = new TStringList();
  588.         TStringList *ArrayClusterOrder = new TStringList();
  590.         SingleCluster(ArrayData,ArrayMask,Columns,Rows,
  591.             ArrayTreeFile,ArrayOrder,ArrayWeight,GeneWeight,ArrayID,
  592.             ArrayMetricComboBox->ItemIndex,
  593.             false,1.0,1.0,ArrayClusterOrder,StatusBar1,false,NULL);
  595.         for (i=0;i<ArrayClusterOrder->Count;i++)
  596.         {
  597.             ColumnOrder[i] = ArrayClusterOrder->Strings[i].ToInt();
  598.         }
  600.         delete ArrayClusterOrder;
  602.         for (i=0;i<2*Columns-1;i++)
  603.         {
  604.             delete ArrayData[i];
  605.             delete ArrayMask[i];
  606.         }
  608.         delete ArrayData;
  609.         delete ArrayMask;
  611.         AnsiString ArrayTreeFileName = JobName + ".atr";
  612.         ArrayTreeFile->SaveToFile(ArrayTreeFileName);
  613.         delete ArrayTreeFile;
  614.     }
  616.     AnsiString OutString;
  618.     TStringList *DataFile = new TStringList();
  620.     // Now make output .cdt file
  622.     OutString = "";
  624.     if (ClusterGenes == true)
  625.     {
  626.         OutString += AnsiString("GID") + AnsiString("t");
  627.     }
  629.     OutString += Headers->Strings[0] + AnsiString("t");
  630.     OutString += AnsiString("NAME") + AnsiString("t");
  631.     OutString += "GWEIGHT";
  633.     // Now add headers for data columns
  635.     for (i=0;i<Columns;i++)
  636.     {
  637.         OutString += "t";
  638.         OutString += AnsiString(Headers->Strings[InColumn[ColumnOrder[i]]]);
  639.     }
  641.     DataFile->Add(OutString);
  643.     if (ClusterArrays == true)
  644.     {
  645.         OutString = AnsiString("AID");
  646.         if (ClusterGenes == true)
  647.         {
  648.             OutString += AnsiString("t");
  649.         }
  651.         OutString += AnsiString("t");
  652.         OutString += AnsiString("t");
  654.         for (i=0;i<Columns;i++)
  655.         {
  656.             OutString += "t";
  657.             OutString += ArrayID[ColumnOrder[i]];
  658.         }
  660.         DataFile->Add(OutString);
  661.     }
  664.     {
  665.         OutString = AnsiString("EWEIGHT");
  666.         if (ClusterGenes == true)
  667.         {
  668.             OutString += AnsiString("t");
  669.         }
  671.         OutString += AnsiString("t");
  672.         OutString += AnsiString("t");
  674.         for (i=0;i<Columns;i++)
  675.         {
  676.             OutString += "t";
  677.             OutString += ArrayWeight[ColumnOrder[i]];
  678.         }
  679.     }
  681.     DataFile->Add(OutString);
  683.     int index;
  685.     TFloatFormat Format = ffGeneral;
  687.     for (i=0;i<Rows;i++)
  688.     {
  689.         index = RowOrder[i];
  691.         OutString = "";
  692.         if (ClusterGenes == true)
  693.         {
  694.             OutString += GeneID[index] + "t";
  695.         }
  697.         OutString += AnsiString(UniqID[index]) + "t" + AnsiString(GeneName[index]);
  698.         OutString += "t" + AnsiString(GeneWeight[index]);
  700.         for (j=0;j<Columns;j++)
  701.         {
  702.             if (GeneMask[index][ColumnOrder[j]] == true)
  703.             {
  704.                 OutString += "t" + AnsiString(FloatToStrF(GeneData[index][ColumnOrder[j]],Format,4,2));
  705.             }
  706.             else
  707.             {
  708.                 OutString += "t";
  709.             }
  710.         }
  711.         DataFile->Add(OutString);
  712.     }
  714.     AnsiString DataFileName = JobName + ".cdt";
  715.     DataFile->SaveToFile(DataFileName);
  717.     for (i=0;i<2*Columns-1;i++)
  718.     {
  719.         ArrayID[i] = "";
  720.     }
  722.     for (i=0;i<2*Rows-1;i++)
  723.     {
  724.         GeneID[i] = "";
  725.     }
  727.     delete ArrayID;
  728.     delete GeneID;
  730.     delete ColumnOrder;
  731.     delete RowOrder;
  733.     StatusBar1->SimpleText = "Done Clustering";
  736. }
  737. //---------------------------------------------------------------------------
  739. /*Single Linkage Clustering Code */
  741. void    TMainForm::SingleCluster(double **ClusterData, bool **ClusterMask,
  742.         int ClusterRows, int ClusterColumns,
  743.         TStringList *TreeFile, double *Order, double *RowWeight, double *ColumnWeight,
  744.         AnsiString *ID, int DistFunction,
  745.         bool CalculateWeights, double WeightCutoff, double WeightPower,
  746.         TStringList *ClusterOrder, TStatusBar *StatusBar,
  747.         bool ReturnTNode, TNode *TopNode)
  748. {
  749.         int i,j,k,l,m;
  751.         ReturnTNode = true;
  753.         unsigned short *minval;
  754.         int *minpair;
  755.         int *elements;
  756.         AnsiString OutString;
  757.         unsigned short **Dist;
  758.         int **NodeElement;
  759.         double *NodeDistance;
  760.         double *CalcWeight;
  761.         int element1, element2;
  763.         
  764.         TStringList *List1 = new TStringList();
  765.         TStringList *List2 = new TStringList();
  767.         Dist = new unsigned short*[2*ClusterRows-1];
  768.         minval = new unsigned short[2*ClusterRows-1];
  769.         minpair = new int[2*ClusterRows-1];
  770.         elements = new int[2*ClusterRows-1];
  771.         NodeElement = new int*[2*ClusterRows-1];
  772.         NodeDistance = new double[2*ClusterRows-1];
  773.         CalcWeight = new double[2*ClusterRows-1];
  775.         int *iList1 = new int[ClusterRows];
  776.         int *iList2 = new int[ClusterRows];
  778.         bool SaveDistances = true;
  780.         double WeightDist;
  782.         for (i=0;i<ClusterRows;i++)
  783.         {
  784.             Dist[i] = new unsigned short[2*ClusterRows-1];
  785.         }
  787.         for (i=0;i<2*ClusterRows-1;i++)
  788.         {
  789.             minval[i] = 32769;
  790.             elements[i] = 1;
  791.             NodeElement[i] = new int[2];
  792.             CalcWeight[i] = 1;
  793.             NodeDistance[i] = 0.0;
  794.         }
  797.         bool Centered = false;
  799.         if ((DistFunction == 1) || (DistFunction == 3) )
  800.         {
  801.             Centered = true;
  802.         }
  804.         bool Absolute = false;
  806.         if ((DistFunction == 3) || (DistFunction == 4) )
  807.         {
  808.             Absolute = true;
  809.         }
  811.         bool CalcInferredDistances = false;
  812.         TStringList **MemberList;
  813.         unsigned short **TreeDist;
  815.         if (CalcInferredDistances == true)
  816.         {
  817.             MemberList = new TStringList*[2*ClusterRows-1];
  818.             TreeDist = new unsigned short*[ClusterRows];
  819.             for (i=0;i<2*ClusterRows-1;i++)
  820.             {
  821.                 MemberList[i] = new TStringList();
  822.                 if (i<ClusterRows)
  823.                 {
  824.                     MemberList[i]->Add(AnsiString(i));
  825.                     TreeDist[i] = new unsigned short[ClusterRows];
  826.                 }
  827.             }
  828.         }
  830.         int TotalDistance = ClusterRows * (ClusterRows - 1) / 2;
  832.         /* First step is to compute the distance matrix
  833.         This is the slowest step */
  835.         for (i=0;i<ClusterRows;i++)
  836.         {
  837.             Dist[i][i] = 0.0;
  838.             for (j=0;j<i;j++)
  839.             {
  841.                 Dist[i][j] = Distance(DistFunction,ClusterData,ClusterMask,ColumnWeight,
  842.                     i,j,ClusterColumns);
  843.                 Dist[j][i] = Dist[i][j];
  845.                 if (CalculateWeights == true)
  846.                 {
  848.                     WeightDist = ( (double) (32768 - Dist[i][j])) /32768.0;
  849.                     WeightDist = max(0.0, (WeightDist - WeightCutoff)/(1.0 - WeightCutoff));
  850.                     WeightDist = pow(WeightDist,WeightPower);
  852.                     CalcWeight[i] += WeightDist;
  853.                     CalcWeight[j] += WeightDist;
  854.                 }
  856.                 if (Dist[i][j] < minval[i])
  857.                 {
  858.                     minval[i] = Dist[i][j];
  859.                     minpair[i] = j;
  860.                 }
  862.                 if (Dist[i][j] < minval[j])
  863.                 {
  864.                     minval[j] = Dist[i][j];
  865.                     minpair[j] = i;
  866.                 }
  867.             }
  868.             StatusBar->SimpleText = "Calculating Distances " + AnsiString(i*(i+1)/2) + " of "
  869.                 + AnsiString(TotalDistance);
  870.             Application->ProcessMessages();
  871.         }
  873.         TStringList *MinList = new TStringList();
  875.         for (i=0;i<ClusterRows;i++)
  876.         {
  877.             MinList->Add(AnsiString(minval[i]));
  878.         }
  880.         MinList->SaveToFile("minlist.txt");
  882.         delete MinList;
  884.         bool *Active;
  885.         Active = new bool[2*ClusterRows-1];
  887.         for (i=0;i<ClusterRows;i++)
  888.         {
  889.             Active[i] = true;
  890.         }
  892.         for (i=ClusterRows;i<2*ClusterRows-1;i++)
  893.         {
  894.             Active[i] = false;
  895.         }
  897.         unsigned short minminval;
  899.         int min1, min2;
  901.         int nodeindex;
  903.         //int node;
  905.         /* Now we join nodes */
  907.         /* If we are going to return TNode, need to set up TNodes */
  909.         TNode **Nodes;
  910.         //if (ReturnTNode)
  911.         {
  912.            Nodes = new TNode*[2*ClusterRows-1];
  914.            for (i=0;i<2*ClusterRows-1;i++)
  915.            {
  916.                Nodes[i] = new TNode();
  918.                if (i < ClusterRows)
  919.                {
  920.                    Nodes[i]->IsNode = false;
  921.                    Nodes[i]->ID = AnsiString(i);
  922.                }
  923.                else
  924.                {
  925.                    Nodes[i]->IsNode = true;
  926.                }
  927.            }
  928.         }
  930.         for (nodeindex=ClusterRows; nodeindex<2*ClusterRows-1;nodeindex++)
  932.         {
  933.             ID[nodeindex] = "NODE" + AnsiString(nodeindex-ClusterRows+1) + "X";
  935.             minminval = 32769;
  937.             for (i=0;i<2*ClusterRows-1;i++)
  938.             {
  939.                 if (Active[i] == true)
  940.                 {
  941.                     if (minval[i] < minminval)
  942.                     {
  943.                         minminval = minval[i];
  944.                         min1 = i;
  945.                         min2 = minpair[i];
  946.                     }
  947.                 }
  948.             }
  950.             /* When we get here min1 and min2 are the elements that are to be joined */
  955.         Active[min1] = false;
  956.         Active[min2] = false;
  958.         if (Order[min1] > Order[min2])
  959.         {
  960.             NodeElement[nodeindex][0] = min1;
  961.             NodeElement[nodeindex][1] = min2;
  962.         }
  963.         else
  964.         {
  965.             NodeElement[nodeindex][1] = min1;
  966.             NodeElement[nodeindex][0] = min2;
  967.         }
  969.         NodeDistance[nodeindex] = ((double) minminval)/16384.0;
  970.         NodeDistance[nodeindex] = max(NodeDistance[nodeindex],NodeDistance[min1]);
  971.         NodeDistance[nodeindex] = max(NodeDistance[nodeindex],NodeDistance[min2]);
  973.         if (ReturnTNode)
  974.         {
  975.                Nodes[nodeindex]->Child1 = Nodes[NodeElement[nodeindex][0]];
  976.                Nodes[nodeindex]->Child2 = Nodes[NodeElement[nodeindex][1]];
  977.                Nodes[nodeindex]->Length = 1.0 - NodeDistance[nodeindex];
  978.         }
  980.         if (CalcInferredDistances == true)
  981.         {
  982.             int elem1,elem2,ielem1,ielem2;
  984.             for (elem1=0;elem1<MemberList[min1]->Count;elem1++)
  985.             {
  986.                 for (elem2=0;elem2<MemberList[min2]->Count;elem2++)
  987.                 {
  988.                     ielem1 = (MemberList[min1]->Strings[elem1]).ToInt();
  989.                     ielem2 = (MemberList[min2]->Strings[elem2]).ToInt();
  990.                     TreeDist[ielem1][ielem2] = (NodeDistance[nodeindex] * 16384);
  991.                     TreeDist[ielem2][ielem1] = (NodeDistance[nodeindex] * 16384);
  992.                 }
  993.             }
  995.             MemberList[nodeindex]->AddStrings(MemberList[min1]);
  996.             MemberList[nodeindex]->AddStrings(MemberList[min2]);
  998.             delete MemberList[min1];
  999.             delete MemberList[min2];
  1000.         }
  1002.         OutString = ID[nodeindex] + AnsiString("t") + ID[NodeElement[nodeindex][0]]
  1003.                 + AnsiString("t") + ID[NodeElement[nodeindex][1]] + AnsiString("t")
  1004.                 + AnsiString(1.0 - NodeDistance[nodeindex]);
  1006.         TreeFile->Add(OutString);
  1008.         StatusBar->SimpleText = "Generating Node " + AnsiString(nodeindex-ClusterRows+1) + " of " + AnsiString(ClusterRows-1);
  1009.         Application->ProcessMessages();
  1011.         elements[nodeindex] = elements[min1] + elements[min2];
  1013.         for (k=0;k<ClusterColumns;k++)
  1014.         {
  1015.             if ( (ClusterMask[min1][k] == true) && (ClusterMask[min2][k] == true) )
  1016.             {
  1017.                 ClusterData[nodeindex][k] =
  1018.                     (elements[min1] * ClusterData[min1][k] +
  1019.                         elements[min2] * ClusterData[min2][k]) /
  1020.                     (elements[min1] + elements[min2]);
  1021.                 ClusterMask[nodeindex][k] = true;
  1022.             }
  1023.             else if (ClusterMask[min1][k] == true)
  1024.             {
  1025.                 ClusterData[nodeindex][k] = ClusterData[min1][k];
  1026.                 ClusterMask[nodeindex][k] = true;
  1027.             }
  1028.             else if (ClusterMask[min2][k] == true)
  1029.             {
  1030.                 ClusterData[nodeindex][k] = ClusterData[min2][k];
  1031.                 ClusterMask[nodeindex][k] = true;
  1032.             }
  1033.             else
  1034.             {
  1035.                 ClusterMask[nodeindex][k] = false;
  1036.             }
  1037.         }
  1039.         Order[nodeindex] = (elements[min1]*Order[min1] + elements[min2]*Order[min2])/(elements[min1] + elements[min2]);
  1040.         Dist[nodeindex] = new unsigned short[2*ClusterRows-1];
  1042.         if (SaveDistances == false)
  1043.         {
  1044.             delete Dist[min1];
  1045.             delete Dist[min2];
  1046.         }
  1048.         List1->Clear();
  1049.         Nodes[nodeindex]->SetList(List1);
  1051.         int NumList1 = List1->Count;
  1053.         for (int i1=0;i1<NumList1;i1++)
  1054.         {
  1055.             iList1[i1] = List1->Strings[i1].ToInt();
  1056.         }
  1059.         for (l=0;l<2*ClusterRows-1;l++)
  1060.         {
  1061.             if (Active[l] == true)
  1062.             {
  1064.                 // OK. Here's where it gets tricky
  1066.                 List2->Clear();
  1068.                 if (l < ClusterRows)
  1069.                 {
  1070.                     List2->Add(AnsiString(l));
  1071.                 }
  1072.                 else
  1073.                 {
  1074.                     Nodes[l]->SetList(List2);
  1075.                 }
  1077.                 int NumList2 = List2->Count;
  1079.                 for (int i2=0;i2<NumList2;i2++)
  1080.                 {
  1081.                     iList2[i2] = List2->Strings[i2].ToInt();
  1082.                 }
  1085.                 Dist[nodeindex][l] = 32768;
  1087.                 for (int i1=0; i1 < NumList1; i1++)
  1088.                 {
  1089.                     for (int i2=0; i2 < NumList2; i2++)
  1090.                     {
  1091.                          Dist[nodeindex][l] = min(Dist[nodeindex][l],Dist[iList1[i1]][iList2[i2]]);
  1092.                     }
  1093.                 }
  1095.                 Dist[l][nodeindex] = Dist[nodeindex][l];
  1097.                 if (Dist[nodeindex][l] < minval[nodeindex])
  1098.                 {
  1099.                     minval[nodeindex] = Dist[nodeindex][l];
  1100.                     minpair[nodeindex] = l;
  1101.                 }
  1103.                 //Rescan for min if minpair was one of the fused elements
  1105.                 if ( (minpair[l] == min1) || (minpair[l] == min2) )
  1106.                 {
  1107.                     minval[l] = 32769;
  1109.                     for (m=0;m<2*ClusterRows-1;m++)
  1110.                     {
  1111.                         if ( (Active[m] == true) && (l != m) )
  1112.                         {
  1113.                             if (Dist[l][m] < minval[l])
  1114.                             {
  1115.                                 minval[l] = Dist[l][m];
  1116.                                 minpair[l] = m;
  1117.                             }
  1118.                         }
  1119.                     }
  1120.                 }
  1122.                 //otherwise check new distance to see if it is new min
  1124.                 else if (Dist[nodeindex][l] < minval[l])
  1125.                 {
  1126.                     minval[l] = Dist[nodeindex][l];
  1127.                     minpair[l] = nodeindex;
  1128.                 }
  1129.             }
  1130.         }
  1132.         Active[nodeindex] = true;
  1133.         }
  1135.         if (SaveDistances == false)
  1136.         {
  1137.             delete Dist[2*ClusterRows-2];
  1138.         }
  1140.         TList *NewList = new TList();
  1141.         TList *OutList = new TList();
  1143.         int **Elements;
  1144.         Elements = new int*[2*ClusterRows-1];
  1145.         for (i=0;i<2*ClusterRows-1;i++)
  1146.         {
  1147.             Elements[i] = new int;
  1148.             *Elements[i] = i;
  1149.         }
  1151.         OutList->Clear();
  1153.         OutList->Add((void *)Elements[2*ClusterRows-2]);
  1155.         int Position;
  1157.         bool Replaced;
  1159.         Replaced = true;
  1161.         while (Replaced == true)
  1162.         {
  1163.             Replaced = false;
  1165.             for (Position = 0; Position < OutList->Count; Position ++)
  1166.             {
  1167.                 nodeindex =  *(int *) OutList->Items[Position];
  1168.                 if (nodeindex >= 0)
  1169.                 {
  1170.                     if (nodeindex < ClusterRows)
  1171.                     {
  1172.                         NewList->Add((void *) Elements[nodeindex]);
  1173.                     }
  1174.                     else
  1175.                     {
  1176.                         element1 =  NodeElement[nodeindex][0];
  1177.                         element2 =  NodeElement[nodeindex][1];
  1179.                         NewList->Add((void *) Elements[element1]);
  1180.                         NewList->Add((void *) Elements[element2]);
  1182.                         Replaced = true;
  1183.                     }
  1184.                 }
  1185.             }
  1187.             OutList->Clear();
  1188.             for (i=0;i<NewList->Count;i++)
  1189.             {
  1190.                 OutList->Add(NewList->Items[i]);
  1191.             }
  1192.             NewList->Clear();
  1193.         }
  1195.         int index;
  1197.         ClusterOrder->Clear();
  1199.         if (SaveDistances == true)
  1200.         {
  1202.             /*
  1203.             if (DistFileDialogBox->Execute())
  1204.             {
  1206.                 TFileStream *DistFile = new TFileStream(DistFileDialogBox->FileName,fmCreate);
  1208.                 int ii, ij;
  1210.                 for (i=0;i<OutList->Count;i++)
  1211.                 {
  1212.                     ii = *(int *)OutList->Items[i];
  1213.                     for (j=0;j<OutList->Count;j++)
  1214.                     {
  1215.                         {
  1216.                             ij = *(int *)OutList->Items[j];
  1217.                             DistFile->Write(&Dist[ii][ij],2);
  1218.                         }
  1219.                     }
  1220.                 }
  1221.                 delete DistFile;
  1224.             } */
  1226.             for (i=0;i<2*ClusterRows-1;i++)
  1227.                 {
  1228.                     delete Dist[i];
  1229.                 }
  1230.         }
  1232.         if (CalcInferredDistances == true)
  1233.         {
  1234.             if (DistFileDialogBox->Execute())
  1235.             {
  1237.                 TFileStream *DistFile = new TFileStream(DistFileDialogBox->FileName,fmCreate);
  1239.                 int ii, ij;
  1241.                 for (i=0;i<OutList->Count;i++)
  1242.                 {
  1243.                     ii = *(int *)OutList->Items[i];
  1244.                     for (j=0;j<OutList->Count;j++)
  1245.                     {
  1246.                         {
  1247.                             ij = *(int *)OutList->Items[j];
  1248.                             DistFile->Write(&TreeDist[ii][ij],2);
  1249.                         }
  1250.                     }
  1251.                 }
  1253.                 delete DistFile;
  1255.                 for (i=0;i<ClusterRows;i++)
  1256.                 {
  1257.                     delete TreeDist[i];
  1258.                 }
  1259.             }
  1261.             delete TreeDist;
  1262.         }
  1264.         for (i=0;i<OutList->Count;i++)
  1265.         {
  1266.             index = *(int *)OutList->Items[i];
  1267.             ClusterOrder->Add(index);
  1268.         }
  1270.         for (i=0;i<2*ClusterRows-1;i++)
  1271.         {
  1272.             delete NodeElement[i];
  1273.             delete Elements[i];
  1274.         }
  1276.         if (CalculateWeights == true)
  1277.         {
  1278.             for (i=0;i<ClusterRows;i++)
  1279.             {
  1280.                 RowWeight[i] = 1/CalcWeight[i];
  1281.             }
  1282.         }
  1284.         delete Dist;
  1285.         delete NodeElement;
  1286.         delete Elements;
  1287.         delete NodeDistance;
  1288.         delete elements;
  1289.         delete minval;
  1290.         delete minpair;
  1291.         delete NewList;
  1292.         delete OutList;
  1293.         delete Active;
  1294.         delete CalcWeight;
  1296.         delete iList1;
  1297.         delete iList2;
  1298.         delete List1;
  1299.         delete List2;
  1300. }
  1302. /* Accessory Code for Clustering Dialog */
  1304. /* Handle Clicks on CheckBoxes */
  1306. void __fastcall TMainForm::CalculateGeneWeightsCheckBoxClick(
  1307.       TObject *Sender)
  1308. {
  1309.     if (CalculateGeneWeightsCheckBox->Checked == true)
  1310.     {
  1311.         ArrayWeightOptionsGroupBox->Visible = true;
  1312.     }
  1313.     else
  1314.     {
  1315.         ArrayWeightOptionsGroupBox->Visible = false;
  1316.     }
  1317. }
  1319. void __fastcall TMainForm::CalculateArrayWeightsCheckBoxClick(
  1320.       TObject *Sender)
  1321. {
  1322.     if (CalculateArrayWeightsCheckBox->Checked == true)
  1323.     {
  1324.         GeneWeightOptionsGroupBox->Visible = true;
  1325.     }
  1326.     else
  1327.     {
  1328.         GeneWeightOptionsGroupBox->Visible = false;
  1329.     }
  1330. }
  1332. /* Handle Edit Exits to Check Values */
  1334. //---------------------------------------------------------------------------
  1335. void __fastcall TMainForm::GeneWeightExpEditExit(TObject *Sender)
  1336. {
  1337.     double Val;
  1338.     try
  1339.     {
  1340.         Val =  GeneWeightExpEdit->Text.ToDouble();
  1341.         GeneWeightExp = Val;
  1342.     }
  1343.     catch (EConvertError &E)
  1344.     {
  1345.         GeneWeightExpEdit->Text = GeneWeightExp;
  1346.     }
  1347. }
  1348. //---------------------------------------------------------------------------
  1349. void __fastcall TMainForm::GeneWeightCutoffEditExit(TObject *Sender)
  1350. {
  1351.     double Val;
  1352.     try
  1353.     {
  1354.         Val =  GeneWeightCutoffEdit->Text.ToDouble();
  1355.         GeneWeightCutoff = Val;
  1356.     }
  1357.     catch (EConvertError &E)
  1358.     {
  1359.         GeneWeightCutoffEdit->Text = GeneWeightCutoff;
  1360.     }
  1361. }
  1363. //---------------------------------------------------------------------------
  1365. void __fastcall TMainForm::ArrayWeightExpEditExit(TObject *Sender)
  1366. {
  1367.     double Val;
  1368.     try
  1369.     {
  1370.         Val =  ArrayWeightExpEdit->Text.ToDouble();
  1371.         ArrayWeightExp = Val;
  1372.     }
  1373.     catch (EConvertError &E)
  1374.     {
  1375.         ArrayWeightExpEdit->Text = ArrayWeightExp;
  1376.     }
  1377. }
  1378. //---------------------------------------------------------------------------
  1380. void __fastcall TMainForm::ArrayWeightCutoffEditExit(TObject *Sender)
  1381. {
  1382.     double Val;
  1383.     try
  1384.     {
  1385.         Val =  ArrayWeightCutoffEdit->Text.ToDouble();
  1386.         ArrayWeightCutoff = Val;
  1387.     }
  1388.     catch (EConvertError &E)
  1389.     {
  1390.         ArrayWeightCutoffEdit->Text = ArrayWeightCutoff;
  1391.     }
  1392. }
  1394. /* This is an invisible button that handles a particular type
  1395. of column and row reordering. It was put in for one use. */
  1397. void __fastcall TMainForm::ReorderType1ButtonClick(TObject *Sender)
  1398. {
  1399.     for (int row=0; row<Rows; row++)
  1400.     {
  1401.         GeneOrder[row] = 0;
  1402.         int count = 0;
  1403.         for (int col=0; col<Columns; col++)
  1404.         {
  1405.             if (GeneMask[row][col] == true)
  1406.             {
  1407.                 GeneOrder[row] += col * GeneData[row][col];
  1408.                 count++;
  1409.             }
  1410.         }
  1412.         if (count > 0)
  1413.         {
  1414.             GeneOrder[row] /= count;
  1415.         }
  1416.     }
  1418.     for (int col=0; col<Columns; col++)
  1419.     {
  1420.         ArrayOrder[col] = 0;
  1421.         int count = 0;
  1422.         for (int row=0; row<Rows; row++)
  1423.         {
  1424.             if (GeneMask[row][col] == true)
  1425.             {
  1426.                 ArrayOrder[col] += row * GeneData[row][col];
  1427.                 count++;
  1428.             }
  1429.         }
  1431.         if (count > 0)
  1432.         {
  1433.             ArrayOrder[col] /= count;
  1434.         }
  1435.     }
  1436. }
  1437. //---------------------------------------------------------------------------
  1439. /* Self-Organizing Maps ala Kohonen: Note this makes use of NR Code */
  1441. double*** __fastcall TMainForm::SOM(int X, int Y, double **SOMData, bool **SOMMask,
  1442.      int SOMRows, int SOMColumns, int SOMIterations)
  1443. {
  1444.      int i,j,k,l,n;
  1446.      double ***Nodes;
  1448.      Nodes = new double**[X];
  1449.      for (i=0;i<X;i++)
  1450.      {
  1451.          Nodes[i] = new double*[Y];
  1452.          for (j=0; j<Y; j++)
  1453.          {
  1454.              Nodes[i][j] = new double[SOMColumns];
  1456.              double NodeMag = 0;
  1458.              while (NodeMag == 0)
  1459.              {
  1460.                    for (k=0;k<SOMColumns;k++)
  1461.                    {
  1462.                        Nodes[i][j][k] = ((double) random(10000))/10000.0;
  1463.                        NodeMag += pow(Nodes[i][j][k],2.0);
  1464.                    }
  1466.                    NodeMag = sqrt(NodeMag);
  1467.              }
  1469.              for (k=0;k<SOMColumns;k++)
  1470.              {
  1471.                  Nodes[i][j][k] /= NodeMag;
  1472.              }
  1473.          }
  1474.      }
  1476.      bool *SOMUse = new bool[SOMRows];
  1477.      double *Mag = new double[SOMRows];
  1479.      int CountSOMUse = 0;
  1481.      for (i=0;i<SOMRows;i++)
  1482.      {
  1483.          Mag[i] = 0;
  1484.          double Min = 1000;
  1485.          double Max = -1000;
  1486.          int    DataPoints = 0;
  1488.          for (j=0;j<SOMColumns;j++)
  1489.          {
  1490.              if (SOMMask[i][j])
  1491.              {
  1492.                 DataPoints++;
  1493.                 Min = min(Min,SOMData[i][j]);
  1494.                 Max = max(Max,SOMData[i][j]);
  1496.                 Mag[i] += pow(SOMData[i][j],2.0);
  1497.              }
  1498.          }
  1500.          Mag[i] = sqrt(Mag[i]);
  1501.          if ( (2 * DataPoints > SOMColumns) && ( (Max - Min) > 0.0) )
  1502.          {
  1503.              SOMUse[i] = true;
  1504.              CountSOMUse++;
  1505.          }
  1506.          else
  1507.          {
  1508.              SOMUse[i] = false;
  1509.          }
  1510.      }
  1512.      int *SOMUseRow = ivector(1,CountSOMUse);
  1513.      float *SOMUseRandom = vector(1,CountSOMUse);
  1515.      CountSOMUse = 0;
  1517.      for (i=0;i<SOMRows;i++)
  1518.      {
  1519.          if (SOMUse[i])
  1520.          {
  1521.             CountSOMUse++;
  1522.             SOMUseRow[CountSOMUse] = i;
  1523.             SOMUseRandom[CountSOMUse] = rand();
  1524.          }
  1525.      }
  1527.      sort2fi(CountSOMUse,SOMUseRandom,SOMUseRow);
  1529.      double MaxDist = sqrt(pow(X-1,2.0)+pow(Y-1,2.0));
  1530.      //MaxDist = 3; // Try this for compatibility with Tamayo et al.
  1532.      for (i=0;i<SOMIterations;i++)
  1533.      {
  1534.          StatusBar1->SimpleText = "SOM Iteration " + AnsiString(i) +" of " + AnsiString(SOMIterations);
  1535.          Application->ProcessMessages();
  1537.          double BestCorr = -100;
  1538.          int BestX, BestY;
  1540. /*       n = random(SOMRows);
  1542.          while(SOMUse[n] == false)
  1543.          {
  1544.              n = random(SOMRows);
  1545.          }   */
  1547.          n = SOMUseRow[(i%CountSOMUse)+1];
  1549.          for (j=0;j<X;j++)
  1550.          {
  1551.              for (k=0;k<Y;k++)
  1552.              {
  1553.                  double Corr = Correlation(Nodes,SOMData,SOMMask,false,j,k,n,SOMColumns);
  1554.                  if (Corr > BestCorr)
  1555.                  {
  1556.                     BestCorr = Corr;
  1557.                     BestX = j;
  1558.                     BestY = k;
  1559.                  }
  1560.              }
  1561.          }
  1563.          for (j=0;j<X;j++)
  1564.          {
  1565.              for (k=0;k<Y;k++)
  1566.              {
  1567.                  double Corr = Correlation(Nodes,SOMData,SOMMask,false,j,k,n,SOMColumns);
  1568.                  if (Corr > BestCorr)
  1569.                  {
  1570.                     BestCorr = Corr;
  1571.                     BestX = j;
  1572.                     BestY = k;
  1573.                  }
  1574.              }
  1575.          }
  1577.          double DistCut = (MaxDist*(0.75-((0.75*i)/SOMIterations)));
  1578.          //DistCut = MaxDist * (1.0 - ((double)i/(double)SOMIterations));
  1580.          double Tau;
  1582.          if (i < 1000)
  1583.          {
  1584.              Tau = (0.9 * (1.0 - i/1000.0));
  1585.          }
  1586.          else
  1587.          {
  1588.              Tau = (0.02 * SOMIterations)/(SOMIterations+(100*i));
  1589.          }
  1590.          //Tau = (0.02 * SOMIterations)/(SOMIterations+(100*i));
  1592.          for (j=0;j<X;j++)
  1593.          {
  1594.              for (k=0;k<Y;k++)
  1595.              {
  1596.                  double NodeDist = sqrt(pow(BestX - j,2.0) + pow(BestY - k,2.0));
  1597.                  if (NodeDist < DistCut)
  1598.                  {
  1599.                     for (l=0;l<SOMColumns;l++)
  1600.                     {
  1601.                         if (SOMMask[n][l] == true)
  1602.                         {
  1603.                            Nodes[j][k][l] += Tau * ((SOMData[n][l]/Mag[n]) - Nodes[j][k][l]);
  1604.                         }
  1605.                     }
  1606.                  }
  1608.                  double NodeMag = 0;
  1610.                  for (l=0;l<SOMColumns;l++)
  1611.                  {
  1612.                      NodeMag += pow(Nodes[j][k][l],2.0);
  1613.                  }
  1615.                  NodeMag = sqrt(NodeMag);
  1617.                  for (l=0;l<SOMColumns;l++)
  1618.                  {
  1619.                      Nodes[j][k][l] /= NodeMag;
  1620.                  }
  1621.              }
  1622.          }
  1623.      }
  1626.      delete Mag;
  1627.      delete SOMUse;
  1629.      free_vector(SOMUseRandom,1,CountSOMUse);
  1630.      free_ivector(SOMUseRow,1,CountSOMUse);
  1632.      StatusBar1->SimpleText = "Done Making SOM";
  1634.      return Nodes;
  1635. }
  1637. /* Correlation Function for SOM */
  1639. double TMainForm::Correlation(double ***Nodes, double **SOMData, bool **SOMMask,
  1640.        bool Centered, int j, int k, int n, int SOMColumns)
  1641. {
  1642.     int l;
  1644.     double Sum1 = 0;
  1645.     double Sum2 = 0;
  1646.     double Sum11 = 0;
  1647.     double Sum12 = 0;
  1648.     double Sum22 = 0;
  1649.     double Count = 0;
  1651.     double Ave1,Ave2;
  1652.     double Norm1 = 0;
  1653.     double Norm2 = 0;
  1654.     double Corr = -100;
  1656.     for (l=0;l<SOMColumns;l++)
  1657.     {
  1658.         if (SOMMask[n][l] == true)
  1659.         {
  1660.            Sum1  += SOMData[n][l];
  1661.            Sum2  += Nodes[j][k][l];
  1662.            Sum11 += SOMData[n][l] * SOMData[n][l];
  1663.            Sum22 += Nodes[j][k][l]* Nodes[j][k][l];
  1664.            Sum12 += SOMData[n][l] * Nodes[j][k][l];
  1666.            Count ++;
  1667.         }
  1669.     }
  1671.     if (Count > 0)
  1672.     {
  1674.        if (Centered)
  1675.        {
  1676.           Ave1 = Sum1/Count;
  1677.           Ave2 = Sum2/Count;
  1678.        }
  1679.        else
  1680.        {
  1681.           Ave1 = 0;
  1682.           Ave2 = 0;
  1683.        }
  1686.        try
  1687.        {
  1688.           Norm1 = sqrt(max(0.0,Sum11 - 2 * Ave1 * Sum1 + Count * Ave1 * Ave1));
  1689.           Norm2 = sqrt(max(0.0,Sum22 - 2 * Ave2 * Sum2 + Count * Ave2 * Ave2));
  1690.        }
  1691.        catch (Exception &E)
  1692.        {
  1693.        }
  1695.        if ( (Norm1 > 0) && (Norm2 > 0) )
  1696.        {
  1697.           Corr = (Sum12 - Sum1 * Ave2 - Sum2 * Ave1 + Count * Ave1 * Ave2)
  1698.           / (Norm1 * Norm2);
  1699.        }
  1700.     }
  1702.     return Corr;
  1703. }
  1705. /* SOM Dialog Controls */ void __fastcall TMainForm::SOMOrganizeGenesCheckBoxClick(TObject *Sender)
  1706. {
  1707.     if (SOMOrganizeGenesCheckBox->Checked == true)
  1708.     {
  1709.         SOMGenesXDimEdit->Visible = true;
  1710.         SOMGenesYDimEdit->Visible = true;
  1711.         SOMGenesTauEdit->Visible = true;
  1712.         SOMGenesIterationsEdit->Visible = true;
  1713.         SOMGenesXDimLabel->Visible = true;
  1714.         SOMGenesYDimLabel->Visible = true;
  1715.         SOMGenesTauLabel->Visible = true;
  1716.         SOMGenesIterationsLabel->Visible = true;
  1717.     }
  1718.     else
  1719.     {
  1720.         SOMGenesXDimEdit->Visible = false;
  1721.         SOMGenesYDimEdit->Visible = false;
  1722.         SOMGenesTauEdit->Visible = false;
  1723.         SOMGenesIterationsEdit->Visible = false;
  1724.         SOMGenesXDimLabel->Visible = false;
  1725.         SOMGenesYDimLabel->Visible = false;
  1726.         SOMGenesTauLabel->Visible = false;
  1727.         SOMGenesIterationsLabel->Visible = false;
  1728.     }
  1729. }
  1730. //---------------------------------------------------------------------------
  1732. void __fastcall TMainForm::SOMOrganizeArraysCheckBoxClick(TObject *Sender)
  1733. {
  1734.     if (SOMOrganizeArraysCheckBox->Checked == true)
  1735.     {
  1736.         SOMArraysXDimEdit->Visible = true;
  1737.         SOMArraysYDimEdit->Visible = true;
  1738.         SOMArraysTauEdit->Visible = true;
  1739.         SOMArraysIterationsEdit->Visible = true;
  1740.         SOMArraysXDimLabel->Visible = true;
  1741.         SOMArraysYDimLabel->Visible = true;
  1742.         SOMArraysTauLabel->Visible = true;
  1743.         SOMArraysIterationsLabel->Visible = true;
  1744.     }
  1745.     else
  1746.     {
  1747.         SOMArraysXDimEdit->Visible = false;
  1748.         SOMArraysYDimEdit->Visible = false;
  1749.         SOMArraysTauEdit->Visible = false;
  1750.         SOMArraysIterationsEdit->Visible = false;
  1751.         SOMArraysXDimLabel->Visible = false;
  1752.         SOMArraysYDimLabel->Visible = false;
  1753.         SOMArraysTauLabel->Visible = false;
  1754.         SOMArraysIterationsLabel->Visible = false;
  1755.     }
  1756. }
  1757. //---------------------------------------------------------------------------
  1759. void __fastcall TMainForm::About1Click(TObject *Sender)
  1760. {
  1761.         AboutForm->Show();
  1762. }
  1766. void __fastcall TMainForm::MakeSOMButtonClick(TObject *Sender)
  1767. {
  1768.         MakeSOM();
  1769. }
  1770. //---------------------------------------------------------------------------
  1773. void __fastcall TMainForm::MakeSOM()
  1774. {
  1775.      int i,j,y;
  1776.      double Best, Val;
  1778.      AnsiString DataFileName = AnsiString(ClusterName) + "_SOM";
  1780.      int *GeneGroup     = ivector(1,Rows);
  1781.      int *SOMGeneOrder  = ivector(1,Rows);
  1783.      double ***GeneNodes;
  1785.      if (SOMOrganizeGenesCheckBox->Checked)
  1786.      {
  1788.         DataFileName += "_G" + AnsiString(SOMGenesXDim) + "-" + AnsiString(SOMGenesYDim);
  1791.         GeneNodes = SOM(SOMGenesXDim, SOMGenesYDim, GeneData, GeneMask, Rows, Columns, SOMGenesIterations);
  1793.         for (i=0;i<Rows;i++)
  1794.         {
  1795.                 GeneGroup[i+1]    = SOMGenesYDim;
  1796.                 SOMGeneOrder[i+1] = i;
  1797.                 Best = 0.4;
  1798.                 Best = -100;
  1800.                 for (y=0;y<SOMGenesYDim;y++)
  1801.                 {
  1802.                         Val = Correlation(GeneNodes,GeneData,GeneMask,false,0,y,i,Columns);
  1803.                         if (Val > Best)
  1804.                         {
  1805.                                 GeneGroup[i+1] = y;
  1806.                                 Best = Val;
  1807.                         }
  1808.                 }
  1810.                 GeneOrder[i] = GeneGroup[i+1];
  1811.         }
  1813.         sort2i(Rows,GeneGroup,SOMGeneOrder);
  1814.      }
  1815.      else
  1816.      {
  1817.         for (i=0;i<Rows;i++)
  1818.         {
  1819.                 GeneGroup[i+1] = 0;
  1820.                 SOMGeneOrder[i+1] = i;
  1821.         }
  1822.      }
  1825.      int *ArrayGroup = ivector(1,Columns);
  1826.      int *SOMArrayOrder = ivector(1,Columns);
  1828.      double ***ArrayNodes;
  1830.      if (SOMOrganizeArraysCheckBox->Checked)
  1831.      {
  1832.         double **ArrayData;
  1833.         bool **ArrayMask;
  1836.         ArrayData = new double*[Columns];
  1837.         ArrayMask = new bool*[Columns];
  1839.         for (i=0;i<Columns;i++)
  1840.         {
  1841.                 ArrayData[i] = new double[Rows];
  1842.                 ArrayMask[i] = new bool[Rows];
  1844.                 for (j=0;j<Rows;j++)
  1845.                 {
  1846.                         ArrayData[i][j] = GeneData[j][i];
  1847.                         ArrayMask[i][j] = GeneMask[j][i];
  1848.                 }
  1849.         }
  1852.         DataFileName += "_A" + AnsiString(SOMArraysXDim) + "-" + AnsiString(SOMArraysYDim);
  1854.         ArrayNodes = SOM(SOMArraysXDim, SOMArraysYDim, ArrayData, ArrayMask, Columns, Rows, SOMArraysIterations);
  1857.         for (i=0;i<Columns;i++)
  1858.         {
  1859.                 ArrayGroup[i+1]    = SOMArraysYDim;
  1860.                 SOMArrayOrder[i+1] = i;
  1861.                 Best = 0.4;
  1862.                 Best = -100;
  1864.                 for (y=0;y<SOMArraysYDim;y++)
  1865.                 {
  1866.                         Val = Correlation(ArrayNodes,ArrayData,ArrayMask,false,0,y,i,Rows);
  1867.                         if (Val > Best)
  1868.                         {
  1869.                                 ArrayGroup[i+1] = y;
  1870.                                 Best = Val;
  1871.                         }
  1872.                 }
  1874.                 ArrayOrder[i] = ArrayGroup[i+1];
  1875.         }
  1877.         sort2i(Columns,ArrayGroup,SOMArrayOrder);
  1879.         for (i=0;i<Columns;i++)
  1880.         {
  1881.                 delete ArrayData[i];
  1882.                 delete ArrayMask[i];
  1883.         }
  1885.         delete ArrayData;
  1886.         delete ArrayMask;
  1888.      }
  1889.      else
  1890.      {
  1891.         for (i=0;i<Columns;i++)
  1892.         {
  1893.                 ArrayGroup[i+1] = 0;
  1894.                 SOMArrayOrder[i+1] = i;
  1895.         }
  1896.      }
  1898.      if (SOMOrganizeGenesCheckBox->Checked)
  1899.      {
  1901.         TStringList *GeneOutList = new TStringList();
  1903.         AnsiString OutString = "NODE";
  1905.         for (i=0;i<Columns;i++)
  1906.         {
  1907.                 OutString += "t";
  1908.                 OutString += AnsiString(Headers->Strings[InColumn[SOMArrayOrder[i+1]]]);
  1909.         }
  1911.         GeneOutList->Add(OutString);
  1913.         for (i=0;i<SOMGenesYDim;i++)
  1914.         {
  1915.                 AnsiString TmpString = "NODE" + AnsiString(i);
  1917.                 for (j=0;j<Columns;j++)
  1918.                 {
  1919.                         TmpString += "t" + AnsiString(GeneNodes[0][i][SOMArrayOrder[j+1]]);
  1920.                 }
  1922.                 GeneOutList->Add(TmpString);
  1923.         }
  1925.         AnsiString GeneNodeFileName = DataFileName + ".GNF";
  1927.         GeneOutList->SaveToFile(GeneNodeFileName);
  1929.         delete GeneOutList;
  1931.         for (i=0;i<SOMGenesXDim;i++)
  1932.         {
  1933.                 for (j=0; j<SOMGenesYDim; j++)
  1934.                 {
  1935.                         delete GeneNodes[i][j];
  1936.                 }
  1937.                 delete GeneNodes[i];
  1938.         }
  1939.         delete GeneNodes;
  1940.      }
  1942.      if (SOMOrganizeArraysCheckBox->Checked)
  1943.      {
  1944.         TStringList *ArrayOutList = new TStringList();
  1946.         AnsiString OutString = Headers->Strings[0] + "tNAME";
  1948.         for (i=0;i<SOMArraysYDim;i++)
  1949.         {
  1950.                 OutString += "tNode" + AnsiString(i);
  1951.         }
  1953.         ArrayOutList->Add(OutString);
  1955.         for (i=0;i<Rows;i++)
  1956.         {
  1957.                 int index = SOMGeneOrder[i+1];
  1959.                 AnsiString TmpString = AnsiString(UniqID[index]) + "t" + AnsiString(GeneName[index]);
  1961.                 for (j=0;j<SOMArraysYDim;j++)
  1962.                 {
  1963.                         TmpString += "t" + AnsiString(ArrayNodes[0][j][SOMGeneOrder[i+1]]);
  1964.                 }
  1966.                 ArrayOutList->Add(TmpString);
  1967.         }
  1969.         AnsiString ArrayNodeFileName = DataFileName + ".ANF";
  1971.         ArrayOutList->SaveToFile(ArrayNodeFileName);
  1973.         for (i=0;i<SOMArraysXDim;i++)
  1974.         {
  1975.                 for (j=0; j<SOMArraysYDim; j++)
  1976.                 {
  1977.                         delete ArrayNodes[i][j];
  1978.                 }
  1979.                 delete ArrayNodes[i];
  1980.         }
  1981.         delete ArrayNodes;
  1983.         delete ArrayOutList;
  1984.      }
  1986.      /*
  1988.      float *Set1 = vector(1,Columns);
  1989.      float *Set2 = vector(1,Columns);
  1991.      float KSD,KSP;
  1993.      double *Prob = new double[Rows];
  1995.      int Count1, Count2;
  1997.      for (i=0;i<Rows;i++)
  1998.      {
  1999.          Count1 = 0;
  2000.          Count2 = 0;
  2001.          for (j=0;j<Columns;j++)
  2002.          {
  2003.              if (GeneMask[i][j])
  2004.              {
  2005.                 if (ArrayGroup[j+1] < SOMArraysYDim/2)
  2006.                 {
  2007.                    Count1++;
  2008.                    Set1[Count1] = GeneData[i][j];
  2009.                 }
  2010.                 else
  2011.                 {
  2012.                     Count2++;
  2013.                     Set2[Count2] = GeneData[i][j];
  2014.                 }
  2015.              }
  2016.          }
  2017.          kstwo(Set1,Count1,Set2,Count2,&KSD,&KSP);
  2018.          Prob[i] = KSP;
  2019.      } */
  2022.     TStringList *DataFile = new TStringList();
  2024.     AnsiString OutString = "";
  2026.     OutString += Headers->Strings[0] + AnsiString("t");
  2027.     OutString += AnsiString("NAME") + AnsiString("t");
  2028.     OutString += "GWEIGHT";
  2030.     // Now add headers for data columns
  2032.     for (i=0;i<Columns;i++)
  2033.     {
  2034.         OutString += "t";
  2035.         OutString += AnsiString(Headers->Strings[InColumn[SOMArrayOrder[i+1]]]);
  2036.     }
  2038.     DataFile->Add(OutString);
  2040.     {
  2041.         OutString = AnsiString("EWEIGHT");
  2042.         OutString += AnsiString("t");
  2043.         OutString += AnsiString("t");
  2045.         for (i=0;i<Columns;i++)
  2046.         {
  2047.             OutString += "t" + AnsiString(ArrayGroup[i+1]);
  2048.         }
  2049.     }
  2051.     DataFile->Add(OutString);
  2053.     int index, colindex;
  2055.     for (i=0;i<Rows;i++)
  2056.     {
  2057.         index = SOMGeneOrder[i+1];
  2059.         OutString = "";
  2061.         OutString += AnsiString(UniqID[index]) + "t" + AnsiString(GeneName[index]);
  2062.         OutString += "t" + AnsiString(GeneGroup[i+1]);
  2063.         //OutString += "t" + AnsiString(Prob[index]);
  2065.         for (j=0;j<Columns;j++)
  2066.         {
  2067.             colindex = SOMArrayOrder[j+1];
  2069.             if (GeneMask[index][colindex] == true)
  2070.             {
  2071.                 OutString += "t" + AnsiString(GeneData[index][colindex]);
  2072.             }
  2073.             else
  2074.             {
  2075.                 OutString += "t";
  2076.             }
  2077.         }
  2078.         DataFile->Add(OutString);
  2079.     }
  2081.     DataFileName += ".txt";
  2083.     DataFile->SaveToFile(DataFileName);
  2085.     free_ivector(SOMGeneOrder,1,Rows);
  2086.     free_ivector(SOMArrayOrder,1,Columns);
  2088.     free_ivector(GeneGroup,1,Rows);
  2089.     free_ivector(ArrayGroup,1,Columns);
  2091.     //free_vector(Set1,1,Columns);
  2092.     //free_vector(Set2,1,Columns);
  2094.     //delete Prob;
  2096. }
  2097. //---------------------------------------------------------------------------
  2099. void __fastcall TMainForm::SOMGenesXDimEditExit(TObject *Sender)
  2100. {
  2101.         int TempVal = SOMGenesXDim;
  2103.         try
  2104.         {
  2105.                 SOMGenesXDim = SOMGenesXDimEdit->Text.ToInt();
  2106.         }
  2107.         catch (EConvertError &E)
  2108.         {
  2109.                 SOMGenesXDim = TempVal;
  2110.         }
  2112.         SOMGenesXDimEdit->Text = SOMGenesXDim;
  2113. }
  2114. //---------------------------------------------------------------------------
  2115. void __fastcall TMainForm::SOMGenesYDimEditExit(TObject *Sender)
  2116. {
  2117.         int TempVal = SOMGenesYDim;
  2119.         try
  2120.         {
  2121.                 SOMGenesYDim = SOMGenesYDimEdit->Text.ToInt();
  2122.         }
  2123.         catch (EConvertError &E)
  2124.         {
  2125.                 SOMGenesYDim = TempVal;
  2126.         }
  2128.         SOMGenesYDimEdit->Text = SOMGenesYDim;
  2129. }
  2130. //---------------------------------------------------------------------------
  2131. void __fastcall TMainForm::SOMGenesTauEditExit(TObject *Sender)
  2132. {
  2133.         double TempVal = SOMGenesTau;
  2135.         try
  2136.         {
  2137.                 SOMGenesTau = SOMGenesTauEdit->Text.ToDouble();
  2138.         }
  2139.         catch  (EConvertError &E)
  2140.         {
  2141.                 SOMGenesTau = TempVal;
  2142.         }
  2144.         SOMGenesTauEdit->Text = SOMGenesTau;
  2145. }
  2146. //---------------------------------------------------------------------------
  2147. void __fastcall TMainForm::SOMGenesIterationsEditExit(TObject *Sender)
  2148. {
  2149.         int TempVal = SOMGenesIterations;
  2151.         try
  2152.         {
  2153.                 SOMGenesIterations = SOMGenesIterationsEdit->Text.ToInt();
  2154.         }
  2155.         catch  (EConvertError &E)
  2156.         {
  2157.                 SOMGenesIterations = TempVal;
  2158.         }
  2160.         SOMGenesIterationsEdit->Text = SOMGenesIterations;
  2161. }
  2162. //---------------------------------------------------------------------------
  2164. void __fastcall TMainForm::SOMArraysXDimEditExit(TObject *Sender)
  2165. {
  2166.         int TempVal = SOMArraysXDim;
  2168.         try
  2169.         {
  2170.                 SOMArraysXDim = SOMArraysXDimEdit->Text.ToInt();
  2171.         }
  2172.         catch (EConvertError &E)
  2173.         {
  2174.                 SOMArraysXDim = TempVal;
  2175.         }
  2177.         SOMArraysXDimEdit->Text = SOMArraysXDim;
  2178. }
  2179. //---------------------------------------------------------------------------
  2180. void __fastcall TMainForm::SOMArraysYDimEditExit(TObject *Sender)
  2181. {
  2182.         int TempVal = SOMArraysYDim;
  2184.         try
  2185.         {
  2186.                 SOMArraysYDim = SOMArraysYDimEdit->Text.ToInt();
  2187.         }
  2188.         catch (EConvertError &E)
  2189.         {
  2190.                 SOMArraysYDim = TempVal;
  2191.         }
  2193.         SOMArraysYDimEdit->Text = SOMArraysYDim;
  2194. }
  2195. //---------------------------------------------------------------------------
  2196. void __fastcall TMainForm::SOMArraysTauEditExit(TObject *Sender)
  2197. {
  2198.         double TempVal = SOMArraysTau;
  2200.         try
  2201.         {
  2202.                 SOMArraysTau = SOMArraysTauEdit->Text.ToDouble();
  2203.         }
  2204.         catch  (EConvertError &E)
  2205.         {
  2206.                 SOMArraysTau = TempVal;
  2207.         }
  2209.         SOMArraysTauEdit->Text = SOMArraysTau;
  2210. }
  2211. //---------------------------------------------------------------------------
  2212. void __fastcall TMainForm::SOMArraysIterationsEditExit(TObject *Sender)
  2213. {
  2214.         int TempVal = SOMArraysIterations;
  2216.         try
  2217.         {
  2218.                 SOMArraysIterations = SOMArraysIterationsEdit->Text.ToInt();
  2219.         }
  2220.         catch  (EConvertError &E)
  2221.         {
  2222.                 SOMArraysIterations = TempVal;
  2223.         }
  2225.         SOMArraysIterationsEdit->Text = SOMArraysIterations;
  2226. }
  2227. //---------------------------------------------------------------------------
  2229. void __fastcall TMainForm::DoSVDButtonClick(TObject *Sender)
  2230. {
  2231.     MakeSVD();
  2232. }
  2234. //---------------------------------------------------------------------------
  2235. void __fastcall TMainForm::MakeSVD()
  2236. {
  2238.     StatusBar1->SimpleText = "Processing Data for SVD";
  2240. float **u;
  2241. float **v;
  2242. float *w;
  2244. int m,n;
  2246. float cutoff;
  2248. n = Columns;
  2249. m = Rows;
  2251. u = matrix(1,m,1,n);
  2252. v = matrix(1,n,1,n);
  2253. w = vector(1,n);
  2255. float *magn = vector(1,m);
  2257. int i,j,k;
  2259. float Mag;
  2261. for (int Row=0;Row<Rows;Row++)
  2262. {
  2263. Mag  = 0;
  2265. for (int Column=0;Column<Columns;Column++)
  2266. {
  2267. if (GeneMask[Row][Column])
  2268. {
  2269. Mag += pow(GeneData[Row][Column],2.0);
  2270. }
  2271. }
  2273. Mag = sqrt(Mag);
  2275. if (Mag == 0)
  2276. {
  2277. Mag = 1;
  2278. }
  2280. magn[Row+1] = Mag;
  2282. for (int Column=0;Column<Columns;Column++)
  2283. {
  2284. if (GeneMask[Row][Column])
  2285. {
  2286. u[Row+1][Column+1] = GeneData[Row][Column] / Mag;
  2287. }
  2288. else
  2289. {
  2290. u[Row+1][Column+1] = 0;
  2291. }
  2292. }
  2293. }
  2295. StatusBar1->SimpleText = "Making SVD";
  2297. svdcmp(u,m,n,w,v);
  2299.     int *svdorder = ivector(1,n);
  2300.     float *svdsortval = vector(1,n);
  2302.     for (i=1;i<=n;i++)
  2303.     {
  2304.         svdorder[i] = i;
  2305.         svdsortval[i] = -w[i];
  2306.     }
  2308.     sort2fi(n,svdsortval,svdorder);
  2310.     StatusBar1->SimpleText = "Saving SVD Files";
  2312.     TStringList *OutList = new TStringList();
  2313.     AnsiString OutString;
  2314.     AnsiString FileName;
  2316.     OutList->Clear();
  2318.     OutString = "";
  2319.     OutString += "EIGVALUE" + AnsiString("t");
  2320.     OutString += AnsiString("NAME") + AnsiString("t");
  2321.     OutString += "GWEIGHT";
  2323.     for (int Column=0;Column<Columns;Column++)
  2324.     {
  2325.         OutString += "t";
  2326.         OutString += AnsiString(Headers->Strings[InColumn[Column]]);
  2327.     }
  2329.     OutList->Add(OutString);
  2331.     for (int Row=1;Row<=Columns;Row++)
  2332.     {
  2333.         OutString = "";
  2335.         OutString += AnsiString(w[svdorder[Row]]) + "t" + AnsiString(w[svdorder[Row]]) + "t1";
  2337.         for (int Column=1;Column<=Columns;Column++)
  2338.         {
  2339.             OutString += "t" + AnsiString(v[svdorder[Column]][svdorder[Row]]);
  2340.         }
  2342.         OutList->Add(OutString);
  2343.     }
  2345.     FileName = JobNameEdit->Text + "_svv.txt";
  2346.     OutList->SaveToFile(FileName);
  2348.     OutList->Clear();
  2350.     OutString = "";
  2351.     OutString += Headers->Strings[0] + AnsiString("t");
  2352.     OutString += AnsiString("NAME") + AnsiString("t");
  2353.     OutString += "GWEIGHT";
  2355.     for (int Column=1;Column<=Columns;Column++)
  2356.     {
  2357.         OutString += "t";
  2358.         OutString += AnsiString(w[svdorder[Column]]);
  2359.     }
  2361.     OutList->Add(OutString);
  2363.     for (int Row=1;Row<=Rows;Row++)
  2364.     {
  2365.         OutString = "";
  2367.         OutString += UniqID[Row-1] + "t" + GeneName[Row-1] + "t1";
  2369.         for (int Column=1;Column<=Columns;Column++)
  2370.         {
  2371.             OutString += "t" + AnsiString(u[Row][svdorder[Column]]);
  2372.         }
  2374.         OutList->Add(OutString);
  2375.     }
  2377.     FileName = JobNameEdit->Text + "_svu.txt";
  2378.     OutList->SaveToFile(FileName);
  2380.     double Sum2 = 0;
  2382.     for (int Column=1; Column<=Columns; Column++)
  2383.     {
  2384.         Sum2 += pow(w[Column],2.0);
  2385.     }
  2387.     double Fractal = 0;
  2389.     for (int Column=1; Column<=Columns; Column++)
  2390.     {
  2391.         double Val = pow(w[Column],2.0)/Sum2;
  2392.         Fractal += Val * log(Val);
  2393.     }
  2395.     Fractal /= -log(Columns);
  2397.     FractalLabel->Caption = Fractal;
  2399.     free_matrix(u,1,m,1,n);
  2400.     free_matrix(v,1,n,1,n);
  2401.     free_vector(w,1,n);
  2402.     free_vector(magn,1,m);
  2404.     free_ivector(svdorder,1,n);
  2405.     free_vector(svdsortval,1,n);
  2407.     StatusBar1->SimpleText = "Done Computing SVD";
  2408. }
  2410. /* KMeans/KMediods Clustering */
  2412. void __fastcall TMainForm::KExecuteClick(TObject *Sender)
  2413. {
  2415.      int i,j,y;
  2416.      double Best, Val;
  2418.      AnsiString DataFileName = AnsiString(ClusterName) + "_K";
  2420.      int *GeneOrder;
  2422.      if (KOrganizeGenesCheckBox->Checked)
  2423.      {
  2425.         DataFileName += "_G" + AnsiString(GenesK);
  2426.         GeneOrder =  DoKMeans(GenesK,GeneData,GeneMask,Rows,Columns,GMaxKCycles,GKMethod->ItemIndex);
  2427.      }
  2428.      else
  2429.      {
  2430.         GeneOrder = new int[Rows];
  2431.         for (i=0;i<Rows;i++)
  2432.         {
  2433.                 GeneOrder[i] = i;
  2434.         }
  2435.      }
  2437.      int *ArrayOrder;
  2439.      if (KOrganizeArraysCheckBox->Checked)
  2440.      {
  2441.         double **ArrayData;
  2442.         bool **ArrayMask;
  2445.         ArrayData = new double*[Columns];
  2446.         ArrayMask = new bool*[Columns];
  2448.         for (i=0;i<Columns;i++)
  2449.         {
  2450.                 ArrayData[i] = new double[Rows];
  2451.                 ArrayMask[i] = new bool[Rows];
  2453.                 for (j=0;j<Rows;j++)
  2454.                 {
  2455.                         ArrayData[i][j] = GeneData[j][i];
  2456.                         ArrayMask[i][j] = GeneMask[j][i];
  2457.                 }
  2458.         }
  2460.         DataFileName += "_A" + AnsiString(ArraysK);
  2461.         ArrayOrder =  DoKMeans(ArraysK,ArrayData,ArrayMask,Columns,Rows,AMaxKCycles,AKMethod->ItemIndex);
  2463.         for (i=0;i<Columns;i++)
  2464.         {
  2465.                 delete ArrayData[i];
  2466.                 delete ArrayMask[i];
  2467.         }
  2469.         delete ArrayData;
  2470.         delete ArrayMask;
  2471.      }
  2472.      else
  2473.      {
  2474.         ArrayOrder = new int[Columns];
  2475.         for (i=0;i<Columns;i++)
  2476.         {
  2477.                 ArrayOrder[i] = i;
  2478.         }
  2479.      }
  2481.      TStringList *DataFile = new TStringList();
  2483.      AnsiString OutString = "";
  2485.      OutString += Headers->Strings[0] + AnsiString("t");
  2486.      OutString += AnsiString("NAME") + AnsiString("t");
  2487.      OutString += "GWEIGHT";
  2489.      // Now add headers for data columns
  2491.      for (i=0;i<Columns;i++)
  2492.      {
  2493.          OutString += "t";
  2494.          OutString += AnsiString(Headers->Strings[InColumn[ArrayOrder[i]]]);
  2495.      }
  2497.      DataFile->Add(OutString);
  2499.      {
  2500.         OutString = AnsiString("EWEIGHT");
  2501.         OutString += AnsiString("t");
  2502.         OutString += AnsiString("t");
  2504.         for (i=0;i<Columns;i++)
  2505.         {
  2506.             OutString += "t" + 1;
  2507.         }
  2508.     }
  2510.     DataFile->Add(OutString);
  2512.     int index, colindex;
  2514.     for (i=0;i<Rows;i++)
  2515.     {
  2516.         index = GeneOrder[i];
  2518.         OutString = "";
  2520.         OutString += AnsiString(UniqID[index]) + "t" + AnsiString(GeneName[index]);
  2521.         OutString += "t" + AnsiString(1);
  2522.         //OutString += "t" + AnsiString(Prob[index]);
  2524.         for (j=0;j<Columns;j++)
  2525.         {
  2526.             colindex = ArrayOrder[j];
  2528.             if (GeneMask[index][colindex] == true)
  2529.             {
  2530.                 OutString += "t" + AnsiString(GeneData[index][colindex]);
  2531.             }
  2532.             else
  2533.             {
  2534.                 OutString += "t";
  2535.             }
  2536.         }
  2537.         DataFile->Add(OutString);
  2538.     }
  2540.     DataFileName += ".txt";
  2542.     DataFile->SaveToFile(DataFileName);
  2544.     delete DataFile;
  2546.     delete GeneOrder;
  2547.     delete ArrayOrder;
  2549.     StatusBar1->SimpleText = "Done";
  2550. }
  2553. int * __fastcall TMainForm::DoKMeans(int K, double **KData, bool **KMask,
  2554.      int KRows, int KColumns, int KMaxIterations, int Method)
  2555. {
  2556.     double **NodeData = new double *[K];
  2557.     int **NodeDataCount = new int *[K];
  2559.     for (int i=0; i<K; i++)
  2560.     {
  2561.         NodeData[i] = new double[KColumns];
  2562.         NodeDataCount[i] = new int[KColumns];
  2563.     }
  2565.     int *NodeMap = new int[KRows];
  2567.     for (int i=0; i<KRows; i++)
  2568.     {
  2569.         NodeMap[i] = random(K);
  2570.     }
  2572.     int Iterations = 0;
  2573.     int NumMoved = 1;
  2575.     float **MedMatrix;
  2576.     int *MedCount;
  2578.     if (Method == 1)
  2579.     {
  2580.         MedMatrix = matrix(1,K,1,KRows);
  2581.         MedCount  = ivector(1,K);
  2582.     }
  2584.     while ((NumMoved > 0) && (Iterations < KMaxIterations) )
  2585.     {
  2586.         NumMoved = 0;
  2587.         Iterations ++;
  2589.         for (int i=0; i<K; i++)
  2590.         {
  2591.             for (int j=0; j<KColumns; j++)
  2592.             {
  2593.                 NodeData[i][j] = 0;
  2594.                 NodeDataCount[i][j] = 0;
  2595.             }
  2596.         }
  2598.         if (Method == 0)
  2599.         {
  2601.             for (int i=0; i<KRows; i++)
  2602.             {
  2603.                 for (int j=0; j<KColumns; j++)
  2604.                 {
  2605.                     if (KMask[i][j] == true)
  2606.                     {
  2607.                         NodeData[NodeMap[i]][j] += KData[i][j];
  2608.                         NodeDataCount[NodeMap[i]][j] ++;
  2609.                     }
  2610.                 }
  2611.             }
  2613.             for (int i=0; i<K; i++)
  2614.             {
  2615.                 for (int j=0; j<KColumns; j++)
  2616.                 {
  2617.                     if (NodeDataCount[i][j]> 0)
  2618.                     {
  2619.                         NodeData[i][j] /= NodeDataCount[i][j];
  2620.                     }
  2621.                 }
  2622.             }
  2623.         }
  2624.         else
  2625.         {
  2626.             for (int j=0; j<KColumns; j++)
  2627.             {
  2628.                 for (int i=0; i<K; i++)
  2629.                 {
  2630.                     MedCount[i+1] = 0;
  2631.                 }
  2633.                 for (int i=0; i<KRows; i++)
  2634.                 {
  2635.                     if (KMask[i][j] == true)
  2636.                     {
  2637.                         MedCount[NodeMap[i]+1]++;
  2638.                         MedMatrix[NodeMap[i]+1][MedCount[NodeMap[i]+1]] = KData[i][j];
  2639.                     }
  2640.                 }
  2642.                 for (int i=0; i<K; i++)
  2643.                 {
  2644.                     if (MedCount[i+1] > 0)
  2645.                     {
  2646.                         int index = (MedCount[i+1]+1)/2;
  2647.                         NodeData[i][j] = select(index,MedCount[i+1],MedMatrix[i+1]);
  2648.                     }
  2649.                     else
  2650.                     {
  2651.                         NodeData[i][j] = 0;
  2652.                     }
  2653.                 }
  2654.             }
  2655.         }
  2658.         for (int i=0; i<KRows; i++)
  2659.         {
  2660.             double BestCorr = -1;
  2661.             int BestNode = NodeMap[i];
  2663.             if (i % 100 == 0)
  2664.             {
  2665.                 StatusBar1->SimpleText = "Last Iteration (#" + AnsiString(Iterations) + ") Num Moved = " +
  2666.                     AnsiString(NumMoved) + ": Processed " + AnsiString(i) + " of " + AnsiString(KRows);
  2667.                 Application->ProcessMessages();
  2668.             }
  2670.             for (int j=0; j<K; j++)
  2671.             {
  2672.                 double Sum11 = 0;
  2673.                 double Sum12 = 0;
  2674.                 double Sum22 = 0;
  2676.                 for (int l=0; l<KColumns; l++)
  2677.                 {
  2678.                     if (KMask[i][l] == true)
  2679.                     {
  2680.                         Sum11 += pow(KData[i][l],2.0);
  2681.                         Sum22 += pow(NodeData[j][l],2.0);
  2682.                         Sum12 += KData[i][l] * NodeData[j][l];
  2683.                     }
  2684.                 }
  2686.                 double Denom = sqrt(Sum11 * Sum22);
  2688.                 if (Denom > 0)
  2689.                 {
  2690.                     double Corr = Sum12 / Denom;
  2692.                     if (Corr > BestCorr)
  2693.                     {
  2694.                         BestNode = j;
  2695.                         BestCorr = Corr;
  2696.                     }
  2697.                 }
  2698.             }
  2700.             if (BestNode != NodeMap[i])
  2701.             {
  2702.                 NodeMap[i] = BestNode;
  2703.                 NumMoved++;
  2704.             }
  2705.         }
  2707.         StatusBar1->SimpleText = "Last Iteration (#" + AnsiString(Iterations) + ") Num Moved = " +
  2708.             AnsiString(NumMoved);
  2709.         Application->ProcessMessages();
  2710.     }
  2713.     for (int i=0; i<K; i++)
  2714.     {
  2715.         delete NodeData[i];
  2716.         delete NodeDataCount[i];
  2717.     }
  2719.     delete NodeData;
  2720.     delete NodeDataCount;
  2722.     if (Method == 1)
  2723.     {
  2724.         free_matrix(MedMatrix,1,K,1,KRows);
  2725.         free_ivector(MedCount,1,K);
  2726.     }
  2728.     float * FinNode =  vector(1,KRows);
  2729.     int * FinPos  =  ivector(1,KRows);
  2731.     for (int i=0; i<KRows; i++)
  2732.     {
  2733.         FinNode[i+1] = NodeMap[i];
  2734.         FinPos[i+1] = i;
  2735.     }
  2737.     sort2fi(KRows,FinNode,FinPos);
  2739.     for (int i=0; i<KRows; i++)
  2740.     {
  2741.         NodeMap[i] = FinPos[i+1];
  2742.     }
  2744.     free_vector(FinNode,1,KRows);
  2745.     free_ivector(FinPos,1,KRows);
  2747.     return NodeMap;
  2748. }
  2749. //---------------------------------------------------------------------------
  2752. void __fastcall TMainForm::GenesKEditExit(TObject *Sender)
  2753. {
  2754.         int TempVal = GenesK;
  2756.         try
  2757.         {
  2758.                 GenesK = GenesKEdit->Text.ToInt();
  2759.         }
  2760.         catch (EConvertError &E)
  2761.         {
  2762.                 GenesK = TempVal;
  2763.         }
  2765.         GenesKEdit->Text = GenesK;
  2766. }
  2767. //---------------------------------------------------------------------------
  2769. void __fastcall TMainForm::ArraysKEditExit(TObject *Sender)
  2770. {
  2771.         int TempVal = ArraysK;
  2773.         try
  2774.         {
  2775.                 ArraysK = ArraysKEdit->Text.ToInt();
  2776.         }
  2777.         catch (EConvertError &E)
  2778.         {
  2779.                 ArraysK = TempVal;
  2780.         }
  2782.         ArraysKEdit->Text = ArraysK;
  2783. }
  2784. //---------------------------------------------------------------------------
  2786. void __fastcall TMainForm::GMaxKCyclesEditExit(TObject *Sender)
  2787. {
  2788.         int TempVal = GMaxKCycles;
  2790.         try
  2791.         {
  2792.                 GMaxKCycles = GMaxKCyclesEdit->Text.ToInt();
  2793.         }
  2794.         catch (EConvertError &E)
  2795.         {
  2796.                 GMaxKCycles = TempVal;
  2797.         }
  2799.         GMaxKCyclesEdit->Text = GMaxKCycles;
  2800. }
  2801. //---------------------------------------------------------------------------
  2803. void __fastcall TMainForm::AMaxKCyclesEditExit(TObject *Sender)
  2804. {
  2805.         int TempVal = AMaxKCycles;
  2807.         try
  2808.         {
  2809.                 AMaxKCycles = AMaxKCyclesEdit->Text.ToInt();
  2810.         }
  2811.         catch (EConvertError &E)
  2812.         {
  2813.                 AMaxKCycles = TempVal;
  2814.         }
  2816.         AMaxKCyclesEdit->Text = AMaxKCycles;
  2817. }
  2818. //---------------------------------------------------------------------------
  2821. void __fastcall TMainForm::AboutButtonClick(TObject *Sender)
  2822. {
  2823.     AboutForm->Show();
  2824. }