public override void Entrenar()
{
this.CentrosIniciales();
int dimensionMedida = Datos[0].Centro.Medidas.Count;
foreach (Clase clase in Datos)
{
for (int i = 0; i < dimensionMedida; i++)
{
clase.Centro.Medidas[i] =
Muestras.Where(f => f.NombreClase == clase.Nombre).Sum(f => f.Medidas[i])
/
Muestras.Count(f => f.NombreClase == clase.Nombre);
}
clase.InicializarMatrizCovarianza(dimensionMedida);
foreach (var item in Muestras.Where(f => f.NombreClase == clase.Nombre))
{
for (int i = 0; i < dimensionMedida; i++)
{
for (int j = 0; j < dimensionMedida; j++)
{
clase.MatrizCovarianza[i][j] +=
((item.Medidas[i] - clase.Centro.Medidas[i]) * (item.Medidas[j] - clase.Centro.Medidas[j]))
/
Muestras.Count(f => f.NombreClase == clase.Nombre);
}
}
}
}
}
private MuestrasDto ConvertToDto(Muestras muestras)
{
MuestrasDto _muestras = new MuestrasDto();
_muestras.Id = muestras.Id;
_muestras.Persona_Muestrada = muestras.Persona_Muestrada;
_muestras.Fecha_Toma = muestras.Fecha_Toma;
_muestras.Persona_Toma_Muestra = muestras.Persona_Toma_Muestra;
return(_muestras);
}
public IActionResult Registrar(Muestras objMuestra)
{
if (ModelState.IsValid)
{
_context.Add(objMuestra);
_context.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
return(View("Index", objMuestra));
}
private MuestraRegistrada ConvertirMuestrasA_DTO(Muestras muestra)
{
MuestraRegistrada muestraRegistrada = new MuestraRegistrada();
muestraRegistrada.Id = muestra.Id;
muestraRegistrada.NombreDeLaPersonaMuestrada = muestra.NombreDeLaPersonaMuestrada;
muestraRegistrada.FechaDeLaToma = muestra.FechaDeLaToma;
muestraRegistrada.NombreDeLaPersonaQueTomaLaMuestra = muestra.NombreDeLaPersonaQueTomaLaMuestra;
return(muestraRegistrada);
}
public void EliminarMuestra(MuestrasDto registroEliminado)
{
using (LaboratorioEntities dbContext = new LaboratorioEntities())
{
Muestras muestra = (from n in dbContext.Muestras
where n.Id == registroEliminado.Id
select n).FirstOrDefault();
dbContext.Muestras.Remove(muestra);
dbContext.SaveChanges();
}
}
public void ActualizarMuestra(MuestrasDto registroActualizado)
{
using (LaboratorioEntities dbContext = new LaboratorioEntities())
{
Muestras muestra = dbContext.Muestras.Find(registroActualizado.Id);
muestra.Persona_Muestrada = registroActualizado.Persona_Muestrada;
muestra.Fecha_Toma = registroActualizado.Fecha_Toma;
muestra.Persona_Toma_Muestra = registroActualizado.Persona_Toma_Muestra;
dbContext.Entry(muestra);
dbContext.SaveChanges();
}
}
public MuestraRegistrada ActualizarMuestra(MuestraActualizada muestraActualizada)
{
using (Laboratorio laboratorio = new Laboratorio())
{
Muestras muestra = laboratorio.Muestras.Find(muestraActualizada.Id);
muestra.Id = muestraActualizada.Id;
muestra.NombreDeLaPersonaMuestrada = muestraActualizada.NombreDeLaPersonaMuestrada;
muestra.FechaDeLaToma = muestraActualizada.FechaDeLaToma;
muestra.NombreDeLaPersonaQueTomaLaMuestra = muestraActualizada.NombreDeLaPersonaQueTomaLaMuestra;
return(ConvertirMuestrasA_DTO(muestra));
}
}
public MuestrasDto RegistrarMuestra(MuestrasDto nuevoRegistro)
{
using (LaboratorioEntities dbContext = new LaboratorioEntities())
{
Muestras muestras = new Muestras();
muestras.Persona_Muestrada = nuevoRegistro.Persona_Muestrada;
muestras.Fecha_Toma = nuevoRegistro.Fecha_Toma;
muestras.Persona_Toma_Muestra = nuevoRegistro.Persona_Toma_Muestra;
dbContext.Muestras.Add(muestras);
dbContext.SaveChanges();
return(ConvertToDto(muestras));
}
}
public MuestraRegistrada CrearMuestra(NuevaMuestra nuevaMuestra)
{
using (Laboratorio labotorio = new Laboratorio())
{
Muestras muestra = new Muestras();
muestra.NombreDeLaPersonaMuestrada = nuevaMuestra.NombreDeLaPersonaMuestrada;
muestra.FechaDeLaToma = nuevaMuestra.FechaDeLaToma;
muestra.NombreDeLaPersonaQueTomaLaMuestra = nuevaMuestra.NombreDeLaPersonaQueTomaLaMuestra;
labotorio.Muestras.Add(muestra);
labotorio.SaveChanges();
return(ConvertirMuestrasA_DTO(muestra));
}
}
public void construirSenalDigital()
{
double periodoMuestreo = 1 / FrecuenciaMuestreo;
for (double i = TiempoInicial; i <= TiempoFinal; i += periodoMuestreo)
{
double valorMuestral = evaluar(i);
Muestras.Add(new Muestra(i, valorMuestral));
if (Math.Abs(valorMuestral) > AmplitudMaxima)
{
AmplitudMaxima = Math.Abs(valorMuestral);
}
}
}
public void construirSeñal()
{
double periodoMuestreo = 1 / FrecuenciaMuestreo;
for (double i = TiempoInicial; i <= TiempoFinal; i += periodoMuestreo)
{
double muestra = evaluar(i);
Muestras.Add(new Muestra(i, muestra));
if (Math.Abs(muestra) > AmplitudMaxima)
{
AmplitudMaxima = Math.Abs(muestra);
}
}
}
public void construirSenalDigital()
{
double periodoMuestreo = 1 / FrecMuestreo;
for (double i = TiempoInicial; i <= TiempoFinal; i += periodoMuestreo)
{
double valorMuestra = evaluar(i);
if (Math.Abs(valorMuestra) > amplitudMaxima)
{
amplitudMaxima = Math.Abs(valorMuestra);
}
//se van añadiendo las muestras a la lista.
Muestras.Add(new Muestra(i, valorMuestra));
}
}
public void construirSeñalDigital()
{
//calcular el periodo
double periodoMuestreo = 1 / FrecuenciaMuestreo; //esto se llama sacar el inverso
//Se construye la señal digital, se delimita el tiempo con el for
for (double i = TiempoInicial; i <= TiempoFinal; i += periodoMuestreo)
{
double valorMuestra = evaluar(i);
//se calcula el numero mas alto que puede tomar la señal
if (Math.Abs(valorMuestra) > AmplitudMaxima)
{
AmplitudMaxima = Math.Abs(valorMuestra);
}
//se van añadiendo las muestras a las listas
Muestras.Add(new Muestra(i, valorMuestra));
}
}
public async Task <IActionResult> Editar(int id, [Bind("Id,Muestra,Descripcion,Img,Precio")] Muestras m)
{
if (id != m.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(m);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
return(NotFound());
}
return(RedirectToAction(nameof(Index)));
}
return(View(m));
}
public override void Entrenar()
{
CentrosIniciales();
var numeroMuestras = Muestras.Count;
var numeroClases = this.Datos.Count();
var dimensionMuestra = Muestras.First().Medidas.Count();
do
{
//Crear matriz pertenencia
double[][] pertenencia = new double[numeroClases][];
for (int i = 0; i < numeroClases; i++)
{
pertenencia[i] = new double[numeroMuestras];
}
//Calculamos matriz pertenencia
for (int j = 0; j < numeroMuestras; j++)
{
List <double> distancias = CalcularPertenenciaClases(Muestras[j]);
for (int i = 0; i < numeroClases; i++)
{
pertenencia[i][j] = distancias[i];
}
}
//Calculamos los nuevos centros para cada clase
for (int i = 0; i < numeroClases; i++)
{
//Calculamos la suma para el divisor
double sumaClase = pertenencia[i].Sum(f => Math.Pow(f, PesoExponencialB));
//double sumaClase = pertenencia[i].Sum();
//Calculamos la suma para el dividendo
double[][] sumaParcialDividendo = new double[dimensionMuestra][];
for (int l = 0; l < dimensionMuestra; l++)
{
sumaParcialDividendo[l] = new double[numeroMuestras];
}
for (int j = 0; j < numeroMuestras; j++)
{
for (int k = 0; k < dimensionMuestra; k++)
{
sumaParcialDividendo[k][j] +=
Muestras[j].Medidas[k] * Math.Pow(pertenencia[i][j], PesoExponencialB);
}
}
//Actualizamos los valores del centro de cada clase
for (int m = 0; m < dimensionMuestra; m++)
{
Datos[i].Centro.Medidas[m] = sumaParcialDividendo[m].Sum(f => f) / sumaClase;
}
}
} while (SeguirCalculando());
//Una vez que hemos acabado el entrenamiento actualizamos los centros
for (int i = 0; i < Centros.Count; i++)
{
for (int j = 0; j < Centros[i].Medidas.Count; j++)
{
Centros[i].Medidas[j] = Datos[i].Centro.Medidas[j];
}
}
}
