public Complejo MultiplicarComplejoEscalar(Complejo primerNumeroComplejo, double segundoNumeroComplejo)
{
var parteReal = primerNumeroComplejo.Real * segundoNumeroComplejo;
var parteImaginaria = primerNumeroComplejo.Imaginaria * segundoNumeroComplejo;
return(new Complejo(parteReal, parteImaginaria));
}
// GET: Complejo/Delete/5
public ActionResult Delete(decimal id)
{
Complejo complejo = _ComplejoService.GetById <Complejo>(id);
ViewData["pSedeOlimpicaId"] = pSedeOlimpicaId;
return(View(complejo));
}
public void TestEsIgual2()
{
double mNumeroReal = 1;
double mNumeroImaginario = 1;
Assert.IsFalse(Complejo.Crear(mNumeroReal, mNumeroImaginario).EsIgual(mNumeroReal, -mNumeroImaginario));
}
public static void InsertarActualizarValoracionComplejo(int puntaje, string titulo, string comentario, int codigoComplejo, int codigoUsuarioApp)
{
ISession nhSesion = ManejoNHibernate.IniciarSesion();
try
{
Complejo complejo = CatalogoGenerico <Complejo> .RecuperarPorCodigo(codigoComplejo, nhSesion);
ValoracionComplejo valCom = complejo.ValoracionesComplejo.Where(x => x.UsuarioApp.Codigo == codigoUsuarioApp).SingleOrDefault();
if (valCom == null)
{
valCom = new ValoracionComplejo();
complejo.ValoracionesComplejo.Add(valCom);
}
valCom.Comentario = comentario;
valCom.Puntaje = puntaje;
valCom.Titulo = titulo;
valCom.FechaHoraValoracionComplejo = DateTime.Now;
valCom.UsuarioApp = CatalogoGenerico <UsuarioApp> .RecuperarPorCodigo(codigoUsuarioApp, nhSesion);
CatalogoGenerico <Complejo> .InsertarActualizar(complejo, nhSesion);
}
catch (Exception ex)
{
throw ex;
}
finally
{
nhSesion.Close();
nhSesion.Dispose();
}
}
public async Task <int> Registro(Complejo entidad)
{
_context.Complejo.Add(entidad);
var salida = await _context.SaveChangesAsync();
return(salida);
}
public async Task <ActionResult <Complejo> > PostComplejo(Complejo complejo)
{
_context.Complejos.Add(complejo);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetComplejo", new { id = complejo.Id }, complejo));
}
public void Graficar(float h, float k, float r, float Ax, float Ay, float Bx, float By, float Cx, float Cy, float Dx, float Dy)
{
limits = 0;
originalC = new Circulo(h, k, r);
GenerarCirculo(originalC, originalCircle, cam1, originalxCoord, originalyCoord, textOriginalCoords);
A = new Complejo(Ax, Ay);
B = new Complejo(Bx, By);
C = new Complejo(Cx, Cy);
D = new Complejo(Dx, Dy);
Complejo T1 = D / C;
transformedC = TransormarPorSuma(originalC, T1);
transformedC = TransormarConInversion(transformedC);
// bc-ad / c*c
Complejo T3Den = C * C;
Complejo T3a = B * C;
Complejo T3b = A * D;
Complejo T3resta = T3a - T3b;
Complejo T3 = T3resta / T3Den;
transformedC = TransormarPorMultiplicacion(transformedC, T3);
Complejo T4 = A / C;
transformedC = TransormarPorSuma(transformedC, T4);
//transformedC = TransormarPorMultiplicacion( originalC, A);
GenerarCirculo(transformedC, transformedCircle, cam2, transformedxCoord, transformedyCoord, textTransformedCoords);
}
public Complejo DividirComplejo(Complejo primerNumeroComplejo, Complejo segundoNumeroComplejo)
{
var conjugada_imaginaria = segundoNumeroComplejo.Imaginaria * -1;
var expresionConjugada = new Complejo(segundoNumeroComplejo.Real, conjugada_imaginaria);
//Parte del dividendo
var primerF = primerNumeroComplejo.Real * segundoNumeroComplejo.Real;
var segundoF = primerNumeroComplejo.Real * expresionConjugada.Imaginaria;
var tercerF = primerNumeroComplejo.Imaginaria * segundoNumeroComplejo.Real;
var cuartoF = primerNumeroComplejo.Imaginaria * expresionConjugada.Imaginaria;
var cuartoC = cuartoF * -1;
var dividendo_1 = (primerF + cuartoC);
var dividendo_2 = (segundoF + tercerF);
var quintoFactor = segundoNumeroComplejo.Real * segundoNumeroComplejo.Real;
var sextofactor = segundoNumeroComplejo.Imaginaria * expresionConjugada.Imaginaria;
var sextoCambio = sextofactor * -1;
var divisor = quintoFactor + sextoCambio;
var parteReal = dividendo_1 / divisor;
var parteImaginaria = dividendo_2 / divisor;
var resultado = new Complejo(parteReal, parteImaginaria);
return(resultado);
}
public string AgregarComplejo(Complejo complejo)
{
if (complejo == null)
{
return("Por favor ingrese datos para el complejo");
}
int maximoCarcteresParaNombre = 20;
var nombreEsDemasiadoLargo = complejo.nombre.Count() > maximoCarcteresParaNombre;
var nombreEstaEnBlanco = complejo.nombre == string.Empty;
var direccionEnBlanco = complejo.localidad == string.Empty;
if (nombreEstaEnBlanco)
{
return("El nombre no puede ser nulo.");
}
if (nombreEsDemasiadoLargo)
{
return("El nombre contiene mas caracteres de lo permitido.");
}
if (direccionEnBlanco)
{
return("La direccion no puede ser nulo");
}
return(null);
}
public void TestEsIgual1()
{
double mNumeroReal = 1;
double mNumeroImaginario = 1;
Assert.IsTrue(Complejo.Crear(mNumeroReal, mNumeroImaginario).EsIgual(Complejo.Crear(mNumeroReal, mNumeroImaginario)));
}
public Complejo MultiplicarComplejo(Complejo primerNumeroComplejo, Complejo segundoNumeroComplejo)
{
var parteReal = (primerNumeroComplejo.Real * segundoNumeroComplejo.Real) - (primerNumeroComplejo.Imaginaria * segundoNumeroComplejo.Imaginaria);
var parteImaginaria = (primerNumeroComplejo.Real * segundoNumeroComplejo.Imaginaria) + (primerNumeroComplejo.Imaginaria * segundoNumeroComplejo.Real);
return(new Complejo(parteReal, parteImaginaria));
}
public async Task <IActionResult> PutComplejo(int id, Complejo complejo)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != complejo.Id)
{
return(BadRequest());
}
_context.Entry(complejo).State = EntityState.Modified;
try
{
await CrearOEditarEventos(complejo.Eventos);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ComplejoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public Complejo Sumar(Complejo primerComplejo, Complejo segundoComplejo)
{
var parteReal = primerComplejo.Real + segundoComplejo.Real;
var parteImaginaria = primerComplejo.Imaginaria + segundoComplejo.Imaginaria;
return(new Complejo(parteReal, parteImaginaria));
}
public Complejo RestarComplejo(Complejo primerNumeroComplejo, Complejo segundoNumeroComplejo)
{
var parteReal = primerNumeroComplejo.Real - segundoNumeroComplejo.Imaginaria;
var parteImaginaria = primerNumeroComplejo.Real - segundoNumeroComplejo.Imaginaria;
return(new Complejo(parteReal, parteImaginaria));
}
public void Multiplicar_Null()
{
var complejo = new Complejo(2, 1);
Complejo resultado = complejo.Multiplicar(new Complejo(0, 0));
Complejo resultadoEsperado = new Complejo(0, 0);
Assert.ReferenceEquals(resultadoEsperado, resultado);
}
public void Multiplicar_2Positivo()
{
var complejo = new Complejo(1, 2);
Complejo resultado = complejo.Multiplicar(new Complejo(2, 3));
Complejo resultadoEsperado = new Complejo(1, 5);
Assert.ReferenceEquals(resultadoEsperado, resultado);
}
public void TestConjugado_Positivo()
{
var complejo = new Complejo(2.0, 1);
Complejo resultado = complejo.Conjugado;
Complejo resultadoEsperado = new Complejo(2.0, -1);
Assert.AreEqual(resultadoEsperado.Imaginario, resultado.Imaginario);
}
public void TestDivision()
{
Complejo mAuxResultadoEsperado = Complejo.Crear(-0.5, -1);
Complejo mAuxDivision = Complejo.Crear(-10, 10);
Complejo mDivisionResultado = Complejo.Crear(15, 5).DividirPor(mAuxDivision);
Assert.IsTrue(mDivisionResultado.EsIgual(mAuxResultadoEsperado));
}
public void TestMultiplicar()
{
Complejo mAuxResultadoEsperado = Complejo.Crear(-35, -15);
Complejo mAuxMultiplicar = Complejo.Crear(-5, 2);
Complejo mMultiplicarResultado = Complejo.Crear(5, 5).MultiplicarPor(mAuxMultiplicar);
Assert.IsTrue(mMultiplicarResultado.EsIgual(mAuxResultadoEsperado));
}
public void Sumar_Positivo()
{
var complejo = new Complejo(3, 4);
Complejo resultado = complejo.Sumar(new Complejo(3, 4));
Complejo resultadoEsperado = new Complejo(6, 8);
Assert.ReferenceEquals(resultadoEsperado, resultado);
}
public void EsIgual_UnParámetro_Positivo()
{
var complejo = new Complejo(3, 4);
bool resultado = complejo.EsIgual(new Complejo(3, 4));
bool resultadoEsperado = true;
Assert.AreEqual(resultadoEsperado, resultado);
}
public void TestMagnitud_Positivo()
{
var complejo = new Complejo(3, 4);
double resultado = complejo.Magnitud;
double resultadoEsperado = 5;
Assert.AreEqual(resultadoEsperado, resultado);
}
public void TestArgumentoEnRadianes_Positivo()
{
var complejo = new Complejo(2.0, 1);
double resultado = complejo.ArgumentoEnRadianes;
double resultadoEsperado = 0.463;
Assert.AreEqual(resultadoEsperado, resultado, 0.1);
}
public void TestArgumentoEnGrados_Positivo_ConCalculadoraEnRadianes()
{
var complejo = new Complejo(2.0, 1);
double resultado = complejo.ArgumentoEnGrados;
double resultadoEsperado = 26.527;
Assert.AreEqual(resultadoEsperado, resultado, 0.1);
}
public Complejo Restar(Complejo primerComplejo, Complejo segundoComplejo)
{
var parteReal = primerComplejo.Real - segundoComplejo.Real;
var parteImaginaria = primerComplejo.Imaginaria - segundoComplejo.Imaginaria;
var nuevoComplejo = new Complejo(parteReal, parteImaginaria);
return(nuevoComplejo);
}
public void TestEsImaginario_Verdadero()
{
var complejo = new Complejo(2.0, 1);
bool resultado = complejo.EsImaginario();
bool resultadoEsperado = true;
Assert.AreEqual(resultadoEsperado, resultado);
}
public void Multiplicar_PositivoyNegativo()
{
var complejo = new Complejo(2, 1);
Complejo resultado = complejo.Multiplicar(new Complejo(-1, -2));
Complejo resultadoEsperado = new Complejo(-4, -2);
Assert.ReferenceEquals(resultadoEsperado, resultado);
}
Circulo TransormarPorMultiplicacion(Circulo cir, Complejo comp)
{
float h = cir.h * comp.x - cir.k * comp.y;
float k = cir.h * comp.y + cir.k * comp.x;
float r = Mathf.Sqrt((comp.x * comp.x + comp.y * comp.y) * cir.r * cir.r);
return(new Circulo(h, k, r));
}
// GET: Complejo/Create
public ActionResult Create()
{
Complejo complejo = new Complejo();
complejo.SedeOlimpicaId = pSedeOlimpicaId;
ViewData["pSedeOlimpicaId"] = pSedeOlimpicaId;
return(View(complejo));
}
Circulo TransormarPorSuma(Circulo cir, Complejo comp)
{
float h = cir.h + comp.x;
float k = cir.k + comp.y;
float r = cir.r;
return(new Circulo(h, k, r));
}
public void TestConjugado()
{
Complejo unComplejo = new Complejo(1.0, 1.0),
valorEsperado = new Complejo(1.0, -1.0),
valorObtenido;
valorObtenido = unComplejo.Conjugado();
Assert.AreEqual(valorEsperado.R, unComplejo.Conjugado().R);
Assert.AreEqual(valorEsperado.I, unComplejo.Conjugado().I);
}
public void TestSuma()
{
Complejo unComplejo = new Complejo(1.0, 1.0),
otroComplejo = new Complejo(2.0, 3.0),
valorEsperado = new Complejo(3.0, 4.0),
valorObtenido;
valorObtenido = unComplejo + otroComplejo;
Assert.AreEqual(valorEsperado.R, valorObtenido.R);
Assert.AreEqual(valorEsperado.I, valorObtenido.I);
}
public void InsertOrUpdate(Complejo entity)
{
if(entity.ComplejoId == 0)
{
_context.Complejos.Add(entity);
_context.SetAdded(entity);
}
else
{
_context.SetModified(entity);
}
}
public void TestModulo()
{
Complejo unComplejo = new Complejo(1.0, 1.0);
Assert.AreEqual(Math.Sqrt(2.0), unComplejo.Modulo());
}
public ActionResult Edit(Complejo entity)
{
//TODO guardar en el servicio
return View();
}
public void testSumaYResta()
{
Assert.AreEqual(binomico[2] + binomico[3], binomico[6]);
Assert.AreEqual(binomico[7] - binomico[7], binomico[12]);
Assert.AreEqual(binomico[9] - binomico[6], binomico[2]);
{
var uno = new Complejo(Math.Sqrt(2) / 2, Math.Sqrt(2) / 2, Complejo.Forma.Binomica);
var otro_igual = new Complejo(1, Math.PI / 4, Complejo.Forma.Polar);
Assert.AreEqual(new Complejo(0, 0), uno - otro_igual);
}
}
public void testDivision()
{
Assert.AreEqual(new Complejo(0.0, 0.0), new Complejo(0.0, 0.0) / new Complejo(1.0, 0.0));
Assert.AreEqual(new Complejo(0.0, 0.0), new Complejo(0.0, 0.0) / new Complejo(0.0, 1.0));
{
Complejo nan = new Complejo(1.0, 1.0) / new Complejo(0.0, 0.0);
Assert.IsNaN(nan.a);
Assert.IsNaN(nan.b);
}
Assert.AreEqual(new Complejo(0.5, 0.5), new Complejo(0.0, 2.0) / new Complejo(2.0, 2.0));
Assert.AreEqual(new Complejo(0.0, -1.0), new Complejo(-1.0, 2.0) / new Complejo(-2.0, -1.0));
Assert.That(
new Complejo(1.0, Math.PI / 4.0, Complejo.Forma.Polar) /
new Complejo(2.0, Math.PI / 2.0, Complejo.Forma.Polar),
Is.EqualTo(new Complejo(0.5, Math.PI * 1.75, Complejo.Forma.Polar))
.Within(Complejo.Epsilon));
}
