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