/* Assignment problem - HUNGARIAN ALGORITHM */
public void assignClustersToDrones(Cluster[] clusters)
{
/* compute matrix dimensions with dummy rows and columns */
int N = UAVs.Length;
int[,] costs = new int[N, N]; //{{20,22,14,24},{20,19,12,20},{13,10,18,16},{22,23,9,28}};
/*compute matrix costs*/
for (int m = 0; m < N; m++)
{
for (int n = 0; n < N; n++)
{
if (m < UAVs.Length && n < clusters.Length)
{
costs[m, n] = (int)Mathf.Floor(Vector3.Magnitude(UAVs[m].transform.position - (clusters[n]).Centroid));
}
else
{
costs[m, n] = int.MaxValue;
}
}
}
/*Munkres - Hungarian Algorithm*/
int [] res = HungarianAlgorithm.FindAssignments(costs);
/*Assign clusters to UAVs*/
for (int i = 0; i < UAVs.Length; i++)
{
if (res[i] < clusters.Length)
{
UAVs[i].assignCluster(clusters[res[i]]);
}
}
}
public void SecondIdIsFive()
{
var matrix = preferenceCalculationClass.CreateEntryMatrix(slots, players, entries);
var test = HungarianAlgorithm.FindAssignments(matrix);
Assert.Equal(5, test[1]);
}
static string[] products; //= { "aaaaaaaaaaaaaaaaa","PlayStationsdfsdf", "Xboxreiyujfcfh", "Iphonegdsgsdtetr", "Pravecgdupoijh" , "Carsfdsdbaaaaaaaaaaaaaafds", "Captivafsdfoiteraaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaggndsfkgvdsfk" };
static void Main(string[] args)
{
if (args.Length > 0)
{
ReadFile(args[0]);
}
else
{
Console.WriteLine("No input file!"); return;
}
//1. Generate assignment matrix
double[,] AssignmentMatrix = new double[customers.Length, products.Length];
//rows are customers
//columns are products
double maxSS = 0;
for (int i = 0; i < customers.Length; i++)
{
for (int j = 0; j < products.Length; j++)
{
double SS = CalculateSS(products[j], customers[i]);
if (SS > maxSS)
{
maxSS = SS;
}
AssignmentMatrix[i, j] = SS;
}
}
//2. Invert because we are searching for max not min
for (int i = 0; i < AssignmentMatrix.GetLength(0); i++)
{
for (int j = 0; j < AssignmentMatrix.GetLength(1); j++)
{
AssignmentMatrix[i, j] = maxSS - AssignmentMatrix[i, j];
}
}
//3. Apply Hungarian algorithm
int[] result = HungarianAlgorithm.FindAssignments(AssignmentMatrix);
//4. Save result
double TotalSS = 0;
for (int i = 0; i < result.Length; i++)
{
//Console.WriteLine("Customer=" + customers[i] + ",product=" + products[result[i]]);
TotalSS += AssignmentMatrix[i, result[i]] + maxSS;
}
//Console.WriteLine("TotalSS="+TotalSS);
//Console.ReadKey();
WriteFile("output.txt", result, TotalSS);
}
void mapDataPointsToBars()
{
var costMatrix = buildCostMatrix(_dataPoints);
_barsAssignments = HungarianAlgorithm.FindAssignments(costMatrix);
for (int i = 0; i < _dataPoints.Count; i++)
{
var point = _dataPoints[i];
var bar = bars[_barsAssignments[i] * 2];
var traperzoid = bar.GetComponent <TrapezoidBarBehavior>();
traperzoid.mapDataPoint = point;
traperzoid._level = 1 / _maxDataPointValue * point.Value;
traperzoid.ReCalculateScale();
drawProjectionLine(point, bar);
}
}
public void Reshape(Mesh mesh)
{
float[,] costs = new float[vertexCount(), mesh.vertexCount()];
for (int i = 0; i < vertexCount(); i++)
{
for (int j = 0; j < mesh.vertexCount(); j++)
{
costs[i, j] = (float)Vector.Distance(vertices[i].v, mesh.vertices[j].v);
}
}
int[] mapping = HungarianAlgorithm.FindAssignments(costs);
for (int i = 0; i < mapping.Length; i++)
{
vertices[i].v = mesh.vertices[mapping[i]].v;
}
//Console.WriteLine(mapping.Length);
}
public void Track(List <Detection> detections, Esp esp, double dt)
{
// Purge dropped objects that have exceeded the time limit.
for (int i = droppedObjects.Count - 1; i >= 0; --i)
{
var dropped = droppedObjects[i];
if (dropped.Time + dt > MaximumInactiveTime)
{
droppedObjects.RemoveFast(i);
}
else
{
droppedObjects[i] = new TrackedObject(dropped.Detection, dropped.Id, dropped.Time + dt);
}
}
// Build the cost matrix.
var rows = trackedObjects.Count + droppedObjects.Count;
var cols = detections.Count;
var dimensions = Math.Max(rows, cols);
var costs = new double[dimensions, dimensions];
// Populate the cost matrix.
// Detections are the rows of the matrix.
// Tracked and droped objects are the columns.
// Entries are the costs for matching each.
// Note that if the number of detections is not equal to the number of tracked/dropped
// objects then we will have a bunch of (dummy) zero entries. These correspond to
// creating new tracked objects or dropping more tracked objects.
for (int r = 0; r < detections.Count; ++r)
{
var detection = detections[r];
for (int c = 0; c < trackedObjects.Count; ++c)
{
costs[r, c] = GIOU(detection.BoundingBox, trackedObjects[c].Detection.BoundingBox);
}
for (int c = 0; c < droppedObjects.Count; ++c)
{
costs[r, trackedObjects.Count + c] = GIOU(detection.BoundingBox, droppedObjects[c].Detection.BoundingBox);
}
}
// Find matches using the Hungarian Algorithm.
var assignments = HungarianAlgorithm.FindAssignments(costs);
// Update or create the tracked/dropped objects.
var persistedCount = trackedObjects.Count;
var maximumDistanceSq = MaximumTrackingDistance * MaximumTrackingDistance;
for (int r = 0; r < detections.Count; ++r)
{
var detection = detections[r];
var detectionCenter = detection.BoundingBox.Center();
var c = assignments[r];
if (c < trackedObjects.Count)
{
// We have a match with a tracked object.
// Check that the distance doesn't exceed the maximum allowed.
var tracked = trackedObjects[c];
var distanceSq = detectionCenter.DistanceSq(tracked.Detection.BoundingBox.Center());
if (distanceSq <= maximumDistanceSq)
{
// Okay, we can update the tracked object.
trackedObjects[c] = new TrackedObject(detection, trackedObjects[c].Id, trackedObjects[c].Time + dt);
}
else
{
// Distance limit exceeded.
// We need to create a new tracking object and drop the old one.
trackedObjects.RemoveFast(c);
trackedObjects.Add(new TrackedObject(detection, nextId++, 0.0));
droppedObjects.Add(new TrackedObject(tracked.Detection, tracked.Id, 0.0));
persistedCount -= 1;
}
}
else if (c < rows)
{
// We have a match with a dropped object.
// Check the distance doesn't exceed the maximum allowed.
var idx = rows - trackedObjects.Count - 1;
var dropped = droppedObjects[idx];
var distanceSq = detectionCenter.DistanceSq(dropped.Detection.BoundingBox.Center());
if (distanceSq <= maximumDistanceSq)
{
// Okay, we can bring back the dropped object.
trackedObjects.Add(new TrackedObject(detection, dropped.Id, 0.0));
droppedObjects.RemoveFast(idx);
}
else
{
// Distance limit exceeded.
// We need to add a new tracking object.
trackedObjects.Add(new TrackedObject(detection, nextId++, 0.0));
}
}
else
{
// Completely new object.
trackedObjects.Add(new TrackedObject(detection, nextId++, 0.0));
}
}
// Collect the list of tracked object IDs to be removed from the tracked object list and
// drop the trapped objects.
dropIds.Clear();
for (int r = detections.Count; r < assignments.Length; ++r)
{
var c = assignments[r];
if (c < persistedCount) // We could have added/removed tracked objects above.
{
var tracked = trackedObjects[c];
dropIds.Add(tracked.Id);
droppedObjects.Add(new TrackedObject(tracked.Detection, tracked.Id, 0.0));
}
}
// Now remove the dropped tracked objects.
foreach (var id in dropIds)
{
for (int i = 0; i < persistedCount; ++i)
{
if (trackedObjects[i].Id == id)
{
trackedObjects.RemoveFast(i);
persistedCount -= 1;
break;
}
}
}
// Render tracked objects.
if (esp != null)
{
foreach (var tracked in trackedObjects)
{
esp.Add(new TextShape(tracked.Detection.BoundingBox.TopLeft(), tracked.Id.ToString(), Color.Red, 12));
}
}
}
public IActionResult Asignacion([Bind("CheckedDependientes, CheckedTurnos, FechaInicio, FechaFinal")] SeleccionarAsignacionVM seleccionarAsignacionVM)
{
var Dependientes = _context.Dependientes.Where(d => seleccionarAsignacionVM.CheckedDependientes.Any(c => c.DependienteId == d.Id && c.Checked == true)).OrderBy(d => d.Id).ToList();
var Bares = _context.Bares.Where(b => seleccionarAsignacionVM.CheckedTurnos.Any(c => c.BarId == b.Id && c.Checked == true)).OrderBy(b => b.Id).ToList();
var ventasDependientesPorBar = BuscarVentas(seleccionarAsignacionVM.CheckedDependientes.Where(d => d.Checked).Select(d => d.DependienteId).ToList(), seleccionarAsignacionVM.CheckedTurnos.Where(d => d.Checked).Select(d => d.BarId).ToList(), seleccionarAsignacionVM.FechaInicio, seleccionarAsignacionVM.FechaFinal);
if (ventasDependientesPorBar.Any())
{
//Convertinedo en un array de 2 dimensiones
double[,] Tabla = new double[Dependientes.Count, Bares.Count];
for (int f = 0; f < Dependientes.Count; f++)
{
var dependienteId = Dependientes[f].Id;
var ventas = ventasDependientesPorBar
.Any(v => v.DependienteId == dependienteId) ?
ventasDependientesPorBar.SingleOrDefault(v => v.DependienteId == dependienteId).VentasPorBares : new List <VentasPorBar>();
for (int c = 0; c < Bares.Count; c++)
{
var barId = Bares[c].Id;
Tabla[f, c] = ventas.Any(v => v.BarId == barId) ? ventas.SingleOrDefault(v => v.BarId == barId).PromedioVentasPorTurno : 0;
}
}
//Balancenado el Problema
if (Tabla.GetLength(0) > Tabla.GetLength(1))
{
int Diferencia = Tabla.GetLength(0) - Tabla.GetLength(1);
double[,] NuevaTabla = new double[Tabla.GetLength(0), Tabla.GetLength(0)];
for (int f = 0; f < Tabla.GetLength(0); f++)
{
for (int c = 0; c < Tabla.GetLength(1); c++)
{
NuevaTabla[f, c] = Tabla[f, c];
}
}
Tabla = NuevaTabla;
//Agregando Bares ficticios
for (int x = 0; x < Diferencia; x++)
{
Bares.Add(new Bar()
{
Nombre = "Ficticio010101"
});
}
}
int[] AsginacionOptima = HungarianAlgorithm.FindAssignments(Tabla, true);
List <string> Asignaciones = new List <string>();
for (int x = 0; x < AsginacionOptima.Count(); x++)
{
if (!(Bares[AsginacionOptima[x]].Nombre == "Ficticio010101"))
{
Asignaciones.Add(Dependientes[x].NombreCompleto + " --> " + Bares[AsginacionOptima[x]].Nombre);
}
}
ViewData["AsignacionOptima"] = Asignaciones;
}
else
{
ViewData["AsignacionOptima"] = new List <string>()
{
"No existe Turnos para esta fecha"
}
};
ViewData["CrearTablaRazon"] = ventasDependientesPorBar;
ViewData["Dependientes"] = _context.Dependientes.OrderBy(c => c.Id).ToList();
var checkedDependientes = _context.Dependientes.ToList().Select(d => new CheckedDependientes()
{
Checked = true, Dependiente = d, DependienteId = d.Id
}).ToList();
ViewData["CheckedDependiente"] = checkedDependientes;
var checkedTurnos = _context.Bares.ToList().Select(b => new CheckedTurno()
{
Checked = true, Bar = b, BarId = b.Id
}).ToList();
ViewData["CheckedBares"] = checkedTurnos;
ViewData["Bares"] = _context.Bares.OrderBy(c => c.Id).ToList();
return(View("Asignacion", ventasDependientesPorBar));
}
public int[] FindAssignments() => HungarianAlgorithm.FindAssignments(_costs);
