Changeset 12320 for branches/HeuristicLab.VariableInteractionNetworks/HeuristicLab.VariableInteractionNetworks.Views/3.3/VariableInteractionNetworkView.cs

Timestamp:

04/16/15 12:32:26 (10 years ago)

Author:

arapeanu

Message:

#2288: Added sliders functionality, dialog box for setting the number of repetitions for each batch + modified node importance weighting

File:

• branches/HeuristicLab.VariableInteractionNetworks/HeuristicLab.VariableInteractionNetworks.Views/3.3/VariableInteractionNetworkView.cs (modified) (1 diff)

branches/HeuristicLab.VariableInteractionNetworks/HeuristicLab.VariableInteractionNetworks.Views/3.3/VariableInteractionNetworkView.cs

@@ -36 +36 @@
 using System.Collections;
 
-namespace HeuristicLab.VariableInteractionNetworks.Views {
-  [View("Variable Interaction Network")]
-  [Content(typeof(RunCollection), IsDefaultView = false)]
-
-  public sealed partial class VariableInteractionNetworkView : AsynchronousContentView {
-    private const string variableImpactResultName = "Variable impacts";
-    private const string TrainingBestSolutionParameterName = "Best training solution";
-    public new RunCollection Content {
-      get { return (RunCollection)base.Content; }
-      set { base.Content = value; }
+namespace HeuristicLab.VariableInteractionNetworks.Views
+{
+    [View("Variable Interaction Network")]
+    [Content(typeof(RunCollection), IsDefaultView = false)]
+
+    public sealed partial class VariableInteractionNetworkView : AsynchronousContentView
+    {
+        private const string variableImpactResultName = "Variable impacts";
+        private const string TrainingBestSolutionParameterName = "Best training solution";
+
+        public new RunCollection Content
+        {
+            get { return (RunCollection)base.Content; }
+            set { base.Content = value; }
+        }
+
+        public VariableInteractionNetworkView()
+        {
+            InitializeComponent();
+        }
+
+        internal class NoFocusTrackBar : System.Windows.Forms.TrackBar
+        {
+            [System.Runtime.InteropServices.DllImport("user32.dll")]
+            public extern static int SendMessage(IntPtr hWnd, uint msg, int wParam, int lParam);
+
+            private static int MakeParam(int loWord, int hiWord)
+            {
+                return (hiWord << 16) | (loWord & 0xffff);
+            }
+
+            protected override void OnGotFocus(EventArgs e)
+            {
+                base.OnGotFocus(e);
+                SendMessage(this.Handle, 0x0128, MakeParam(1, 0x1), 0);
+            }
+        }
+
+        #region events
+
+        //  #region Event Handlers (Content)
+        protected override void OnContentChanged()
+        {
+            base.OnContentChanged();
+            if (Content == null)
+            {
+                // TODO: Add code when content has been changed and is null
+            }
+            else
+            {
+                // TODO: Add code when content has been changed and is not null
+                viewHost2.Content = CalculateNodeImportance(CalculateAdjacencyMatrix());     
+                var adjMatrix = CalculateAdjacencyMatrix();
+                viewHost1.Content = adjMatrix;
+                viewHost3.Content = (DoubleMatrix)adjMatrix.Clone();
+                trackBar1.Minimum = (int)(1000 * GetMinNonNullElement(adjMatrix));
+                trackBar1.Maximum = (int)(1000 * (adjMatrix.Max()));
+            }
+        }
+        #endregion
+
+        protected override void SetEnabledStateOfControls()
+        {
+            base.SetEnabledStateOfControls();
+            // TODO: Enable or disable controls based on whether the content is null or the view is set readonly
+        }
+
+        #region Event Handlers (child controls)
+        // TODO: Put event handlers of child controls here.
+        #endregion
+
+        private DoubleMatrix CalculateAdjacencyMatrix()
+        {
+            var runCollection = Content;
+            var groupRunCollection = Content.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).ToList();
+
+            var allVariableImpacts = runCollection.Select(run => (DoubleMatrix)run.Results[variableImpactResultName]);
+            var variableNames = (from variableImpact in allVariableImpacts
+                                 from variableName in variableImpact.RowNames
+                                 select variableName).Distinct().ToArray();
+            var adjMatrix = new DoubleMatrix(variableNames.Length, variableNames.Length);
+
+            adjMatrix.RowNames = groupRunCollection.Select(x => x.Key);
+            adjMatrix.ColumnNames = adjMatrix.RowNames;
+            for (int j = 0; j < groupRunCollection.Count; ++j)
+            {
+                var g = groupRunCollection[j];
+                var matrix = CalculateAdjacencyRows(g);
+                var variables = new List<Tuple<string, double>>();
+                var columnNames = matrix.ColumnNames.ToList();
+
+                for (int i = 0; i < matrix.Columns; ++i)
+                {
+                    variables.Add(new Tuple<string, double>(columnNames[i], matrix[0, i]));
+                }
+                variables.Add(new Tuple<string, double>(g.Key, 0));
+                variables.Sort((a, b) => a.Item1.CompareTo(b.Item1));
+                for (int i = 0; i < variables.Count; ++i)
+                {
+                    adjMatrix[j, i] = variables[i].Item2;
+
+                }
+            }
+            return adjMatrix;
+        }
+
+        private DoubleMatrix CalculateAdjacencyRows(IEnumerable<IRun> runs)
+        {
+            IEnumerable<DoubleMatrix> allVariableImpacts = (from run in runs
+                                                            select run.Results[variableImpactResultName]).Cast<DoubleMatrix>();
+            var variableNames = (from variableImpact in allVariableImpacts
+                                 from variableName in variableImpact.RowNames
+                                 select variableName)
+                                              .Distinct().ToArray();
+
+            List<string> variableNamesList = (from variableName in variableNames
+                                              where GetVariableImpacts(variableName, allVariableImpacts).Any(x => !x.IsAlmost(0.0))
+                                              select variableName)
+                                             .ToList();
+
+            var runNames = runs.Select(x => x.Name).ToArray();
+            var runsArray = runs.ToArray();
+            DoubleMatrix varImpactMatrix = CalculateVariableImpactMatrix(runsArray, runNames);
+            var targetMatrix = new DoubleMatrix(1, variableNames.Length);
+
+            for (int i = 0; i < varImpactMatrix.Rows; ++i)
+            {
+                targetMatrix[0, i] = varImpactMatrix[i, runNames.Length];
+            }
+
+            targetMatrix.RowNames = new[] { "Target" };
+            targetMatrix.ColumnNames = variableNames;
+
+            return targetMatrix;
+        }
+
+        private DoubleMatrix UpdateAdjacencyMatrixByThresholdAndTargetVariable(double threshold, string targetVariable, DoubleMatrix adjMatrix)
+        {
+            var originalMatrix = (DoubleMatrix)viewHost1.Content;
+            var groupRunCollection = Content.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).ToList();
+            string[] targets = adjMatrix.RowNames.ToArray();
+            var targetIndex = Array.IndexOf(targets, targetVariable);
+
+            for (int j = 0; j < groupRunCollection.Count; ++j)
+            {
+                double originalValue = originalMatrix[targetIndex, j];
+                adjMatrix[targetIndex, j] = (originalValue <= Math.Max(threshold, Double.Parse(genThreshold.Text))) ? 0 : originalValue;
+            }
+            return adjMatrix;
+        }
+
+        private DoubleMatrix UpdateAdjacencyMatrixByThreshold(double threshold, DoubleMatrix adjMatrix)
+        {
+         //   var updatedMatrix = (DoubleMatrix) adjMatrix.Clone();
+            var originalMatrix = (DoubleMatrix)viewHost1.Content;
+            var groupRunCollection = Content.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).ToList();
+
+            for (int i = 0; i < adjMatrix.Rows; ++i)
+            {
+                for (int j = 0; j < adjMatrix.Columns; ++j)
+                {
+                    double originalValue = originalMatrix[i, j];
+                    adjMatrix[i, j] = originalValue <= threshold ? 0 : originalValue;
+                }
+            }
+            return adjMatrix;
+        }
+
+        private double GetMinNonNullElement(DoubleMatrix adjMatrix)
+        {
+            double min = adjMatrix.Max();
+            for (int i = 0; i < adjMatrix.Rows; i++)
+            {
+                for (int j = 0; j < adjMatrix.Columns; j++)
+                {                  
+                    min = (min > adjMatrix[i, j] && adjMatrix[i, j] != 0) ? adjMatrix[i, j] : min;
+                }
+            }
+            return min;
+        }
+
+        private double GetMaxFromRow(int rowIndex, DoubleMatrix adjMatrix)
+        {
+            double max = adjMatrix.Min();
+            for (int j = 0; j < adjMatrix.Columns; ++j)
+            {
+                max = (max < adjMatrix[rowIndex, j] && adjMatrix[rowIndex, j] != 0) ? adjMatrix[rowIndex, j] : max;
+            }
+            return max;
+        }
+
+        private DoubleMatrix CalculateNodeImportance(DoubleMatrix adjMatrix)
+        {
+            DoubleMatrix nodeImportance = new DoubleMatrix(adjMatrix.Rows, 1);
+            var variables = new List<Tuple<string, double>>();
+            var rowNames = adjMatrix.RowNames.ToList();
+            var groupRunCollection = Content.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).ToList();
+            double[] meanQuality = new double[groupRunCollection.Count];
+
+            for (int j = 0; j < groupRunCollection.Count; ++j)
+            {
+                var g = groupRunCollection[j];
+                meanQuality[j] = g.Average(x => ((IRegressionSolution)x.Results[TrainingBestSolutionParameterName]).TrainingRSquared);
+            }
+
+            for (int i = 0; i < adjMatrix.Columns; ++i)
+            {
+                for (int j = 0; j < adjMatrix.Rows; ++j)
+                {
+                    nodeImportance[i, 0] += adjMatrix[j, i] * meanQuality[j];
+                }
+                nodeImportance[i, 0] /= (adjMatrix.Rows - 1);
+                variables.Add(new Tuple<string, double>(rowNames[i], nodeImportance[i, 0]));
+            }
+
+            variables.Sort((b, a) => a.Item2.CompareTo(b.Item2));
+
+            for (int i = 0; i < nodeImportance.Rows; ++i)
+            {
+                nodeImportance[i, 0] = variables[i].Item2;
+                rowNames[i] = variables[i].Item1;
+            }
+
+            nodeImportance.RowNames = rowNames;
+            nodeImportance.ColumnNames = new[] { "Node Importance" };
+            return nodeImportance;
+        }
+
+        //adapted from RunCollectionVariableImpactView
+        private DoubleMatrix CalculateVariableImpactMatrix(IRun[] runs, string[] runNames)
+        {
+            IEnumerable<DoubleMatrix> allVariableImpacts = (from run in runs
+                                                            select run.Results[variableImpactResultName]).Cast<DoubleMatrix>();
+            IEnumerable<string> variableNames = (from variableImpact in allVariableImpacts
+                                                 from variableName in variableImpact.RowNames
+                                                 select variableName).Distinct();
+
+            // filter variableNames: only include names that have at least one non-zero value in a run
+            List<string> variableNamesList = (from variableName in variableNames
+                                              where GetVariableImpacts(variableName, allVariableImpacts).Any(x => !x.IsAlmost(0.0))
+                                              select variableName).ToList();
+
+            List<string> columnNames = new List<string>(runNames);
+            columnNames.Add("Mean");
+
+            int numberOfRuns = runs.Length;
+
+            DoubleMatrix matrix = new DoubleMatrix(variableNamesList.Count, numberOfRuns + 1);
+            matrix.SortableView = true;
+            matrix.ColumnNames = columnNames;
+
+            List<List<double>> variableImpactsOverRuns = (from variableName in variableNamesList
+                                                          select GetVariableImpacts(variableName, allVariableImpacts).ToList()).ToList();
+
+            for (int row = 0; row < variableImpactsOverRuns.Count; row++)
+            {
+                matrix[row, numberOfRuns] = Math.Round(variableImpactsOverRuns[row].Average(), 3);
+            }
+
+            // fill matrix with impacts from runs
+            for (int i = 0; i < runs.Length; i++)
+            {
+                IRun run = runs[i];
+                DoubleMatrix runVariableImpacts = (DoubleMatrix)run.Results[variableImpactResultName];
+                for (int j = 0; j < runVariableImpacts.Rows; j++)
+                {
+                    int rowIndex = variableNamesList.FindIndex(s => s == runVariableImpacts.RowNames.ElementAt(j));
+                    if (rowIndex > -1)
+                    {
+                        matrix[rowIndex, i] = Math.Round(runVariableImpacts[j, 0], 3);
+                    }
+                }
+            }
+            return matrix;
+        }
+
+        //taken from RunCollectionVariableImpactView
+        private IEnumerable<double> GetVariableImpacts(string variableName, IEnumerable<DoubleMatrix> allVariableImpacts)
+        {
+            foreach (DoubleMatrix runVariableImpacts in allVariableImpacts)
+            {
+                int row = 0;
+                foreach (string rowName in runVariableImpacts.RowNames)
+                {
+                    if (rowName == variableName)
+                        yield return runVariableImpacts[row, 0];
+                    row++;
+                }
+            }
+        }
+
+        private void trackBar1_ValueChanged(object sender, EventArgs e)
+        {
+            genThreshold.Text = (0.001 * trackBar1.Value).ToString();
+            textBox1.Text = (0.001 * trackBar1.Minimum).ToString();
+            textBox2.Text = (0.001 * trackBar1.Maximum).ToString();
+            viewHost3.Content = UpdateAdjacencyMatrixByThreshold(0.001 * trackBar1.Value, (DoubleMatrix)viewHost3.Content);
+        }
+
+        private void mouseDownEvent(TrackBar tb, MouseEventArgs e)
+        {
+                double percentage = (double)e.X / (double)(tb.Width - 6);
+                double clickPos = percentage * (tb.Maximum - tb.Minimum);
+                try
+                {
+                    tb.Value = (int)clickPos + tb.Minimum;
+                }
+                catch
+                {
+                    MessageBox.Show("Value outside range!");
+                    return;
+                }
+        }
+
+        private void trackBar1_MouseDown(object sender, MouseEventArgs e)
+        {
+            mouseDownEvent(trackBar1, e);
+        }
+
+        private void trackBar2_MouseDown(object sender, MouseEventArgs e)
+        {
+            if (targetVariablesCombo.SelectedIndex < 0)
+            {
+                return;
+            }
+            else
+            {
+                mouseDownEvent(trackBar2, e);
+            }
+        }
+
+        private void trackBar2_ValueChanged(object sender, EventArgs e)
+        {
+            targetThreshold.Text = (0.001 * trackBar2.Value).ToString();
+
+            if (targetVariablesCombo.SelectedIndex < 0)
+            {
+                MessageBox.Show("Please select target variable!");
+                return;
+            }
+            else
+            {
+                string selectedItem = (string)targetVariablesCombo.Items[targetVariablesCombo.SelectedIndex];
+                viewHost3.Content = UpdateAdjacencyMatrixByThresholdAndTargetVariable(0.001 * trackBar2.Value, selectedItem, (DoubleMatrix)viewHost3.Content);
+            }
+        }
+
+        private void genThresholdEvent()
+        {
+            this.errorProvider.SetError(genThreshold, "");
+
+            if (genThreshold.Text != "")
+            {
+                if (Double.Parse(genThreshold.Text) >= GetMinNonNullElement((DoubleMatrix)viewHost1.Content) && Double.Parse(genThreshold.Text) <= ((DoubleMatrix)viewHost1.Content).Max())
+                {
+                    genThreshold.Select(genThreshold.Text.Length, 0);
+                    trackBar1.Value = (int)(1000 * Double.Parse(genThreshold.Text));
+                    viewHost3.Content = UpdateAdjacencyMatrixByThreshold(Double.Parse(genThreshold.Text), (DoubleMatrix)viewHost3.Content);
+                }
+                else
+                {
+                    this.errorProvider.SetError(genThreshold, "Value out of range!");
+                }
+            }
+            else
+            {
+                MessageBox.Show("Please select a threshold!");
+                this.errorProvider.SetError(genThreshold, "");
+                return;
+            }
+        }
+
+        private void genThreshold_TextChanged(object sender, EventArgs e)
+        {
+            genThresholdEvent();
+        }
+
+        private void genThreshold_KeyDown(object sender, KeyEventArgs e)
+        {
+            if (e.KeyCode == Keys.Enter)
+                genThresholdEvent();        
+        }
+
+        private void targetThresholdEvent()
+        {
+            this.errorProvider2.SetError(targetThreshold, "");
+
+            if (targetVariablesCombo.SelectedIndex < 0)
+            {
+                return;
+            }
+            else
+            {
+                string selectedItem = (string)targetVariablesCombo.Items[targetVariablesCombo.SelectedIndex];
+                if (Double.Parse(targetThreshold.Text) >= Double.Parse(textBox3.Text) && Double.Parse(targetThreshold.Text) <= Double.Parse(textBox4.Text))
+                {
+                    trackBar2.Value = (int)(1000 * Double.Parse(targetThreshold.Text));
+                }
+                else
+                {
+                    this.errorProvider2.SetError(targetThreshold, "Value out of range!");
+                    return;
+                }
+            }
+        }
+
+        private void targetThreshold_TextChanged(object sender, EventArgs e)
+        {
+            targetThresholdEvent();
+        }
+
+        private void targetThreshold_KeyDown(object sender, KeyEventArgs e)
+        {
+            if (e.KeyCode == Keys.Enter)
+            {
+                targetThresholdEvent();
+            }
+        }
+
+        private void targetVariablesCombo_Dropdown(object sender, System.EventArgs e)
+        {
+            targetVariablesCombo.Items.Clear();
+            string[] targetVariables = ((DoubleMatrix)viewHost3.Content).RowNames.ToArray();
+            targetVariablesCombo.Items.AddRange(targetVariables);
+        }
+
+        private void targetVariablesCombo_SelectedIndexChanged(object sender, System.EventArgs e)
+        {
+            var targetIndex = targetVariablesCombo.SelectedIndex;
+            string selectedItem = (string)targetVariablesCombo.Items[targetIndex];
+            trackBar2.Minimum = 0;
+            trackBar2.Maximum = (int)(1000 * GetMaxFromRow(targetIndex, (DoubleMatrix)viewHost1.Content));
+            textBox3.Text = trackBar2.Minimum.ToString();
+            textBox4.Text = (0.001 * trackBar2.Maximum).ToString();
+            UpdateAdjacencyMatrixByThresholdAndTargetVariable(0.001 * trackBar2.Value, selectedItem, (DoubleMatrix)viewHost3.Content);
+        }
     }
-
-    public VariableInteractionNetworkView() {
-      InitializeComponent();
-    }
-
-    #region events
-    
-  //  #region Event Handlers (Content)
-    protected override void OnContentChanged() {
-      base.OnContentChanged();
-      if (Content == null) {
-        // TODO: Add code when content has been changed and is null
-      } else {
-        // TODO: Add code when content has been changed and is not null
-        CalculateAdjacencyMatrix();
-      }
-    }
-    #endregion
-
-    protected override void SetEnabledStateOfControls() {
-      base.SetEnabledStateOfControls();
-      // TODO: Enable or disable controls based on whether the content is null or the view is set readonly
-    }
-
-    #region Event Handlers (child controls)
-    // TODO: Put event handlers of child controls here.
-    #endregion
-
-    private void CalculateAdjacencyMatrix()
-    {
-        var runCollection = Content;
-        var groupRunCollection = Content.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).ToList();
-
-        var allVariableImpacts = runCollection.Select(run => (DoubleMatrix)run.Results[variableImpactResultName]);
-        var variableNames = (from variableImpact in allVariableImpacts
-                             from variableName in variableImpact.RowNames
-                             select variableName).Distinct().ToArray();
-        var adjMatrix = new DoubleMatrix(variableNames.Length, variableNames.Length);
-
-        adjMatrix.RowNames = groupRunCollection.Select(x => x.Key); 
-        adjMatrix.ColumnNames = adjMatrix.RowNames;
-
-        for (int j = 0; j < groupRunCollection.Count; ++j) 
-        {
-            var g = groupRunCollection[j];
-            var matrix = CalculateAdjacencyRows(g);
-            var variables = new List<Tuple<string, double>>();
-            var columnNames = matrix.ColumnNames.ToList();
-            
-            for (int i = 0; i < matrix.Columns; ++i)
-            {
-                variables.Add(new Tuple<string, double>(columnNames[i], matrix[0, i]));
-            }
-            variables.Add(new Tuple<string, double>(g.Key, 0));
-            variables.Sort((a, b) => a.Item1.CompareTo(b.Item1));
-            for (int i = 0; i < variables.Count; ++i)
-            {
-                adjMatrix[j, i] = variables[i].Item2;
-            }
-        }
-        viewHost2.Content = CalculateNodeImportance(adjMatrix);
-        viewHost3.Content = UpdateAdjacencyMatrixByThreshold(0.2, "x1", adjMatrix);
-        viewHost1.Content = adjMatrix;
-    }
-
-    private DoubleMatrix CalculateAdjacencyRows(IEnumerable<IRun> runs)
-    {
-        IEnumerable<DoubleMatrix> allVariableImpacts = (from run in runs
-                                                      select run.Results[variableImpactResultName]).Cast<DoubleMatrix>();
-        var variableNames = (from variableImpact in allVariableImpacts
-                                           from variableName in variableImpact.RowNames
-                                           select variableName)
-                                          .Distinct().ToArray();
-       
-        List<string> variableNamesList = (from variableName in variableNames
-                                          where GetVariableImpacts(variableName, allVariableImpacts).Any(x => !x.IsAlmost(0.0))
-                                          select variableName)
-                                         .ToList();
-   
-        var runNames = runs.Select(x => x.Name).ToArray();
-        var runsArray = runs.ToArray();
-        DoubleMatrix varImpactMatrix = CalculateVariableImpactMatrix(runsArray, runNames);
-        var targetMatrix = new DoubleMatrix(1, variableNames.Length);
-
-        for (int i = 0; i < varImpactMatrix.Rows; ++i)
-        {
-            targetMatrix[0, i] = varImpactMatrix[i, runNames.Length];
-        }
-   
-        targetMatrix.RowNames = new[] { "Target" };
-        targetMatrix.ColumnNames = variableNames;
-
-        return targetMatrix;
-    }
-
-    private DoubleMatrix UpdateAdjacencyMatrixByThreshold(double threshold, string targetVariable, DoubleMatrix adjMatrix)
-    {
-        var updatedMatrix = (DoubleMatrix) adjMatrix.Clone();
-        var groupRunCollection = Content.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).ToList();
-        string[] targets = adjMatrix.RowNames.ToArray();
-        var targetIndex = Array.IndexOf(targets, targetVariable);
-        
-        for (int j = 0; j < groupRunCollection.Count; ++j)
-        {
-            if (updatedMatrix[targetIndex, j] < threshold)
-            {
-                updatedMatrix[targetIndex, j] = 0;
-            }          
-        }
-        return updatedMatrix;
-    }
-
-    private DoubleMatrix CalculateNodeImportance(DoubleMatrix adjMatrix)
-    {
-           DoubleMatrix nodeImportance = new DoubleMatrix(adjMatrix.Rows, 1);
-           var variables = new List<Tuple<string, double>>();
-           var rowNames = adjMatrix.RowNames.ToList();
-           var groupRunCollection = Content.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).ToList();
-           double[] meanQuality = new double[groupRunCollection.Count];
-
-           for (int j = 0; j < groupRunCollection.Count; ++j)
-           {
-               var g = groupRunCollection[j];
-               meanQuality[j] = g.Average(x => ((IRegressionSolution)x.Results[TrainingBestSolutionParameterName]).TrainingRSquared);
-           }
-
-           for (int i = 0; i < adjMatrix.Columns; ++i)
-           {
-               for (int j = 0; j < adjMatrix.Rows; ++j)
-               {
-                   nodeImportance[i, 0] += adjMatrix[j, i];
-               }
-               nodeImportance[i, 0] = nodeImportance[i, 0] * meanQuality[i] / (adjMatrix.Rows - 1);
-               variables.Add(new Tuple<string, double>(rowNames[i], nodeImportance[i, 0]));
-           }
-           
-           variables.Sort((b,a) => a.Item2.CompareTo(b.Item2));
-
-           for (int i = 0; i < nodeImportance.Rows; ++i)
-           {
-               nodeImportance[i, 0] = variables[i].Item2;
-               rowNames[i] = variables[i].Item1;
-           }
-
-           nodeImportance.RowNames = rowNames;
-           nodeImportance.ColumnNames = new[] { "Node Importance" };
-           return nodeImportance;    
-    }
-
-    //adapted from RunCollectionVariableImpactView
-    private DoubleMatrix CalculateVariableImpactMatrix(IRun[] runs, string[] runNames)
-    {
-        IEnumerable<DoubleMatrix> allVariableImpacts = (from run in runs
-                                                        select run.Results[variableImpactResultName]).Cast<DoubleMatrix>();
-        IEnumerable<string> variableNames = (from variableImpact in allVariableImpacts
-                                             from variableName in variableImpact.RowNames
-                                             select variableName).Distinct();
-
-        // filter variableNames: only include names that have at least one non-zero value in a run
-        List<string> variableNamesList = (from variableName in variableNames
-                                          where GetVariableImpacts(variableName, allVariableImpacts).Any(x => !x.IsAlmost(0.0))
-                                          select variableName).ToList();
-
-        List<string> columnNames = new List<string>(runNames);
-        columnNames.Add("Mean");
-      
-        int numberOfRuns = runs.Length;
-
-        DoubleMatrix matrix = new DoubleMatrix(variableNamesList.Count, numberOfRuns + 1);
-        matrix.SortableView = true;
-        matrix.ColumnNames = columnNames;
-
-        List<List<double>> variableImpactsOverRuns = (from variableName in variableNamesList
-                                                      select GetVariableImpacts(variableName, allVariableImpacts).ToList()).ToList();
-
-        for (int row = 0; row < variableImpactsOverRuns.Count; row++)
-        {
-            matrix[row, numberOfRuns] = Math.Round(variableImpactsOverRuns[row].Average(), 3);
-        }
-
-        // fill matrix with impacts from runs
-        for (int i = 0; i < runs.Length; i++)
-        {
-            IRun run = runs[i];
-            DoubleMatrix runVariableImpacts = (DoubleMatrix)run.Results[variableImpactResultName];
-            for (int j = 0; j < runVariableImpacts.Rows; j++)
-            {
-                int rowIndex = variableNamesList.FindIndex(s => s == runVariableImpacts.RowNames.ElementAt(j));
-                if (rowIndex > -1)
-                {
-                    matrix[rowIndex, i] = Math.Round(runVariableImpacts[j, 0], 3);
-                }
-            }
-        }
-        return matrix;
-    }
-
-    //taken from RunCollectionVariableImpactView
-    private IEnumerable<double> GetVariableImpacts(string variableName, IEnumerable<DoubleMatrix> allVariableImpacts)
-    {
-        foreach (DoubleMatrix runVariableImpacts in allVariableImpacts)
-        {
-            int row = 0;
-            foreach (string rowName in runVariableImpacts.RowNames)
-            {
-                if (rowName == variableName)
-                    yield return runVariableImpacts[row, 0];
-                row++;
-            }
-        }
-    }
-  }
 }