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;
}
