Beispiel #1
0
        public static FuncionSinusoidal operator +(FuncionSinusoidal izq, FuncionSinusoidal der)
        {
            var fase_izq = izq.fase;
            var fase_der = der.fase;
            var angulo = Angulo.Coseno;

            if (Math.Abs(izq.frecuencia - der.frecuencia) >= Epsilon)
                throw new Exception("No se pueden sumar funciones sinusoidales cuya frecuencia sea diferente");

            if (izq.angulo == Angulo.Seno && der.angulo == Angulo.Seno)
                angulo = Angulo.Seno;

            if (izq.angulo == Angulo.Seno)
                fase_izq = fase_izq - Math.PI / 2;

            if (der.angulo == Angulo.Seno)
                fase_der = fase_der - Math.PI / 2;

            var fasor_izq = new Complejo(izq.amplitud, fase_izq, Complejo.Forma.Polar);
            var fasor_der = new Complejo(der.amplitud, fase_der, Complejo.Forma.Polar);

            var fasor_suma = fasor_izq + fasor_der;

            var fase_total = fasor_suma.b;

            if (angulo == Angulo.Seno)
                fase_total = fase_total + Math.PI / 2;

            return new FuncionSinusoidal(fasor_suma.a, angulo, izq.frecuencia, fase_total);
        }
Beispiel #2
0
        internal List<Complejo> OperacionRaizPrimitiva(string raiz)
        {
            Complejo a = new Complejo(1, 0, Complejo.Forma.Binomica);

            int b;

            try
            {
                b = int.Parse(raiz);
            }
            catch (Exception e)
            {
                throw new Exception("Raiz: " + e.Message);
            }

            return a.Primitivas(b);
        }
Beispiel #3
0
        public static Complejo operator -(Complejo izq, Complejo der)
        {
            bool polar = false;

            if (izq.forma == Forma.Polar && der.forma == Forma.Polar)
                polar = true;

            izq = izq.Convertir(Forma.Binomica);
            der = der.Convertir(Forma.Binomica);

            var resta = new Complejo(izq.a - der.a, izq.b - der.b, Forma.Binomica);

            if (polar == true)
                return resta.Convertir(Forma.Polar);

            return resta;
        }
Beispiel #4
0
        public List<Complejo> Raiz(int n)
        {
            var raices = new List<Complejo>();

            bool binomica = false;

            if (this.forma == Forma.Binomica)
                binomica = true;

            var aux = this.Convertir(Forma.Polar);

            int i;
            for (i = 0; i < n; i++)
            {
                var raiz = new Complejo(Math.Pow(aux.a, (double)1 / n), (aux.b + 2 * i * Math.PI) / n, Forma.Polar);
                if (binomica == true)
                    raiz = raiz.Convertir(Forma.Binomica);
                raices.Add(raiz);
            }

            return raices;
        }
Beispiel #5
0
        // devuelve una lista con "n" elementos que tiene el valor de la raiz primitiva
        // en caso de que w(n) sea raiz primitiva y valor "null" para el caso contrario
        public List<Complejo> Primitivas(int n)
        {
            var raices = new List<Complejo>();

            var primitivas = new List<Complejo>();

            Complejo unidad = new Complejo(1, 0, Forma.Binomica);

            if (!this.Equals(unidad))
            {
                throw new Exception(
                    "No se pueden calcular las raices primitivas" +
                    " a un complejo que no sea la unidad " + unidad.ToString());
            }

            raices = this.Raiz(n);

            // w(0) nunca es raiz primitiva
            primitivas.Add(null);
            // w(1) siempre es raiz primitiva
            primitivas.Add(raices[1]);

            // empieza la iteracion desde w(2)
            for (int i = 2; i < raices.Count; i++)
            {
                Complejo raiz = null;

                if ( MCD(i,n) == 1 )
                    raiz = raices[i];

                primitivas.Add(raiz);
            }

            return primitivas;
        }
Beispiel #6
0
        public Complejo Potencia(int n)
        {
            bool binomica = false;

            if (this.forma == Forma.Binomica)
                binomica = true;

            var aux = this.Convertir(Forma.Polar);

            var potencia = new Complejo(Math.Pow(aux.a, n), n * aux.b, Forma.Polar);

            if ( binomica == true )
                return potencia.Convertir(Forma.Binomica);

            return potencia;
        }