private void exportQueryAsFileButton_Click(object sender, EventArgs e)
        {
            string Filename;
            string Outstring;

            if (thisFormResult.GetType() == typeof(RBACS.UserQueryResult))
            {
                UserQueryResult UQR = (UserQueryResult)thisFormResult;
                Filename  = parentReference.PreferredExportFilepath + "\\" + UQR.AccountName + ".txt";
                Outstring = FileHelperFuctions.ReturnFormattedPersonInfo(UQR, parentReference.GroupNamesAndDescriptionsAll, parentReference.ByTitle);
            }
            else if (thisFormResult.GetType() == typeof(RBACS.GroupingQueryResult))
            {
                GroupingQueryResult GQR = (GroupingQueryResult)thisFormResult;
                Filename  = parentReference.PreferredExportFilepath + "\\" + FileHelperFuctions.ReturnAcceptableFileName(GQR.GroupingName) + ".txt";
                Outstring = FileHelperFuctions.ReturnFormattedGroupInfo(parentReference.UserQueryResults, GQR, parentReference.GroupNamesAndDescriptionsAll);
            }
            else
            {
                Filename = ""; Outstring = "";
            }

            TextWriter QueryText = new StreamWriter(Filename);

            QueryText.Write(Outstring);
            QueryText.Dispose();
        }
 private void nNDataGridView_CellContentDoubleClick(object sender, DataGridViewCellEventArgs e)
 {
     if (thisFormResultType == typeof(UserQueryResult))
     {
         int RowNum = e.RowIndex;
         if (RowNum >= 0)
         {
             var              KeyResult = from UQR in parentReference.UserQueryResults where UQR.AccountName == nNDataGridView.Rows[RowNum].Cells[4].Value.ToString() select UQR;
             UserQueryResult  Result    = KeyResult.ToList()[0];
             QueryDetailsForm QDF       = new QueryDetailsForm(Result, parentReference);
             QDF.Show();
         }
     }
     else if (thisFormResultType == typeof(GroupingQueryResult))
     {
         int RowNum = e.RowIndex;
         if (RowNum >= 0)
         {
             var KeyResult = from UQR in parentReference.GroupingQueryResults where UQR.GroupingName == nNDataGridView.Rows[RowNum].Cells[1].Value.ToString() select UQR;
             GroupingQueryResult Result = KeyResult.ToList()[0];
             QueryDetailsForm    QDF    = new QueryDetailsForm(Result, parentReference);
             QDF.Show();
         }
     }
 }
        public static List <UserQueryResult> AddPermissionToAllConditionalOnIndex(List <UserQueryResult> UQRListIn, List <string> Permissions, string Permission, List <int> Indexes, int ConditionalityIndex = -1)
        {
            int NewPermissionIndex = Permissions.IndexOf(Permission);

            UserQueryResult[] UQRArrayOut = new UserQueryResult[UQRListIn.Count];
            Parallel.For(0, UQRListIn.Count, i => {
                double[] CurrentArray = UQRListIn[i].ReturnAccessVector().ToArray();
                double[] NextArray    = new double[CurrentArray.Length + 1];
                for (int a = 0; a < NextArray.Length; a++)
                {
                    if (a < NewPermissionIndex)
                    {
                        NextArray[a] = CurrentArray[a];
                    }
                    else if (a == NewPermissionIndex)
                    {
                        //this is used if a list of indices of users is provided
                        if (Indexes.Contains(i))
                        {
                            NextArray[a] = 1;
                        }
                        else
                        {
                            NextArray[a] = 0;
                        }
                        //this is used where a conditional index is specified (ie index of a child group)
                        if (ConditionalityIndex >= 0)
                        {
                            //checks for conditional index in access vector
                            //to be used for nested groups
                            if (ConditionalityIndex > NewPermissionIndex)
                            {
                                //conditionality index is drawn from an updated list of groups
                                //so may need to be decremented when referencing out of a non-updated vector
                                if (CurrentArray[ConditionalityIndex - 1] == 1)
                                {
                                    NextArray[a] = 1;
                                }
                            }
                            else
                            {
                                if (CurrentArray[ConditionalityIndex] == 1)
                                {
                                    NextArray[a] = 1;
                                }
                            }
                        }
                    }
                    else
                    {
                        NextArray[a] = CurrentArray[a - 1];
                    }
                }
                DenseVector NewVector = DenseVector.OfArray(NextArray);
                UQRArrayOut[i]        = new UserQueryResult(UQRListIn[i].Title, UQRListIn[i].Description, UQRListIn[i].Name, UQRListIn[i].AccountName, UQRListIn[i].DistinguishedName, NewVector);
            });
            return(UQRArrayOut.ToList());
        }
        public QueryDetailsForm(QueryResult InputQR, RBAC SourceRBAC) : this()
        {
            thisFormResult          = InputQR;
            thisBindingSourceGroups = new BindingSource();
            parentReference         = SourceRBAC;
            if (InputQR.GetType() == typeof(RBACS.UserQueryResult))
            {
                UserQueryResult UQR = (UserQueryResult)InputQR;
                qRName = UQR.AccountName;
                string QRScrip = UQR.Description;
                string QRTitle = UQR.Title;
                Text = $"{qRName} Query Details";
                titlingRichTextBox.Text = $"Name:\t{qRName}\r\nTitle:\t{QRTitle}\r\nDescription:\t{QRScrip}";
                thisGroupsReport        = new GroupReport(HelperFunctions.QueryResultToGroupResults(UQR, parentReference.GroupNamesAndDescriptionsAll), Ordering.Ascending);
                GroupReport GR2 = (GroupReport)thisGroupsReport;
                thisBindingSourceGroups.DataSource = GR2.QRList;
                groupsDataGridView.DataSource      = thisBindingSourceGroups;
                //summaryTextBox.Text = FileHelperFuctions.ReturnFormattedPersonInfo((UserQueryResult)InputQR, SourceRBAC.GroupNamesAndDescriptionsAll, SourceRBAC.ByTitle);
            }
            else if (InputQR.GetType() == typeof(RBACS.GroupingQueryResult))
            {
                GroupingQueryResult GQR = (GroupingQueryResult)InputQR;
                qRName = GQR.GroupingName;
                Text   = $"{qRName} Query Details";
                titlingRichTextBox.Text = $"{GQR.GroupingType}:\t{GQR.GroupingName}\r\nMember Count:\t{GQR.MemberCount}";
                List <UserQueryResult> TempUQRList = new List <UserQueryResult>();
                foreach (string Mem in GQR.Members.Split(','))
                {
                    if (Mem != null)
                    {
                        string MemTrim = Mem.Trim();
                        Parallel.ForEach(parentReference.UserQueryResults, UQR =>
                        {
                            if (UQR.AccountName == MemTrim)
                            {
                                TempUQRList.Add(UQR);
                            }
                        });
                    }
                }

                thisGroupsReport = new GroupRepresentationTFIDFReport(HelperFunctions.QueryListToGroupRepresentationTFIDFList(GQR, parentReference.GroupingQueryResults, parentReference.GroupNamesAndDescriptionsAll), Ordering.Ascending);
                GroupRepresentationTFIDFReport GRR2 = (GroupRepresentationTFIDFReport)thisGroupsReport;
                thisBindingSourceGroups.DataSource = GRR2.QRList;
                groupsDataGridView.DataSource      = thisBindingSourceGroups;
                //summaryTextBox.Text = FileHelperFuctions.ReturnFormattedGroupSummary((GroupingQueryResult)InputQR, SourceRBAC.GroupNamesAndDescriptionsAll);
            }
            else
            {
            }
            thisFormResultType = InputQR.GetType();
            thisBindingSource  = new BindingSource();
            parentReference    = SourceRBAC;
            //InitializeComponent();
        }
 public static List <UserQueryResult> UpdatePermissionsByCondition(int TargetPermissionIndex, int ConditionalityPermissionIndex, List <UserQueryResult> UQRListIn)
 {
     UserQueryResult[] UQRArrayOut = new UserQueryResult[UQRListIn.Count];
     Parallel.For(0, UQRListIn.Count, i =>
     {
         double[] InterimArray = UQRListIn[i].ReturnAccessVector().ToArray();
         if (InterimArray[ConditionalityPermissionIndex] == 1)
         {
             InterimArray[TargetPermissionIndex] = 1;
         }
         DenseVector NewVector = DenseVector.OfArray(InterimArray);
         UQRArrayOut[i]        = new UserQueryResult(UQRListIn[i].Title, UQRListIn[i].Description, UQRListIn[i].Name, UQRListIn[i].AccountName, UQRListIn[i].DistinguishedName, NewVector);
     });
     return(UQRArrayOut.ToList());
 }
        public static List <QueryResult> DatagridViewSubsetToQueryResultList(DataGridView DGV, int KeyValueColumnIndex, int SubsetColumnIndex, string SubsetValue, List <QueryResult> ReferencedList)
        {
            //takes no notice of selected rows
            List <QueryResult> OutputList = new List <QueryResult>();

            List <DataGridViewRow> RowCollection = (from DataGridViewRow DGVR in DGV.Rows where DGVR.Cells[SubsetColumnIndex].Value.ToString() == SubsetValue select DGVR).ToList();

            if (ReferencedList[0].GetType() == typeof(UserQueryResult))
            {
                foreach (DataGridViewRow ThisRow in RowCollection)
                {
                    string          CompareString = ThisRow.Cells[KeyValueColumnIndex].Value.ToString();
                    UserQueryResult UQR           = null;
                    Parallel.ForEach(ReferencedList, QR => {
                        UserQueryResult CurrentUQR = (UserQueryResult)QR;
                        if (CompareString == CurrentUQR.AccountName)
                        {
                            UQR = CurrentUQR;
                        }
                    });
                    if (UQR != null)
                    {
                        OutputList.Add(UQR);
                    }
                }
            }
            else
            {
                foreach (DataGridViewRow ThisRow in RowCollection)
                {
                    string CompareString    = ThisRow.Cells[KeyValueColumnIndex].Value.ToString();
                    GroupingQueryResult GQR = null;
                    Parallel.ForEach(ReferencedList, QR => {
                        GroupingQueryResult CurrentGQR = (GroupingQueryResult)QR;
                        if (CompareString == CurrentGQR.GroupingName)
                        {
                            GQR = CurrentGQR;
                        }
                    });
                    if (GQR != null)
                    {
                        OutputList.Add(GQR);
                    }
                }
            }
            return(OutputList);
        }
        private void kNNAsFileButton_Click(object sender, EventArgs e)
        {
            string FileName;
            string FileContent = "";

            if (thisFormResultType == typeof(UserQueryResult))
            {
                UserQueryResult      UQR     = (UserQueryResult)thisFormResult;
                List <UserKNNResult> UKRList = AllKNNResults.Cast <UserKNNResult>().ToList();
                FileName = $"{parentReference.PreferredExportFilepath}\\{UQR.Name} {kTextBox.Text} Nearest Neighbours.txt";
                int i = 1;
                foreach (UserKNNResult UKR in UKRList)
                {
                    FileContent = FileContent + FileHelperFuctions.FirstSecondEtc(i) + $" Nearest Neighbour to {UQR.AccountName}, Distance of {UKR.Distance}:\r\n\r\n#########################################################\r\n"
                                  + FileHelperFuctions.ReturnFormattedPersonInfo(new UserQueryResult(UKR.Title, UKR.Description, UKR.Name, UKR.AccountName, UKR.DistinguishedName, UKR.ReturnAccessVector()), parentReference.GroupNamesAndDescriptionsAll, parentReference.ByTitle);
                    i++;
                }

                TextWriter UTextWr = new StreamWriter(FileName);
                UTextWr.Write(FileContent);
                UTextWr.Dispose();
            }
            else if (thisFormResultType == typeof(GroupingQueryResult))
            {
                //only puts out single file at this point
                //don't see why multiple files would even be desirable for KNN Results

                GroupingQueryResult      GQR     = (GroupingQueryResult)thisFormResult;
                List <GroupingKNNResult> GKRList = AllKNNResults.Cast <GroupingKNNResult>().ToList();
                FileName = $"{parentReference.PreferredExportFilepath}\\{FileHelperFuctions.ReturnAcceptableFileName(GQR.GroupingName)} {kTextBox.Text} Nearest Neighbours.txt";
                int i2 = 1;
                foreach (GroupingKNNResult GKR in GKRList)
                {
                    FileContent = FileContent + FileHelperFuctions.FirstSecondEtc(i2) + $" Nearest Neighbour to {GQR.GroupingName}, Distance of {GKR.Distance}:\r\n\r\n#########################################################\r\n"
                                  + FileHelperFuctions.ReturnFormattedGroupSummary(new GroupingQueryResult(GKR), parentReference.GroupNamesAndDescriptionsAll);
                    i2++;
                }

                TextWriter GTextWr = new StreamWriter(FileName);
                GTextWr.Write(FileContent);
                GTextWr.Dispose();
            }
            else
            {
            }
        }
        private void kNNAsCSVButton_Click(object sender, EventArgs e)
        {
            string CSVString = FileHelperFuctions.ReturnCSVString(nNDataGridView);
            string FileName;

            if (thisFormResultType == typeof(UserQueryResult))
            {
                UserQueryResult UQR = (UserQueryResult)thisFormResult;
                FileName = $"{parentReference.PreferredExportFilepath}\\{UQR.Name} {kTextBox.Text} Nearest Neighbours.csv";
                File.WriteAllText(FileName, CSVString);
            }
            else if (thisFormResultType == typeof(GroupingQueryResult))
            {
                GroupingQueryResult GQR = (GroupingQueryResult)thisFormResult;
                FileName = $"{parentReference.PreferredExportFilepath}\\{FileHelperFuctions.ReturnAcceptableFileName(GQR.GroupingName)} {kTextBox.Text} Nearest Neighbours.csv";
                File.WriteAllText(FileName, CSVString);
            }
            else
            {
            }
        }
        public static string ReturnFormattedPersonInfo(UserQueryResult UQR, List <Tuple <string, string> > AllADGroupsList, bool TitleNotDescription = true)
        {
            if (AllADGroupsList.Count != UQR.ReturnAccessVector().Count)
            {
                throw new ArgumentOutOfRangeException();
            }
            string Outstring = UQR.AccountName;

            while (Outstring.Length < 80)
            {
                Outstring = Outstring + " ";
            }
            if (TitleNotDescription)
            {
                Outstring = Outstring + UQR.Title;
            }
            else
            {
                Outstring = Outstring + UQR.Description;
            }
            Outstring = $"{Outstring}\r\n{UQR.DistinguishedName}\r\n------------------------------------------------------------------------------------------------------------------------\r\n\r\n";
            Vector AccVect = UQR.ReturnAccessVector();

            for (int i = 0; i < AccVect.Count; i++)
            {
                if (AccVect[i] > 0)
                {
                    string TempString = AllADGroupsList[i].Item1;
                    while (TempString.Length < 80)
                    {
                        TempString = TempString + " ";
                    }
                    TempString = TempString + AllADGroupsList[i].Item2;
                    Outstring  = Outstring + TempString + "\r\n";
                }
            }
            Outstring = Outstring + "\r\n";
            return(Outstring);
        }
Beispiel #10
0
 public UserKNNResult(UserQueryResult UQR) : base(UQR.Title, UQR.Description, UQR.Name, UQR.AccountName, UQR.DistinguishedName, UQR.ReturnAccessVector())
 {
 }
Beispiel #11
0
 public UserClusteringResult(UserQueryResult UQR, string ClusterID, int ClusterIndex) : base(UQR.Title, UQR.Description, UQR.Name, UQR.AccountName, UQR.DistinguishedName, UQR.ReturnAccessVector())
 {
     clusterID    = ClusterID;
     clusterIndex = ClusterIndex;
 }
        public static List <QueryResult> DatagridViewToQueryResultList(DataGridView DGV, int KeyValueColumnIndex, List <QueryResult> ReferencedList)
        {
            List <QueryResult> OutputList = new List <QueryResult>();

            if (DGV.SelectedRows.Count > 0)
            {
                if (ReferencedList[0].GetType() == typeof(UserQueryResult))
                {
                    foreach (DataGridViewRow ThisRow in DGV.SelectedRows)
                    {
                        UserQueryResult UQR           = null;
                        string          CompareString = ThisRow.Cells[KeyValueColumnIndex].Value.ToString();
                        Parallel.ForEach(ReferencedList, QR => {
                            UserQueryResult CurrentUQR = (UserQueryResult)QR;

                            if (CompareString == CurrentUQR.AccountName)
                            {
                                UQR = CurrentUQR;
                            }
                        });
                        if (UQR != null)
                        {
                            OutputList.Add(UQR);
                        }
                    }
                }
                else
                {
                    foreach (DataGridViewRow ThisRow in DGV.SelectedRows)
                    {
                        GroupingQueryResult GQR = null;
                        string CompareString    = ThisRow.Cells[KeyValueColumnIndex].Value.ToString();
                        Parallel.ForEach(ReferencedList, QR => {
                            GroupingQueryResult CurrentGQR = (GroupingQueryResult)QR;

                            if (CompareString == CurrentGQR.GroupingName)
                            {
                                GQR = CurrentGQR;
                            }
                        });
                        if (GQR != null)
                        {
                            OutputList.Add(GQR);
                        }
                    }
                }
                return(OutputList);
            }
            else
            {
                if (ReferencedList[0].GetType() == typeof(UserQueryResult))
                {
                    foreach (DataGridViewRow ThisRow in DGV.Rows)
                    {
                        string          CompareString = ThisRow.Cells[KeyValueColumnIndex].Value.ToString();
                        UserQueryResult UQR           = null;
                        Parallel.ForEach(ReferencedList, QR => {
                            UserQueryResult CurrentUQR = (UserQueryResult)QR;
                            if (CompareString == CurrentUQR.AccountName)
                            {
                                UQR = CurrentUQR;
                            }
                        });
                        if (UQR != null)
                        {
                            OutputList.Add(UQR);
                        }
                    }
                }
                else
                {
                    foreach (DataGridViewRow ThisRow in DGV.Rows)
                    {
                        string CompareString    = ThisRow.Cells[KeyValueColumnIndex].Value.ToString();
                        GroupingQueryResult GQR = null;
                        Parallel.ForEach(ReferencedList, QR => {
                            GroupingQueryResult CurrentGQR = (GroupingQueryResult)QR;
                            if (CompareString == CurrentGQR.GroupingName)
                            {
                                GQR = CurrentGQR;
                            }
                        });
                        if (GQR != null)
                        {
                            OutputList.Add(GQR);
                        }
                    }
                }
                return(OutputList);
            }
        }
 private QueryResult uQtoQR(UserQueryResult QR)
 {
     return((QueryResult)QR);
 }
        private void nearestNeighboursButton_Click(object sender, EventArgs e)
        {
            nNDataGridView.AutoGenerateColumns = true;
            bool KSpecified = true;
            int  K;
            List <iKNNResult>          AllResults = new List <iKNNResult>();
            ConcurrentBag <iKNNResult> ResultBag  = new ConcurrentBag <iKNNResult>();

            try { K = Convert.ToInt32(kTextBox.Text); }
            catch
            {
                KSpecified    = false;
                kTextBox.Text = "All";
                Application.DoEvents();
                K = -1;
            }
            if (thisFormResultType == typeof(UserQueryResult))
            {
                UserQueryResult      UQR     = (UserQueryResult)thisFormResult;
                List <UserKNNResult> UKRList = new List <UserKNNResult>();
                Parallel.ForEach <UserQueryResult>(parentReference.UserQueryResults, CurrentUQR => {
                    if (CurrentUQR.AccountName != UQR.AccountName)
                    {
                        UserKNNResult UKR      = new UserKNNResult(CurrentUQR);
                        double CurrentDistance = HelperFunctions.GetEuclideanDistance(UQR.ReturnAccessVector(), CurrentUQR.ReturnAccessVector());
                        UKR.AssignKNNDistanceFromX(CurrentDistance);
                        ResultBag.Add(UKR);
                    }
                });
                UKRList         = ResultBag.Cast <UserKNNResult>().ToList <UserKNNResult>();
                AllResults      = UKRList.OrderBy(o => o.Distance).ToList().Cast <iKNNResult>().ToList();
                thisQueryReport = new UserKNNReport(AllResults.Cast <UserKNNResult>().ToList(), Ordering.Ascending);
            }
            else if (thisFormResultType == typeof(GroupingQueryResult))
            {
                GroupingQueryResult      GQR     = (GroupingQueryResult)thisFormResult;
                List <GroupingKNNResult> GKRList = new List <GroupingKNNResult>();
                Parallel.ForEach <GroupingQueryResult>(parentReference.GroupingQueryResults, CurrentGQR => {
                    if (CurrentGQR.GroupingName != GQR.GroupingName)
                    {
                        GroupingKNNResult GKR = new GroupingKNNResult(CurrentGQR);
                        double CurrentDistance;
                        if (parentReference.ClusterByRelativeCount)
                        {
                            CurrentDistance = HelperFunctions.GetEuclideanDistance(GQR.ReturnAccessVector(), CurrentGQR.ReturnAccessVector());
                        }
                        else
                        {
                            CurrentDistance = HelperFunctions.GetEuclideanDistance(GQR.ReturnTF_IDFVector(), CurrentGQR.ReturnTF_IDFVector());
                        }
                        GKR.AssignKNNDistanceFromX(CurrentDistance);
                        ResultBag.Add(GKR);
                    }
                });
                GKRList         = ResultBag.Cast <GroupingKNNResult>().ToList();
                AllResults      = GKRList.OrderBy(o => o.Distance).ToList().Cast <iKNNResult>().ToList();
                thisQueryReport = new GroupingKNNReport(AllResults.Cast <GroupingKNNResult>().ToList(), Ordering.Ascending);
            }
            else
            {
            }

            if (KSpecified && K <= AllResults.Count)
            {
                List <iKNNResult> Outlist = new List <iKNNResult>();
                for (int i = 0; i < K; i++)
                {
                    Outlist.Add(AllResults[i]);
                }
                //AllKNNResults = Outlist;
                if (thisFormResultType == typeof(UserQueryResult))
                {
                    thisQueryReport = new UserKNNReport(Outlist.Cast <UserKNNResult>().ToList(), Ordering.Ascending);
                }
                else if (thisFormResultType == typeof(GroupingQueryResult))
                {
                    thisQueryReport = new GroupingKNNReport(Outlist.Cast <GroupingKNNResult>().ToList(), Ordering.Ascending);
                }
                else
                {
                }
            }
            else
            {
                AllKNNResults = AllResults;
            }
            if (thisFormResultType == typeof(UserQueryResult))
            {
                UserKNNReport ReportPointer = (UserKNNReport)thisQueryReport;
                thisBindingSource.DataSource = ReportPointer.QRList;
                //thisBindingSource.DataSource = (UserKNNReport)thisQueryReport..Cast<UserKNNResult>().ToList();
                nNDataGridView.DataSource = thisBindingSource;
            }
            else if (thisFormResultType == typeof(GroupingQueryResult))
            {
                GroupingKNNReport ReportPointer = (GroupingKNNReport)thisQueryReport;
                thisBindingSource.DataSource = ReportPointer.QRList;

                nNDataGridView.DataSource = thisBindingSource;
            }
            else
            {
            }
        }
        public ClusteringOutput(List <QueryResult> QRList, RBAC RBACRef)
        {
            thisFormResultType = QRList[0].GetType();
            parentReference    = RBACRef;
            ConcurrentBag <Tuple <string, DenseVector> > InputList = new ConcurrentBag <Tuple <string, DenseVector> >();

            if (QRList[0].GetType() == typeof(UserQueryResult))
            {
                Parallel.ForEach <QueryResult>(QRList, QR =>
                {
                    UserQueryResult UQR = (UserQueryResult)QR;
                    Tuple <string, DenseVector> TupleIn = new Tuple <string, DenseVector>(UQR.AccountName, (DenseVector)UQR.ReturnAccessVector());
                    InputList.Add(TupleIn);
                });
            }
            else if (QRList[0].GetType() == typeof(GroupingQueryResult))
            {
                Parallel.ForEach <QueryResult>(QRList, QR =>
                {
                    GroupingQueryResult GQR = (GroupingQueryResult)QR;
                    DenseVector VectorA;
                    if (parentReference.ClusterByRelativeCount)
                    {
                        VectorA = (DenseVector)GQR.ReturnAccessVector();
                    }
                    else
                    {
                        VectorA = (DenseVector)GQR.ReturnTF_IDFVector();
                    }
                    Tuple <string, DenseVector> TupleIn = new Tuple <string, DenseVector>(GQR.GroupingName, VectorA);
                    InputList.Add(TupleIn);
                });
            }
            else
            {
            }
            //add options on algo configtab on main form later
            if (parentReference.ClusteringAlgoType == typeof(HACAlgo))
            {
                thisAlgo = new HACAlgo(InputList.OrderBy(o => o.Item1).ToList(), parentReference.PreferredDistanceStyle, parentReference.HACStoppingMetric, parentReference.PreferredStoppingStyle);
            }
            else
            {
                thisAlgo = new KMeansPlusPlus(InputList.OrderBy(o => o.Item1).ToList(), parentReference.KMeansValue, parentReference.PreferredKMeansStoppingStyle, parentReference.KMeansMaxIter);
            }
            parentReference.statusLabelChanger($"Initialising {thisAlgo.GetType().ToString().Split('.')[1]}, please be patient");
            thisAlgo.InitialiseClusters();

            while (!thisAlgo.Stopped)
            {
                thisAlgo.IterateOnce();
                if (!thisAlgo.Stopped)
                {
                    parentReference.statusLabelChanger($"Running {thisAlgo.GetType().ToString().Split('.')[1]}, iteration {thisAlgo.Iterator}");
                }
            }
            //set all centroids as means in case mapping of clusters is required further
            //down the line:

            if (QRList[0].ReturnAccessVector().Count > 500)
            {
                thisAlgo.SetCentroidsAsMeansHighDimensionality();
            }
            else
            {
                thisAlgo.SetCentroidsAsMeans();
            }
            parentReference.statusLabelChanger("Creating Data View");

            ConcurrentBag <QueryResult> ResultsBag = new ConcurrentBag <QueryResult>();

            if (thisFormResultType == typeof(UserQueryResult))
            {
                foreach (Cluster Clust in thisAlgo.Clusters)
                {
                    Parallel.ForEach <Tuple <string, DenseVector> >(Clust.MemberList, Member => {
                        UserQueryResult Target = (UserQueryResult)(from UQR in QRList.Cast <UserQueryResult>() where UQR.AccountName == Member.Item1 select UQR).ToList()[0];
                        ResultsBag.Add(new UserClusteringResult(Target, Clust.ClusterID, Clust.ListPosition));
                    });
                }
                clusteringResultList = ResultsBag.Cast <UserClusteringResult>().OrderBy(o => o.ClusterIndex).ToList <QueryResult>();
            }
            else if (thisFormResultType == typeof(GroupingQueryResult))
            {
                foreach (Cluster Clust in thisAlgo.Clusters)
                {
                    Parallel.ForEach <Tuple <string, DenseVector> >(Clust.MemberList, Member => {
                        GroupingQueryResult Target = (GroupingQueryResult)(from GQR in QRList.Cast <GroupingQueryResult>().ToList() where GQR.GroupingName == Member.Item1 select GQR).ToList <GroupingQueryResult>()[0];
                        ResultsBag.Add(new GroupingClusteringResult(Target, Clust.ClusterID, Clust.ListPosition));
                    });
                }
                clusteringResultList = ResultsBag.Cast <GroupingClusteringResult>().OrderBy(o => o.ClusterIndex).ToList <QueryResult>();
            }
            else
            {
            }
            parentReference.statusLabelChanger("Idle");

            InitializeComponent();
            this.Text = $"Clustering Results from {thisAlgo.Iterator} Iterations, using {thisAlgo.GetType().ToString().Split('.')[1]}, {thisAlgo.Clusters.Count} Clusters";


            thisBindingSource = new BindingSource();
            if (thisFormResultType == typeof(UserQueryResult))
            {
                //needs a bit of casting to allow datagridview to access type-specific public properties
                thisQR = new UserClusteringReport(clusteringResultList.Cast <UserClusteringResult>().ToList(), Ordering.Ascending);
                UserClusteringReport ReportReference = (UserClusteringReport)thisQR;
                thisBindingSource.DataSource    = ReportReference.QRList;
                clustersDataGridView.DataSource = thisBindingSource;
            }
            else
            {
                thisQR = new GroupingClusteringReport(clusteringResultList.Cast <GroupingClusteringResult>().ToList(), Ordering.Ascending);
                GroupingClusteringReport ReportReference = (GroupingClusteringReport)thisQR;
                thisBindingSource.DataSource    = ReportReference.QRList;
                clustersDataGridView.DataSource = thisBindingSource;
            }
        }