protected List <List <ComparablePredicate> > ComputeOutcomePatterns(ComparablePredicate[] sorted) { ComparablePredicate cp = sorted[0]; var newGroup = new List <ComparablePredicate>(); var outcomePatterns = new List <List <ComparablePredicate> >(); foreach (var predicate in sorted) { if (cp.CompareTo(predicate) == 0) { newGroup.Add(predicate); } else { cp = predicate; outcomePatterns.Add(newGroup); newGroup = new List <ComparablePredicate> { predicate }; } } outcomePatterns.Add(newGroup); #if DEBUG Debug.Print(outcomePatterns.Count + " outcome patterns."); #endif return(outcomePatterns); }
protected internal virtual ComparablePredicate[] sortValues() { ComparablePredicate[] sortPreds = new ComparablePredicate[PARAMS.Length]; int numParams = 0; for (int pid = 0; pid < PARAMS.Length; pid++) { int[] predkeys = PARAMS[pid].Outcomes; // Array.Sort(predkeys); int numActive = predkeys.Length; int[] activeOutcomes = predkeys; double[] activeParams = PARAMS[pid].Parameters; numParams += numActive; /* * double[] activeParams = new double[numActive]; * * int id = 0; for (int i=0; i < predkeys.length; i++) { int oid = * predkeys[i]; activeOutcomes[id] = oid; activeParams[id] = * PARAMS[pid].getParams(oid); id++; } */ sortPreds[pid] = new ComparablePredicate(PRED_LABELS[pid], activeOutcomes, activeParams); } Array.Sort(sortPreds); return(sortPreds); }
protected ComparablePredicate[] SortValues() { var sortPreds = new ComparablePredicate[Parameters.Length]; for (var pid = 0; pid < Parameters.Length; pid++) { sortPreds[pid] = new ComparablePredicate( PredLabels[pid], Parameters[pid].Outcomes, Parameters[pid].Parameters); } // // Knuppe 2015-10-28: // - We can not use the Array.Sort because it uses QuickSort algorithm in the older versions of the .net framework. // - To get everything working as the java version I had to implement the MergeSort algorithm in order to keep the // - same sort behavior. // // Array.Sort(sortPreds); works on .net45 or newer // // References: // https://msdn.microsoft.com/en-us/library/system.array.sort(v=vs.110).aspx // http://docs.oracle.com/javase/7/docs/api/java/util/Arrays.html#sort(T[],%20java.util.Comparator) // sortPreds.MergeSort(); return(sortPreds); }
protected ComparablePredicate[] SortValues() { var tmpPreds = new ComparablePredicate[Parameters.Length]; var tmpOutcomes = new int[numOutcomes]; var tmpParams = new double[numOutcomes]; var numPreds = 0; //remove parameters with 0 weight and predicates with no parameters for (var pid = 0; pid < Parameters.Length; pid++) { var numParams = 0; var predParams = Parameters[pid].Parameters; var outcomePattern = Parameters[pid].Outcomes; for (var pi = 0; pi < predParams.Length; pi++) { if (predParams[pi].Equals(0d)) { continue; } tmpOutcomes[numParams] = outcomePattern[pi]; tmpParams[numParams] = predParams[pi]; numParams++; } var activeOutcomes = new int[numParams]; var activeParams = new double[numParams]; for (var pi = 0; pi < numParams; pi++) { activeOutcomes[pi] = tmpOutcomes[pi]; activeParams[pi] = tmpParams[pi]; } if (numParams == 0) { continue; } tmpPreds[numPreds] = new ComparablePredicate(PredLabels[pid], activeOutcomes, activeParams); numPreds++; } #if DEBUG Debug.Print("Compressed " + Parameters.Length + " parameters to " + numPreds); #endif var sortPreds = new ComparablePredicate[numPreds]; Array.Copy(tmpPreds, 0, sortPreds, 0, numPreds); Array.Sort(sortPreds); return(sortPreds); }
protected ComparablePredicate[] SortValues() { var sortPreds = new ComparablePredicate[PARAMS.Length]; for (var pid = 0; pid < PARAMS.Length; pid++) { sortPreds[pid] = new ComparablePredicate( PRED_LABELS[pid], PARAMS[pid].Outcomes, PARAMS[pid].Parameters); } Array.Sort(sortPreds); return(sortPreds); }
protected List<List<ComparablePredicate>> CompressOutcomes(ComparablePredicate[] sorted) { var cp = sorted[0]; var outcomePatterns = new List<List<ComparablePredicate>>(); var newGroup = new List<ComparablePredicate>(); foreach (var t in sorted) { if (cp.CompareTo(t) == 0) { newGroup.Add(t); } else { cp = t; outcomePatterns.Add(newGroup); newGroup = new List<ComparablePredicate> {t}; } } outcomePatterns.Add(newGroup); return outcomePatterns; }
protected internal virtual ComparablePredicate[] sortValues() { ComparablePredicate[] sortPreds; ComparablePredicate[] tmpPreds = new ComparablePredicate[PARAMS.Length]; int[] tmpOutcomes = new int[numOutcomes]; double[] tmpParams = new double[numOutcomes]; int numPreds = 0; //remove parameters with 0 weight and predicates with no parameters for (int pid = 0; pid < PARAMS.Length; pid++) { int numParams = 0; double[] predParams = PARAMS[pid].Parameters; int[] outcomePattern = PARAMS[pid].Outcomes; for (int pi = 0; pi < predParams.Length; pi++) { if (predParams[pi] != 0d) { tmpOutcomes[numParams] = outcomePattern[pi]; tmpParams[numParams] = predParams[pi]; numParams++; } } int[] activeOutcomes = new int[numParams]; double[] activeParams = new double[numParams]; for (int pi = 0; pi < numParams; pi++) { activeOutcomes[pi] = tmpOutcomes[pi]; activeParams[pi] = tmpParams[pi]; } if (numParams != 0) { tmpPreds[numPreds] = new ComparablePredicate(PRED_LABELS[pid], activeOutcomes, activeParams); numPreds++; } } Console.Error.WriteLine("Compressed " + PARAMS.Length + " parameters to " + numPreds); sortPreds = new ComparablePredicate[numPreds]; Array.Copy(tmpPreds, 0, sortPreds, 0, numPreds); Array.Sort(sortPreds); return(sortPreds); }
protected ComparablePredicate[] SortValues() { var tmpPreds = new ComparablePredicate[PARAMS.Length]; var tmpOutcomes = new int[numOutcomes]; var tmpParams = new double[numOutcomes]; int numPreds = 0; //remove parameters with 0 weight and predicates with no parameters for (int pid = 0; pid < PARAMS.Length; pid++) { var numParams = 0; var predParams = PARAMS[pid].Parameters; var outcomePattern = PARAMS[pid].Outcomes; for (int pi = 0; pi < predParams.Length; pi++) { if (!predParams[pi].Equals(0d)) { tmpOutcomes[numParams] = outcomePattern[pi]; tmpParams[numParams] = predParams[pi]; numParams++; } } var activeOutcomes = new int[numParams]; var activeParams = new double[numParams]; for (int pi = 0; pi < numParams; pi++) { activeOutcomes[pi] = tmpOutcomes[pi]; activeParams[pi] = tmpParams[pi]; } if (numParams != 0) { tmpPreds[numPreds] = new ComparablePredicate(PRED_LABELS[pid], activeOutcomes, activeParams); numPreds++; } } #if DEBUG Debug.Print("Compressed " + PARAMS.Length + " parameters to " + numPreds); #endif var sortPreds = new ComparablePredicate[numPreds]; Array.Copy(tmpPreds, 0, sortPreds, 0, numPreds); Array.Sort(sortPreds); return sortPreds; }
protected List<List<ComparablePredicate>> ComputeOutcomePatterns(ComparablePredicate[] sorted) { ComparablePredicate cp = sorted[0]; var newGroup = new List<ComparablePredicate>(); var outcomePatterns = new List<List<ComparablePredicate>>(); foreach (var predicate in sorted) { if (cp.CompareTo(predicate) == 0) { newGroup.Add(predicate); } else { cp = predicate; outcomePatterns.Add(newGroup); newGroup = new List<ComparablePredicate> { predicate }; } } outcomePatterns.Add(newGroup); #if DEBUG Debug.Print(outcomePatterns.Count + " outcome patterns."); #endif return outcomePatterns; }
protected internal virtual IList <IList <ComparablePredicate> > compressOutcomes(ComparablePredicate[] sorted) { ComparablePredicate cp = sorted[0]; IList <IList <ComparablePredicate> > outcomePatterns = new List <IList <ComparablePredicate> >(); IList <ComparablePredicate> newGroup = new List <ComparablePredicate>(); for (int i = 0; i < sorted.Length; i++) { if (cp.CompareTo(sorted[i]) == 0) { newGroup.Add(sorted[i]); } else { cp = sorted[i]; outcomePatterns.Add(newGroup); newGroup = new List <ComparablePredicate>(); newGroup.Add(sorted[i]); } } outcomePatterns.Add(newGroup); return(outcomePatterns); }
protected internal virtual IList <IList <ComparablePredicate> > computeOutcomePatterns(ComparablePredicate[] sorted) { ComparablePredicate cp = sorted[0]; IList <IList <ComparablePredicate> > outcomePatterns = new List <IList <ComparablePredicate> >(); IList <ComparablePredicate> newGroup = new List <ComparablePredicate>(); foreach (ComparablePredicate predicate in sorted) { if (cp.CompareTo(predicate) == 0) { newGroup.Add(predicate); } else { cp = predicate; outcomePatterns.Add(newGroup); newGroup = new List <ComparablePredicate>(); newGroup.Add(predicate); } } outcomePatterns.Add(newGroup); Console.Error.WriteLine(outcomePatterns.Count + " outcome patterns"); return(outcomePatterns); }
protected ComparablePredicate[] SortValues() { var sortPreds = new ComparablePredicate[PARAMS.Length]; for (var pid = 0; pid < PARAMS.Length; pid++) { sortPreds[pid] = new ComparablePredicate( PRED_LABELS[pid], PARAMS[pid].Outcomes, PARAMS[pid].Parameters); } Array.Sort(sortPreds); return sortPreds; }