Example #1
0
            public void Pomnoz(Zespolona z)
            {
                double old_x = z.x, old_y = z.y, old_X = x, old_Y = y;

                x = x * z.x - y * z.y;
                y = old_X * old_y + old_x * old_Y;
            }
Example #2
0
            public static Zespolona Pomnoz(Zespolona z, Zespolona w)
            {
                double x = w.x * z.x - w.y * z.y;
                double y = z.x * w.y + z.y * w.x;

                return(new Zespolona(x, y));
            }
Example #3
0
            public void Podziel(Zespolona z)
            {
                double old_x = z.x, old_y = z.y, old_X = x, old_Y = y;
                double dzielnik = (z.y * z.y + z.x * z.x);

                x = (x * z.x + y * z.y) / dzielnik;
                y = (old_Y * old_x - old_X * old_y) / dzielnik;
            }
Example #4
0
    public static ZespolonyWektor Skalar(ZespolonyWektor c1, int skalar) //skalar
    {
        Zespolona[] skal = new Zespolona[c1.ComplexVector.Length];
        for (int i = 0; i < c1.ComplexVector.Length; i++)
        {
            skal[i] = c1.ComplexVector[i] * skalar;
        }

        return(new ZespolonyWektor(skal));
    }
Example #5
0
    public static ZespolonyWektor operator -(ZespolonyWektor c1, ZespolonyWektor c2) //odejmowanie
    {
        Zespolona[] odd = new Zespolona[c1.ComplexVector.Length];
        for (int i = 0; i < c1.ComplexVector.Length; i++)
        {
            odd[i] = c1.ComplexVector[i] - c2.ComplexVector[i];
        }

        return(new ZespolonyWektor(odd));
    }
Example #6
0
    public static ZespolonyWektor operator +(ZespolonyWektor c1, ZespolonyWektor c2) //dodawanie
    {
        Zespolona[] add = new Zespolona[c1.ComplexVector.Length];
        for (int i = 0; i < c1.ComplexVector.Length; i++)
        {
            // add[i] = new Complex(W.vector[i].R + V.vector[i].R, W.vector[i].I + V.vector[i].I);
            add[i] = c1.ComplexVector[i] + c2.ComplexVector[i];
        }

        return(new ZespolonyWektor(add));
    }
Example #7
0
    public static Zespolona IloczynSkalarny(ZespolonyWektor c1, ZespolonyWektor c2)  //iloczyn
    {
        Zespolona temp = new Zespolona(0);

        for (int i = 0; i < c1.ComplexVector.Length; i++)
        {
            temp += c1.ComplexVector[i] * c2.ComplexVector[i];
        }

        return(temp);
    }
Example #8
0
        static void Main(string[] args)
        {
            Zespolona z1 = new Zespolona(3, 4);
            Zespolona z2 = new Zespolona(3, -4);

            z1.Wyświetl();
            z2.Wyświetl();
            Zespolona z3 = Zespolona.Mnożenie(z1, z2);

            z3.Wyświetl();
            Zespolona z4 = Zespolona.dodaj(z1, z2);

            z4.Wyświetl();
            Console.ReadKey();
        }
Example #9
0
        static void Main(string[] args)
        {
            Zespolona z1 = new Zespolona(7, 5);
            Zespolona z2 = new Zespolona(2, 1);
            Zespolona z  = z1.Dodaj(z2);

            z.Wyswietl();
            z = Zespolona.Dodaj(z1, z2);
            z.Wyswietl();
            z = Zespolona.Dodaj(z2, z1);
            z.Wyswietl();
            z = Zespolona.Pomnoz(z1, z2);
            z.Wyswietl();
            Console.WriteLine(z.Re);
            z.Sprzezona().Wyswietl();
        }
Example #10
0
        public void TestujZespolone()
        {
            var z1         = new Zespolona(1, 2);
            var z2         = new Zespolona(3, 4);
            var Oczekiwana = new Zespolona(4, 6);

            var z3 = Zespolona.DodajZesp(z1, z2);

            Console.WriteLine(z3.Rzeczywista + z3.Urojona);
            Assert.AreEqual(4, z3.Rzeczywista);
            Assert.AreEqual(6, z3.Urojona);


            var z4 = new Zespolona(1, 2);
            var z6 = new Zespolona(3, 4);
            var z5 = Zespolona.MnozenieZesp(z4, z6);

            Assert.AreEqual(-5, z5.Rzeczywista);
            Assert.AreEqual(10, z5.Urojona);
        }
Example #11
0
        private void Button_Click(object sender, RoutedEventArgs e)
        {
            Zespolona z1 = new Zespolona(Double.Parse(tekst1.Text), Double.Parse(tekst2.Text));

            wynikLabel.Content = z1.Modul().ToString();
        }
Example #12
0
 public static Zespolona dodaj(Zespolona z1, Zespolona z2)
 {
     return(new Zespolona(z1.Re + z2.Re, z1.Im + z2.Im));
 }
Example #13
0
 public static Zespolona Mnożenie(Zespolona z1, Zespolona z2)
 {
     return(new Zespolona(z1.Re * z2.Re - z1.Im * z2.Im, z1.Im * z2.Re + z1.Re * z2.Im));
 }
    static void Main(string[] args)
    {
        Zespolona z = new Zespolona(1.3, 2.4);

        Console.WriteLine(z);
        Zespolona s = new Zespolona(1.0, 1.0);

        Console.WriteLine(s);
        Zespolona r = z + s;

        Console.WriteLine(r);
        r = z + 5.5;
        Console.WriteLine(r);
        r = 5.5 + z;
        Console.WriteLine(r);
        Console.WriteLine(z + 10);
        z += s; // od razu przeciążony +=
        Console.WriteLine(z);

        r = new Zespolona(1, 1);
        Console.WriteLine(s == z);
        Console.WriteLine(s != z);
        Console.WriteLine(s == r);
        Console.WriteLine(s.Equals(z));
        Console.WriteLine(s.Equals(r));
        Console.WriteLine("HashCode");
        Console.WriteLine(s.GetHashCode());
        Console.WriteLine(r.GetHashCode());
        Console.WriteLine(z.GetHashCode());
        Console.WriteLine("-------");

        Console.WriteLine(s == 1.0);
        Console.WriteLine(s == 1.5);

        if (z)
        {
            Console.WriteLine("różne od 0");
        }
        else
        {
            Console.WriteLine("0");
        }
        Zespolona z0 = new Zespolona(0, 0);

        if (z0)
        {
            Console.WriteLine("różne od 0");
        }
        else
        {
            Console.WriteLine("0");
        }

        Console.WriteLine(z == 9);
        Console.WriteLine(z != 9);

        Console.WriteLine(~z);
        Console.WriteLine(-z);
        Console.WriteLine(!s);

        Console.ReadKey();
    }
Example #15
0
 public void Odejmij(Zespolona z)
 {
     x = x - z.x;
     y = y - z.y;
 }
Example #16
0
 public static Zespolona Dodaj(Zespolona z, Zespolona w)
 {
     return(new Zespolona(
                w.x + z.x,
                w.y + z.y));
 }
Example #17
0
 /*public void Dodaj(Zespolona z)
  * {
  *  x = x + z.x;
  *  y = y + z.y;
  * }*/
 public Zespolona Dodaj(Zespolona z)
 {
     return(new Zespolona(
                x + z.x,
                y + z.y));
 }
Example #18
0
 public Zespolona(Zespolona z)
     : this(z.Re, z.Im)
 {
 }