public static int Classify(double[] unknown, double[][] trainData, int numClasses, int k)
{
// compute and store distances from unknown to all train data
int n = trainData.Length; // number data items
IndexAndDistance[] info = new IndexAndDistance[n];
for (int i = 0; i < n; ++i)
{
IndexAndDistance curr = new IndexAndDistance();
double dist = Distance(unknown, trainData[i]);
curr.Index = i;
curr.Distance = dist;
info[i] = curr;
}
Array.Sort(info); // sort by distance
Console.WriteLine("\nNearest / Distance / Class");
Console.WriteLine("==============================");
for (int i = 0; i < k; ++i)
{
int classIndex = (int)trainData[info[i].Index][2];
string dist = info[i].Distance.ToString("F3");
Console.WriteLine("( " + trainData[info[i].Index][0] + "," + trainData[info[i].Index][1] + " ) : "
+ dist + " " + classIndex);
}
int result = Vote(info, trainData, numClasses, k); // k nearest classes
return(result);
} // Classify
static int Classify(double[] unknown, double[][] trainData, int numClasses, int k)
{
int n = trainData.Length;
IndexAndDistance[] info = new IndexAndDistance[n];
//coloca o index e a distancia do vetor desconhecido em relaçãoa todos os pontos de treinamento em um vetor auxiliar
for (int i = 0; i < n; ++i)
{
IndexAndDistance curr = new IndexAndDistance();
double dist = Distance(unknown, trainData[i]);
curr.idx = i;
curr.dist = dist;
info[i] = curr;
}
Array.Sort(info); // sort by distance crescent order
print("Nearest / Distance / Class");
print("==========================");
for (int i = 0; i < k; ++i)
{
int c = (int)trainData[info[i].idx][8];
string dist = info[i].dist.ToString("F3");
print("( " + trainData[info[i].idx][0] +
"," + trainData[info[i].idx][1] +
"," + trainData[info[i].idx][2] +
"," + trainData[info[i].idx][3] +
"," + trainData[info[i].idx][4] +
"," + trainData[info[i].idx][5] +
"," + trainData[info[i].idx][6] +
"," + trainData[info[i].idx][7] + ") : " +
dist + " " + c);
}
int result = Vote(info, trainData, numClasses, k);
return(result);
} // Classify
//--------------------------------------------KNN-------------------------------------------//
static int Classify(double[] unknown, double[][] trainData, int numClasses, int k)
{
int n = trainData.Length;
IndexAndDistance[] info = new IndexAndDistance[n];
for (int i = 0; i < n; i++)
{
IndexAndDistance curr = new IndexAndDistance();
double dist = Distance(unknown, trainData[i]);
curr.idx = i;
curr.dist = dist;
info[i] = curr;
}
Array.Sort(info); // sort by distance
Console.WriteLine("Nearest / Distance / Class");
Console.WriteLine("==========================");
for (int i = 0; i < k; ++i)
{
int c = (int)trainData[info[i].idx][6];
string dist = info[i].dist.ToString("F3");
Console.WriteLine("( " + trainData[info[i].idx][0] +
";" + trainData[info[i].idx][1] + ";" + trainData[info[i].idx][2] +
";" + trainData[info[i].idx][3] + ";" + trainData[info[i].idx][4] + ";" + trainData[info[i].idx][5] +
" ) : " + dist + " " + c);
}
int result = vote(info, trainData, numClasses, k);
return(result);
}
public static double Classify(object[] unknown, object[][] trainData, int numClasses, int k)
{
int n = trainData.Length;
info = new IndexAndDistance[n];
for (int i = 0; i < n; ++i)
{
IndexAndDistance curr = new IndexAndDistance();
double dist = Distance(unknown, trainData[i]);
curr.idx = i;
curr.dist = dist;
info[i] = curr;
}
double result = Vote(info, trainData, numClasses, k);
return(result);
}
public int CompareTo(object obj)
{
if (obj == null)
{
return(1);
}
IndexAndDistance other = (IndexAndDistance)obj;
if (other != null)
{
return(dist.CompareTo(other.dist));
}
else
{
throw new ArgumentException("Object is not a IndexAndDistance");
}
}
public static int Classify(double[] unknown, List <Seed> trainData, int numClasses, int k, bool euclidiana)
{
int n = trainData.Count;
IndexAndDistance[] info = new IndexAndDistance[n];
for (int i = 0; i < n; i++)
{
IndexAndDistance current = new IndexAndDistance();
double dist = Distance(unknown, trainData[i].Features, euclidiana);
current.idx = i;
current.dist = dist;
info[i] = current;
}
Array.Sort(info);
int result = Vote(info, trainData, numClasses, k);
return(result);
}
// Calculates the distance to new datapoint and sorts the list
public static IndexAndDistance[] SortedDistanceArray(double[] unknown, List <Dictionary <string, object> > trainData)
{
attributes = new List <string>(trainData[0].Keys);
int n = trainData.Count;
IndexAndDistance[] info = new IndexAndDistance[n];
for (int i = 0; i < n; ++i)
{
IndexAndDistance curr = new IndexAndDistance();
double dist = Distance(unknown, trainData[i]);
curr.idx = i;
curr.dist = dist;
info[i] = curr;
}
Array.Sort(info);
return(info);
}
public static string Classify(double[] input, double[][] trainData, int numClasses, int k)
{
IndexAndDistance[] info = new IndexAndDistance[trainData.Length];
//Calculate distance for each element in trainData array and input
for (int i = 0; i < trainData.Length; i++)
{
IndexAndDistance curr = new IndexAndDistance();
double dist = Distance(input, trainData[i]);
curr.idx = i;
curr.dist = dist;
info[i] = curr;
}
//Sort distances
Array.Sort(info);
//Display k nearest elements to input
for (int i = 0; i < k; i++)
{
string c = trainData[info[i].idx][trainData[0].Length - 1] == 1 ? "Seed 3" : (trainData[info[i].idx][trainData[0].Length - 2] == 1 ? "Seed 2" : "Seed 1");
double dist = info[i].dist;
Console.Write("Nearest: (");
for (int j = 0; j < trainData[info[i].idx].Length - 4; j++)
{
Console.Write("{0:0.000}, ", trainData[info[i].idx][j]);
}
Console.Write("{0:0.000}) Distance: {1:0.000} Class: {2}", trainData[info[i].idx][trainData[info[i].idx].Length - 4], dist, c);
Console.WriteLine();
}
//Get most possible class of input data
string result = Vote(info, trainData, numClasses, k);
return(result);
}
