public static double ModuloComplejo(Complejos z)
{
double resultado;
resultado = Math.Sqrt(Math.Pow(z.Real, 2) + Math.Pow(z.Imaginario, 2));
return(resultado);
}
public static double Tita(Complejos complejo)
{
double tita;
tita = Math.Atan2(complejo.Imaginario, complejo.Real);
return(tita);
}
public static double Ro(Complejos complejo)
{
double ro;
ro = Math.Sqrt(Math.Pow(complejo.Real, 2) + Math.Pow(complejo.Imaginario, 2));
return(ro);
}
public static Complejos Julia(Complejos z, Complejos c)
{
Complejos resultado = new Complejos();
resultado = SumaComplejos(CuadradoComplejos(z), c);
return(resultado);
}
public static double DistanciaEntreComplejos(Complejos complejo1, Complejos complejo2)
{
double distancia;
distancia = Math.Sqrt(Math.Pow((complejo1.Real - complejo2.Real), 2) + Math.Pow((complejo1.Imaginario - complejo2.Imaginario), 2));
return(distancia);
}
public static Complejos.Complejos IteradaInversaNegativa(Complejos.Complejos c)
{
Complejos.Complejos resultado = new Complejos.Complejos();
Complejos.Complejos puntofijo = PuntoFijoNegativo(c);
resultado = Complejos.Complejos.RaizCuadradaComplejo(Complejos.Complejos.RestaComplejos(puntofijo, c));
return(resultado);
}
public static Complejos CuadradoComplejos(Complejos z)
{
Complejos resultado = new Complejos();
resultado.Real = Math.Pow(z.Real, 2) - Math.Pow(z.Imaginario, 2);
resultado.Imaginario = 2 * z.Real * z.Imaginario;
return(resultado);
}
public static Complejos Dividirpor2(Complejos complejo)
{
Complejos resultado = new Complejos();
resultado.Real = complejo.Real / 2;
resultado.Imaginario = complejo.Imaginario / 2;
return(resultado);
}
public static Complejos RestaComplejos(Complejos numero1, Complejos numero2)
{
Complejos resultado = new Complejos();
resultado.Real = numero1.Real - numero2.Real;
resultado.Imaginario = numero1.Imaginario - numero2.Imaginario;
return(resultado);
}
public static Complejos.Complejos PuntoFijoPositivo(Complejos.Complejos c)
{
Complejos.Complejos puntofijopos = new Complejos.Complejos();
Complejos.Complejos radicando = new Complejos.Complejos();
radicando = Complejos.Complejos.Radicando(c);
puntofijopos = Complejos.Complejos.Dividirpor2(Complejos.Complejos.SumaComplejos(menosuno, radicando));
return(puntofijopos);
}
public static Complejos.Complejos PuntoFijoNegativo(Complejos.Complejos c)
{
Complejos.Complejos puntofijoneg = new Complejos.Complejos();
Complejos.Complejos radicando = new Complejos.Complejos();
radicando = Complejos.Complejos.Radicando(c);
puntofijoneg = Complejos.Complejos.Dividirpor2(Complejos.Complejos.RestaComplejos(menosuno, radicando));
return(puntofijoneg);
}
public static Complejos MultiplicarPorReal(Complejos complejo, double numero)
{
Complejos resultado = new Complejos
{
Real = complejo.Real * numero,
Imaginario = complejo.Imaginario * numero
};
return(resultado);
}
public static Complejos RaizCuadradaComplejo(Complejos complejo)
{
Complejos raizcuadradacomplejo = new Complejos();
double ro = Ro(complejo);
double tita = Tita(complejo);
raizcuadradacomplejo.Imaginario = Math.Sqrt(ro) * Math.Sin(tita / 2);
raizcuadradacomplejo.Real = Math.Sqrt(ro) * Math.Cos(tita / 2);
return(raizcuadradacomplejo);
}
public static Complejos Radicando(Complejos c)
{
Complejos radicando = new Complejos();
Complejos cuatroC = new Complejos();
cuatroC = MultiplicarPorReal(c, 4);
radicando = RaizCuadradaComplejo(RestaComplejos(uno, cuatroC));
return(radicando);
}
public static Complejos JuliaIterada(Complejos z, Complejos c, int iterada)
{
int cont = 1;
Complejos resultado = new Complejos();
resultado = Julia(z, c);
while (cont < iterada)
{
resultado = Julia(resultado, c);
cont++;
}
return(resultado);
}
public void Restar(Complejos Complejo1, Complejos Complejo2)
{
double SumaReal = Complejo1.ParteReal - Complejo2.ParteReal;
double SumaImaginaria = Complejo1.ParteImaginaria - Complejo2.ParteImaginaria;
if (SumaImaginaria > 0)
{
Console.WriteLine("La resta de los numeros complejos es: " + SumaReal + " + " + SumaImaginaria);
}
else
{
Console.WriteLine("La resta de los numeros complejos es: " + SumaReal + " - " + Math.Abs(SumaImaginaria) + "i");
}
}
public static List <Complejos.Complejos> IteradaInversaPuntoFijoPositivo(Complejos.Complejos c)
{
List <Complejos.Complejos> InversaPositivayNegativa = new List <Complejos.Complejos>();
Complejos.Complejos puntoFijoPositivo = new Complejos.Complejos();
puntoFijoPositivo = PuntoFijoPositivo(c);
Complejos.Complejos InversaPositiva = new Complejos.Complejos();
InversaPositiva = InversaFuncionJulia(puntoFijoPositivo, c, "positivo");
Complejos.Complejos inversaNegativa = new Complejos.Complejos();
inversaNegativa = InversaFuncionJulia(puntoFijoPositivo, c, "negativo");
InversaPositivayNegativa.Add(inversaNegativa);
InversaPositivayNegativa.Add(InversaPositiva);
return(InversaPositivayNegativa);
}
public static void MostrarEnpantallaUnComplejo(Complejos complejo)
{
if (complejo.Imaginario > 0)
{
Console.WriteLine("El número es " + complejo.Real + " + " + complejo.Imaginario + "i");
}
else if (complejo.Imaginario < 0)
{
Console.WriteLine("El número es " + complejo.Real + complejo.Imaginario + "i");
}
else
{
Console.WriteLine("El número es " + complejo.Real);
}
}
static void Main(String[] args)
{
Console.WriteLine("Bienvenido!");
Complejos Operaciones = new Complejos();
Complejos ComplejoUno = new Complejos(6, 1);
Complejos ComplejoDos = new Complejos(5.196, 3);
Console.WriteLine();
Operaciones.Sumar(ComplejoUno, ComplejoDos);
Console.WriteLine();
Operaciones.Restar(ComplejoUno, ComplejoDos);
Console.WriteLine();
Operaciones.Multiplicar(ComplejoUno, ComplejoDos);
Console.WriteLine();
Operaciones.Dividir(ComplejoUno, ComplejoDos);
}
public static List <Complejos.Complejos> IteradasInversasConDistanciaFijoPositivo1(Complejos.Complejos c, double distancia, int totalIteradas)
{
List <Complejos.Complejos> puntosJulia = new List <Complejos.Complejos>();
//puntosJulia.Add(c);
Complejos.Complejos puntoFijoPositivo = new Complejos.Complejos();
puntoFijoPositivo = PuntoFijoPositivo(c);
puntosJulia.Add(puntoFijoPositivo);
List <Complejos.Complejos> NuevospuntosJulia = new List <Complejos.Complejos>();
List <Complejos.Complejos> ListaAuxiliar = new List <Complejos.Complejos>();
Complejos.Complejos inversaPositiva = new Complejos.Complejos();
Complejos.Complejos inversaNegativa = new Complejos.Complejos();
int iter = 0;
int longitudJulia = 1;
int posicionEmpiezaIteradas = 0;
int nuevosElementosJulia = 0;
do
{
for (int i = posicionEmpiezaIteradas; i < longitudJulia; i++)
{
ListaAuxiliar = IteradaInversaPuntoFijoPositivo(puntosJulia[i]);
inversaPositiva = InversaFuncionJulia(puntosJulia[i], c, "positivo");
inversaNegativa = InversaFuncionJulia(puntosJulia[i], c, "negativo");
//ListaAuxiliar=IteradaConDistanciaFijoPositivo(puntosJulia[i],distancia);
if (CompruebaDistaciaAListaMayorP(puntosJulia, inversaPositiva, distancia))
{
puntosJulia.Add(inversaPositiva);
nuevosElementosJulia++;
}
if (CompruebaDistaciaAListaMayorP(puntosJulia, inversaNegativa, distancia))
{
puntosJulia.Add(inversaNegativa);
nuevosElementosJulia++;
}
}
posicionEmpiezaIteradas = puntosJulia.Count - nuevosElementosJulia;
//longitudJulia =CantidadListaComplejos(puntosJulia)-1;
longitudJulia = puntosJulia.Count;
ListaAuxiliar.Clear();
iter++;
nuevosElementosJulia = 0;
} while (iter < totalIteradas);
return(puntosJulia);
}
public static Complejos.Complejos InversaFuncionJulia(Complejos.Complejos y, Complejos.Complejos c, string signoraiz)
{
Complejos.Complejos resultado = new Complejos.Complejos();
resultado = Complejos.Complejos.RaizCuadradaComplejo(Complejos.Complejos.RestaComplejos(y, c));
if (signoraiz == "positivo")
{
return(resultado);
}
else if (signoraiz == "negativo")
{
return(Complejos.Complejos.MultiplicarPorReal(resultado, -1));;
}
else
{
Console.WriteLine("El signo tiene que ser positivo o negativo");
return(null);
}
}
public static List <Complejos> IteradaConDistanciaFijoPositivo(Complejos c, double distancia)
{
List <Complejos> puntosJulia = new List <Complejos>();
puntosJulia.Add(c);
Complejos puntoFijoPositivo = new Complejos();
List <Complejos> juliaPuntoFijoPos = new List <Complejos>();
juliaPuntoFijoPos = IteradaInversaPuntoFijoPositivo(c);
if (CompruebaDistaciaAListaMayorP(puntosJulia, juliaPuntoFijoPos[0], distancia))
{
puntosJulia.Add(juliaPuntoFijoPos[0]);
}
if (CompruebaDistaciaAListaMayorP(puntosJulia, juliaPuntoFijoPos[1], distancia))
{
puntosJulia.Add(juliaPuntoFijoPos[1]);
}
puntosJulia.Remove(c);
return(puntosJulia);
}
/* public static List<Complejos> IteradasInversasConDistanciaFijoPositivo(Complejos c,double distancia, int totalIteradas)
* {
* List<Complejos> puntosJulia = new List<Complejos>();
* puntosJulia.Add(c);
* List<Complejos> listaAuxiliarParaPuntosJulia=new List<Complejos>();
* Complejos puntoFijoPositivo = new Complejos();
* puntoFijoPositivo = PuntoFijoPositivo(c);
* int iter = 0;
* int posicionDondeAplicaInversaFuncion = 0;
* int longitudListaJuliaIteradaAnterior = 1;
* int valoresIntroducidos = 0;
*
* do
* {
* listaAuxiliarParaPuntosJulia = IteradaInversaPuntoFijoPositivo(c);
* while (posicionDondeAplicaInversaFuncion < longitudListaJuliaIteradaAnterior)
* {
* //listaAuxiliarParaPuntosJulia = IteradaInversaPuntoFijoPositivo(c);
* if (CompruebaDistaciaAListaMayorP(puntosJulia, listaAuxiliarParaPuntosJulia[0], distancia)){
* puntosJulia.Add(listaAuxiliarParaPuntosJulia[0]);
* valoresIntroducidos++;
* }
* if (CompruebaDistaciaAListaMayorP(puntosJulia, listaAuxiliarParaPuntosJulia[1], distancia))
* {
* puntosJulia.Add(listaAuxiliarParaPuntosJulia[1]);
* valoresIntroducidos++;
* }
* }
* posicionDondeAplicaInversaFuncion = puntosJulia.Count - valoresIntroducidos;
* valoresIntroducidos = 0;
* iter++;
*
* } while (iter < totalIteradas);
*
* return puntosJulia;
* }
*/
public static Boolean CompruebaDistaciaAListaMayorP(List <Complejos> listaComplejos, Complejos elemento, double p)
{
Boolean distancia = true;
foreach (Complejos item in listaComplejos)
{
if (DistanciaEntreComplejos(item, elemento) < p)
{
distancia = false;
break;
}
}
return(distancia);
}
public static List <Complejos> IntroduceEltoEnLtcomplejosSiDistanciaMayorP(List <Complejos> listaComplejos, Complejos elemento, double p)
{
Boolean elementosLejanos = true;
foreach (Complejos item in listaComplejos)
{
if (DistanciaEntreComplejos(item, elemento) < p)
{
elementosLejanos = false;
break;
}
}
if (elementosLejanos)
{
listaComplejos.Add(elemento);
}
return(listaComplejos);
}
public void Multiplicar(Complejos Complejo1, Complejos Complejo2)
{
/* Hallamos el modulo de los dos numeros complejos */
double Modulo1 = Math.Sqrt(Math.Pow(Complejo1.ParteReal, 2) + Math.Pow(Complejo1.ParteImaginaria, 2));
double Modulo2 = Math.Sqrt(Math.Pow(Complejo2.ParteReal, 2) + Math.Pow(Complejo2.ParteImaginaria, 2));
/* Hallamos el angulo de los numeros complejos, como el resultado sale en Radianes se lo convierte a sexagesimal */
double Tan1 = Math.Atan(Complejo1.ParteImaginaria / Complejo1.ParteReal) * (180 / Math.PI);
double Tan2 = Math.Atan(Complejo2.ParteImaginaria / Complejo2.ParteReal) * (180 / Math.PI);
double Angulo1 = 0;
double Angulo2 = 0;
/* ? Se lleva el angulo obtenido anteriormente al siguiente rango (0° - 360°=) : 0° < angulo < 360° */
if (Complejo1.ParteReal > 0 && Complejo1.ParteImaginaria > 0)
{
Angulo1 = Tan1;
}
else
{
if (Complejo1.ParteReal < 0 && Complejo1.ParteImaginaria > 0)
{
Angulo1 = 180 + Tan1;
}
else
{
if (Complejo1.ParteReal < 0 && Complejo1.ParteImaginaria < 0)
{
Angulo1 = 180 + Tan1;
}
else
{
if (Complejo1.ParteReal > 0 && Complejo1.ParteImaginaria < 0)
{
Angulo1 = 360 + Tan1;
}
}
}
}
if (Complejo2.ParteReal > 0 && Complejo2.ParteImaginaria > 0)
{
Angulo2 = Tan2;
}
else
{
if (Complejo2.ParteReal < 0 && Complejo2.ParteImaginaria > 0)
{
Angulo2 = 180 + Tan2;
}
else
{
if (Complejo2.ParteReal < 0 && Complejo2.ParteImaginaria < 0)
{
Angulo2 = 180 + Tan2;
}
else
{
if (Complejo2.ParteReal > 0 && Complejo2.ParteImaginaria < 0)
{
Angulo2 = 360 + Tan2;
}
}
}
}
/* Hallamos el valor del modulo y el angulo resultante */
double ModuloResultante = Modulo1 * Modulo2;
double AnguloResultante = Angulo1 + Angulo2;
/* Covertimos el AnguloResultante a Radianes para poder realizar el calculo */
double AnguloCalculo = (AnguloResultante * Math.PI) / 180;
/* Operacion Final para hallar el resultado de la parte real e imaginaria en forma binaria */
decimal ResultadoReal = Math.Round(Convert.ToDecimal(ModuloResultante * Math.Cos(AnguloCalculo)), 0);
decimal ResultadoImaginario = Math.Round(Convert.ToDecimal(ModuloResultante * Math.Sin(AnguloCalculo)), 0);
/* Mostramos el resultado por consola */
if (ResultadoImaginario > 0)
{
Console.WriteLine("La multiplicacion de los numeros complejos es: " + ResultadoReal + " + " + ResultadoImaginario + "i");
}
else
{
Console.WriteLine("La multiplicacion de los numeros complejos es: " + ResultadoReal + " - " + Math.Abs(ResultadoImaginario) + "i");
}
Console.WriteLine("El resultado en la forma polar es : " + "Modulo --> " + Math.Round(Convert.ToDecimal(ModuloResultante), 2) + " ; Angulo --> " + Math.Round(Convert.ToDecimal(AnguloResultante), 2));
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
Complejos.Complejos uno = new Complejos.Complejos();
uno.Real = 1;
uno.Imaginario = 0;
Complejos.Complejos prueba = new Complejos.Complejos();
prueba.Real = 2.2;
prueba.Imaginario = -1.75;
Complejos.Complejos prueba1 = new Complejos.Complejos();
prueba1.Real = 0;
prueba1.Imaginario = -0.156;
Complejos.Complejos prueba2 = new Complejos.Complejos();
prueba2.Real = 36.9;
prueba2.Imaginario = -2.25;
Complejos.Complejos radicando = new Complejos.Complejos();
radicando = Complejos.Complejos.PuntoFijoPositivo(prueba);
Console.WriteLine(radicando.Real);
Console.WriteLine(radicando.Imaginario);
Complejos.Complejos.MostrarEnpantallaUnComplejo(radicando);
Complejos.Complejos origen = new Complejos.Complejos(0, 0);
List <Complejos.Complejos> julia = new List <Complejos.Complejos>();
julia = Complejos.Complejos.IteradaInversaPuntoFijoNegativa(prueba);
List <Complejos.Complejos> julia1 = new List <Complejos.Complejos>();
julia1 = Complejos.Complejos.IntroduceEltoEnLtcomplejosSiDistanciaMayorP(julia, prueba, 2.27);
Complejos.Complejos.ImprimeListaComplejos(julia1);
double distancia1 = Complejos.Complejos.DistanciaEntreComplejos(julia[0], prueba);
Console.WriteLine(distancia1);
List <Complejos.Complejos> elementosjulia = new List <Complejos.Complejos>();
elementosjulia = Complejos.Complejos.IteradaInversaPuntoFijoPositivo(prueba);
Complejos.Complejos.ImprimeListaComplejos(elementosjulia);
Complejos.Complejos c = new Complejos.Complejos();
c = prueba;
double distancia = 3;
List <Complejos.Complejos> puntosJulia = new List <Complejos.Complejos>();
puntosJulia.Add(c);
Console.WriteLine("prueba1");
Complejos.Complejos.ImprimeListaComplejos(puntosJulia);
Complejos.Complejos puntoFijoPositivo = new Complejos.Complejos();
List <Complejos.Complejos> juliaPuntoFijoPos = new List <Complejos.Complejos>();
juliaPuntoFijoPos = Complejos.Complejos.IteradaInversaPuntoFijoPositivo(c);
if (Complejos.Complejos.CompruebaDistaciaAListaMayorP(puntosJulia, juliaPuntoFijoPos[0], distancia))
{
puntosJulia.Add(juliaPuntoFijoPos[0]);
}
if (Complejos.Complejos.CompruebaDistaciaAListaMayorP(puntosJulia, juliaPuntoFijoPos[1], distancia))
{
puntosJulia.Add(juliaPuntoFijoPos[1]);
}
Console.WriteLine("prueba2");
Complejos.Complejos.ImprimeListaComplejos(puntosJulia);
Console.WriteLine("prueba3");
List <Complejos.Complejos> pruebaLista2 = new List <Complejos.Complejos>();
Console.WriteLine("prueba4");
pruebaLista2 = Complejos.Complejos.IteradaConDistanciaFijoPositivo(prueba, 0.4);
Complejos.Complejos.ImprimeListaComplejos(pruebaLista2);
Boolean pruebabol = Complejos.Complejos.CompruebaDistaciaAListaMayorP(pruebaLista2, prueba, 2);
Console.WriteLine(pruebabol);
Console.WriteLine("prueba addrange");
List <Complejos.Complejos> pruebalista5 = new List <Complejos.Complejos>();
pruebalista5.AddRange(puntosJulia);
Console.WriteLine("prueba addrange");
Complejos.Complejos.ImprimeListaComplejos(puntosJulia);
Console.WriteLine("prueba addrange");
Complejos.Complejos.ImprimeListaComplejos(pruebalista5);
pruebalista5.AddRange(pruebaLista2);
Console.WriteLine("prueba addrange");
Complejos.Complejos.ImprimeListaComplejos(pruebaLista2);
Console.WriteLine("prueba addrange");
Complejos.Complejos.ImprimeListaComplejos(pruebalista5);
Console.WriteLine("prueba iteradas");
List <Complejos.Complejos> pruebaiteradas = new List <Complejos.Complejos>();
int i = Complejos.Complejos.CantidadListaComplejos(pruebalista5);
Console.WriteLine(i);
pruebaiteradas = Complejos.Complejos.IteradaInversaPuntoFijoPositivo(prueba);
Complejos.Complejos prueba6 = new Complejos.Complejos();
prueba6 = Complejos.Complejos.PuntoFijoPositivo(prueba);
//prueba2 = Complejos.Complejos.PuntoFijoPositivo(prueba1);
//pruebaiteradas = Complejos.Complejos.IteradasInversasConDistanciaFijoPositivo(prueba1, 0.00015, 95);
//Complejos.Complejos.ImprimeListaComplejos(pruebaiteradas);
Complejos.Complejos.MostrarEnpantallaUnComplejo(prueba6);
Console.WriteLine("prueba definitiva");
List <Complejos.Complejos> listaprueba = new List <Complejos.Complejos>();
Complejos.Complejos jul = new Complejos.Complejos(0, -0.156);
listaprueba = Complejos.Complejos.IteradasInversasConDistanciaFijoPositivo(prueba, 0.00007, 5);
Complejos.Complejos.ImprimeListaComplejos(listaprueba);
Console.WriteLine(listaprueba.Count);
Console.WriteLine("prueba puntodijo");
List <Complejos.Complejos> listaprueba1 = new List <Complejos.Complejos>();
//listaprueba1 = Complejos.Escaneado.PasoMalla(origen,10,5,5);
//Complejos.Complejos.ImprimeListaComplejos(listaprueba1);
//listaprueba = Complejos.Complejos.IteradasInversasConDistanciaFijoPositivo1(prueba, 0.00007, 5);
//Complejos.Complejos.ImprimeListaComplejos(listaprueba);
int dividi = 10;
double p = Convert.ToDouble(dividi);
Console.WriteLine(dividi);
double cinco = 5;
for (int v = 0; v < 5; v++)
{
cinco += 1 / p;
Console.WriteLine(cinco);
}
Console.WriteLine("paso de malla");
List <Complejos.Complejos> pruebamalla = new List <Complejos.Complejos>();
pruebamalla = Complejos.Escaneado.PasoMalla(origen, 10, 5, 5);
Complejos.Complejos.ImprimeListaComplejos(pruebamalla);
Console.WriteLine(pruebamalla.Count);
Complejos.Complejos prubajiter = new Complejos.Complejos();
prubajiter = Complejos.Complejos.JuliaIterada(prueba, prueba1, 3);
Complejos.Complejos.MostrarEnpantallaUnComplejo(prubajiter);
Console.WriteLine("metodoescaneado");
List <Complejos.Complejos> pruebamEsca = new List <Complejos.Complejos>();
pruebamEsca = Complejos.Escaneado.MallaJulia(origen, 2);
Complejos.Complejos.ImprimeListaComplejos(pruebamEsca);
Console.WriteLine(pruebamEsca.Count);
Complejos.Complejos tres = new Complejos.Complejos(3, 3);
Console.WriteLine(Complejos.Complejos.ModuloComplejo(tres));
Complejos.Complejos prueba3 = new Complejos.Complejos(0.8, 0.6);
Console.WriteLine("Escaneado1");
List <Complejos.Complejos> escaneado1 = new List <Complejos.Complejos>();
escaneado1 = Complejos.Escaneado.MetodoEscaneado1(prueba3, 25, 1000, 100);
Complejos.Complejos.ImprimeListaComplejos(escaneado1);
Console.WriteLine(escaneado1.Count);
}
