Προς το περιεχόμενο
  • 0
tasos41997

Εργασια Προγραμματισμου

Ερώτηση

Καλησπερα, εχω μια εργασια για την σχολη και θα ηθελα μια βοηθεια.

Εύρεση ριζών μιγαδικού αριθμού ειναι το θεμα

Χρησιμοποιώντας την γλώσσα C, δημιουργήστε πρόγραμμα το οποίο θα δέχεται ως είσοδο μιγαδικό αριθμό z της μορφής a+bi και φυσικό αριθμό n, και θα επιστρέφει τις n-στές ρίζες του z, επίσης στη μορφή a+bi.

Καμια γνωμη; πως αρχιζω απο που πιανω το θεμα;

Κοινοποιήστε αυτήν την ανάρτηση


Σύνδεσμος στην ανάρτηση
Κοινοποίηση σε άλλες σελίδες

11 απαντήσεις σε αυτή την ερώτηση

Προτεινόμενες αναρτήσεις

  • 0
Δημοσ. (επεξεργασμένο)
3 ώρες πριν, Lanike71 είπε

Από τα μαθηματικά πρώτα, αν ξέρεις να το λύσεις.

Ξέρεις;

Οχι, γνωριζεις στο περιπου τι εννοει; Το ερωτημα μου ειναι τι θα χρειαστω πχ δεικτες συναρτησεις δομες ή απλες δομες επαναληψεις.

Το να μου εγραφε καποιος εστω και ψευδοκωδικα πχ (αν και θα βολευε C) να καταλαβω

Επεξ/σία από tasos41997

Κοινοποιήστε αυτήν την ανάρτηση


Σύνδεσμος στην ανάρτηση
Κοινοποίηση σε άλλες σελίδες
  • 0

Το πρόβλημα αποτελείται από 2 μέρη, το μαθηματικό και του κώδικα.

Το μαθηματικό, έστω και στο χαρτί, μπορείς να το λύσεις; Αν όχι, πώς θα πας παρακάτω;

Κοινοποιήστε αυτήν την ανάρτηση


Σύνδεσμος στην ανάρτηση
Κοινοποίηση σε άλλες σελίδες
  • 0
5 ώρες πριν, Lanike71 είπε

Το πρόβλημα αποτελείται από 2 μέρη, το μαθηματικό και του κώδικα.

Το μαθηματικό, έστω και στο χαρτί, μπορείς να το λύσεις; Αν όχι, πώς θα πας παρακάτω;

Μπορεις να μου εξηγησεις το μαθηματικο μερος;

Κοινοποιήστε αυτήν την ανάρτηση


Σύνδεσμος στην ανάρτηση
Κοινοποίηση σε άλλες σελίδες
  • 0
2 ώρες πριν, tasos41997 είπε

Μπορεις να μου εξηγησεις το μαθηματικο μερος;

Ρίξε μία ματιά στο yt, έχει άπειρα βίντεο που τα λένε καλά:

 

Κοινοποιήστε αυτήν την ανάρτηση


Σύνδεσμος στην ανάρτηση
Κοινοποίηση σε άλλες σελίδες
  • 0
4 ώρες πριν, Lanike71 είπε

Ρίξε μία ματιά στο yt, έχει άπειρα βίντεο που τα λένε καλά:

Το εχω δει το βιντεακι, ειναι απο τα βασικα για τους μιγαδικους. Γνωριζεις μηπως να μου πεις τι θα χρειαστω απο γνωσεις προγραμματισμου για να το λυσω;

Κοινοποιήστε αυτήν την ανάρτηση


Σύνδεσμος στην ανάρτηση
Κοινοποίηση σε άλλες σελίδες
  • 0
23 ώρες πριν, tasos41997 είπε

Χρησιμοποιώντας την γλώσσα C

giphy.gif?cid=4d1e4f292519506697887f301e

2 ώρες πριν, tasos41997 είπε

Γνωριζεις μηπως να μου πεις τι θα χρειαστω απο γνωσεις προγραμματισμου για να το λυσω;

 

Κοινοποιήστε αυτήν την ανάρτηση


Σύνδεσμος στην ανάρτηση
Κοινοποίηση σε άλλες σελίδες
  • 0

Χμμ μήπως στον υπολογισμο σε βολεύει το:

https://calculating-it.com/math-calculators/roots/

Ακόμα ίσως και να όριζες τον μιγαδικό σε πολική μορφή να βόλευε:
https://www.engineeringmathgeek.com/roots-of-a-complex-number-how-to-find-out/

H ακόμα και το:
https://www.onlinemathlearning.com/complex-numbers-roots.html

Όπως είπαν δοκίμασε πρώτα pencil & paper και μετά σε κώδικα.

Κοινοποιήστε αυτήν την ανάρτηση


Σύνδεσμος στην ανάρτηση
Κοινοποίηση σε άλλες σελίδες
  • 0
Δημοσ. (επεξεργασμένο)

Καλημέρα !

Η εύρεση της ν-οστής ρίζας μιγαδικού απ' όσο θυμάμαι έχει δύο σκέλη. Συνήθως τον μιγαδικό μας τον δίνουνε στη μορφή z=α+βi. Οπότε το πρώτο στάδιο είναι να τον μετατρέψουμε σε πολική (τριγωνομετρική) μορφή με τους εξής τύπους :

ρ=τετραγ.ριζα(α*α+β*β)

Αυτό λέγεται μέτρο του μιγαδικού. Μετά υπολογίζουμε τη γωνία θ ως εξής :

συνθ=α/ρ και ημθ=β/ρ.

Οπότε ο αρχικός μιγαδικός z=α+βi γράφεται ως εξής :

z=ρ(συνθ+iημθ)

Αφού το ξεπεράσαμε αυτό το στάδιο, στόχος είναι να υψώσουμε τον z στη δύναμη 1/n. Αυτό σημαίνει ουσιαστικά n-οστή ρίζα. Έτσι ακριβώς γίνεται και με τους πραγματικούς. Η εύρεση π.χ. της κυβικής ρίζας του οκτώ ισούται με "οκτώ εις την 1/3".
Για να το κάνεις αυτό υπάρχει ένας μαθηματικός τύπος που ονομάζεται "τύπος του De Moivre". Ορίζει έναν απλό τρόπο για να υψώνουμε οποιονδήποτε μιγαδικό (πολικής μορφής) σε οποιαδήποτε δύναμη.
Σ'  ένα παλιό βιβλίο για τη C++ από τα χρόνια στο πανεπιστήμιο έτυχε να βρω ένα σύνολο από ρουτίνες για να κάνεις ό,τι θέλεις με μιγαδικούς. Βλέπω ότι έχει μέσα και ύψωση μιγαδικού σε δύναμη και μετατροπές από και προς την πολική μορφή.  Δεν θελω να κάνω τον έξυπνο, τον κώδικα αυτό φυσικά και δεν τον έγραψα μόνος μου, απλά δοκίμασα τις περισσότερες ρουτίνες και δουλεύουνε. Άρα τον αντιγράφω εδώ γιατί πιστεύω ότι θα βοηθήσει.

#include<iostream>
#include<cmath>
#include<cstdlib>
#include<iomanip>
	#define Pi 3.141592653589793
#define Eu 2.718281828459045
	typedef long double ld;
typedef long long int l;
using namespace std;
	int signum(ld x)
{
    return (0<x)-(x<0);
}
	ld degtorad(ld deg)
{
    cout.setf(ios::fixed);
    cout.precision(8);
    ld cnst=Pi/180.0;
    return deg*cnst;
}
	ld radtodeg(ld rad)
{
    cout.setf(ios::fixed);
    cout.precision(8);
    ld cnst=180.0/Pi;
    return rad*cnst;
}
	class Complex
{
private:
    ld real;
    ld imag;
public:
	    Complex(ld re=0,ld im=0):real(re),imag(im){}    ///Complex Constructor -- Assigns Real and Imaginary values...
    ///Complex(Complex& a){}                    ///Complex Copy Constructor -- @CurrentlyUnderConstruction...
    void Get()                                  ///Gets the Real and Imaginary Parts of the Complex Number
    {
        cout<<"Enter Real Value = ";cin>>real;
        cout<<"Enter Imaginary Value = ";cin>>imag;
        cout<<endl;
    }
    void Print()                                ///Prints the Complex Number
    {
        if(imag>0)
        {
            cout<<"The Number is = "<<real<<" + "<<imag<<" i "<<endl;
        }
        else if(imag==0)
        {
            cout<<"The Number is = "<<real<<endl;
        }
        else if(imag<0)
        {
            cout<<"The Number is = "<<real<<" - "<<abs(imag)<<" i "<<endl;
        }
        else
        {
            cout<<"The Number is = "<<imag<<" i "<<endl;
        }
    }
    void Re(ld re)                              ///Sets the Real Part to 're'
        {
                real=re;
    }
        void Im(ld im)                              ///Sets the Imaginary Part to 'im'
        {
                imag=im;
    }
        ld Re()                                     ///Returns the Real Part of the Complex Number
    {
        return real;
    }
    ld Im()                                     ///Returns the Imaginary Part of the Complex Number
    {
        return imag;
    }
    ld Modulus()                                ///Returns |z| for Complex z
    {
        ld term=pow(real,2)+pow(imag,2);
        return sqrt(term);
    }
    ld Normal()                                 ///Returns |z|^2 for Complex z
    {
        ld term=pow(real,2)+pow(imag,2);
        return term;
    }
    Complex Conjugate()                         ///Returns Conj(z) of Complex z
    {
        Complex res;
        res.real=real;
        res.imag=-imag;
        return res;
    }
    ld Argument()                               ///Returns The Slope's Angle of Complex in Argand Plane
    {
        ld term;
        term=atan2(imag,real);
        return radtodeg(term);
    }
    void Inverse()                              ///Returns Inverse of the Complex Number
    {
        imag=-imag;
        ld a=Normal();
        real/=a;
        imag/=a;
    }
    void GetPolar()                             ///Gets the Complex z in Polar Form
    {
        ld arg,mod;
        cout<<"Enter the Argument - ";cin>>arg;
        cout<<"Enter the Modulus - ";cin>>mod;
        cout<<endl;
        ld newarg=degtorad(arg);
        real=mod*cos(newarg);
        imag=mod*sin(newarg);
    }
    void Polar1Print()                          ///Prints Polar form of z - r(cos(x)+isin(x))
    {
        cout<<"The Polar Form is = ";
        cout<<Modulus()<<"( cos("<<Argument()<<")+sin("<<Argument()<<") )"<<endl;
    }
    void Polar2Print()                          ///Prints Polar form of z - re^ix
    {
        Complex term,t1(0,1),t2;
        term.real=t1.real*degtorad(Argument());
        term.imag=t1.imag*degtorad(Argument());
        t2.RaiseToComplex(Eu,term);
        cout<<"The Polar Form is = ";
        cout<<Modulus()<<"( e ^ "<<degtorad(Argument())<<"i )"<<endl;
        cout<<"                             OR "<<endl;
        cout<<"The Polar Form is = ";
        cout<<Modulus()<<"( "<<Eu<<" ^ "<<degtorad(Argument())<<"i )"<<endl;
        cout<<"                             OR "<<endl;
        cout<<"The Polar Form is = ";
        if(imag>0)
            cout<<Modulus()<<"( "<<t2.real<<" + "<<t2.imag<<" i )"<<endl;
        else if(imag<0)
            cout<<Modulus()<<"( "<<t2.real<<" - "<<abs(t2.imag)<<" i )"<<endl;
    }
    Complex Polar(ld mod,ld arg)                ///Converts Polar Form of the Complex Number to Original Form
    {
        Complex res;
        ld newarg=degtorad(arg);
        res.real=mod*cos(newarg);
        res.imag=mod*sin(newarg);
        return res;
    }
    void Root(Complex& x1, Complex& x2)         ///Returns Square Roots of Complex z in x1 and x2
    {
        ld a=Modulus();
        x1.real=sqrt((a+real)/2);
        x1.imag=signum(imag)*sqrt((-real+a)/2);
        x2.real=-(sqrt((a+real)/2));
        x2.imag=-(signum(imag)*sqrt((-real+a)/2));
    }
    Complex* Root(int m)                       ///Returns nth Roots of Complex z in Complex array
        {
                int n=abs(m);
                Complex *z=new Complex[n];
                ld rn=pow(Modulus(),1.0/n);
                ld narg=(degtorad(Argument()))/n;
                ld npi=(2.0*Pi)/n;
                for(int i=0;i<n;i++)
                {
                        z[i]=Complex(0,0);                        
                }
                for(int k=0;k<n;k++)
                {
                        if(n>0)
                                z[k]=Complex(rn*cos(narg+k*npi),rn*sin(narg+k*npi));
                        else
                            z[k]=Complex(rn*cos(narg+(-k)*npi),rn*sin(narg+(-k)*npi));
                }
                return z;   
        }
        void Rotate(ld angle)                       ///Rotates the Complex Number by 'angle' Degrees
    {
        ld a=Modulus(),b=Argument();
        b+=angle;
        ld bx=degtorad(b);
        real=a*cos(bx);
        imag=a*sin(bx);
    }
    void RaiseToComplex(ld a,Complex& z)        ///Returns a raised to Complex z
    {
        cout.precision(8);
        cout.setf(ios::fixed);
        ld t1,t2,t3;
        t1=pow(a,z.real);
        t2=cos(z.imag*log(a));
        t3=sin(z.imag*log(a));
        real=t1*t2;
        imag=t1*t3;
    }
    Complex Cos()                               ///Returns Cosine of Complex z
    {
        Complex res,t1(0,1),t2(0,-1),t3,t4,t5,t6,t7;
        t3.real=(real*t1.real)-(imag*t1.imag);
        t3.imag=(real*t1.imag)+(imag*t1.real);
        t4.real=(real*t2.real)-(imag*t2.imag);
        t4.imag=(real*t2.imag)+(imag*t2.real);
        t5.RaiseToComplex(2.718281828459045,t3);
        t6.RaiseToComplex(2.718281828459045,t4);
        t7=t5+t6;
        res.real=t7.real/2;
        res.imag=t7.imag/2;
        return res;
    }
    Complex Cosh()                              ///Returns Hyperbolic Cosine of Complex z
    {
        Complex res,t1(real,imag),t2(-real,-imag),t3,t4,t5;
        t3.RaiseToComplex(2.718281828459045,t1);
        t4.RaiseToComplex(2.718281828459045,t2);
        t5=t4+t3;
        res.real=t5.real/2;
        res.imag=t5.imag/2;
        return res;
    }
    Complex Sin()                               ///Returns Sine of Complex z
    {
        Complex res,t(0,1),t1(0,1),t2(0,-1),t3,t4,t5,t6,t7,t8;
        t3.real=(real*t1.real)-(imag*t1.imag);
        t3.imag=(real*t1.imag)+(imag*t1.real);
        t4.real=(real*t2.real)-(imag*t2.imag);
        t4.imag=(real*t2.imag)+(imag*t2.real);
        t5.RaiseToComplex(2.718281828459045,t3);
        t6.RaiseToComplex(2.718281828459045,t4);
        t7=t6-t5;
        t8=t7*t;
        res.real=t8.real/2;
        res.imag=t8.imag/2;
        return res;
    }
    Complex Sinh()                              ///Returns Hyperbolic Sine of Complex z
    {
        Complex res,t1(real,imag),t2(-real,-imag),t3,t4,t5;
        t3.RaiseToComplex(2.718281828459045,t1);
        t4.RaiseToComplex(2.718281828459045,t2);
        t5=t3-t4;
        res.real=t5.real/2;
        res.imag=t5.imag/2;
        return res;
    }
    Complex Tan()                               ///Returns Tangent of Complex z
    {
        Complex res,t1,t2;
        t1=Sin();
        t2=Cos();
        res=t1/t2;
        return res;
    }
    Complex Tanh()                              ///Returns Hyperbolic Tangent of Complex z
    {
        Complex res,t1,t2;
        t1=Sinh();
        t2=Cosh();
        res=t1/t2;
        return res;
    }
    Complex Exp()
        {
                Complex res;
                res.RaiseToComplex(Eu,*this);    
                return res;
    }
        Complex Log(ld base)                       ///Returns Log of the Complex No. to the base
    {
        Complex res;
        res.real=log(Modulus())/((log(base)));
        res.imag=degtorad(Argument())/((log(base)));
        return res;
    }
        bool operator==(const Complex& rhs)       ///Checks if the Complex Numbers are Equal
        {
                return(real==rhs.real&&imag==rhs.imag);
    }
        bool operator!=(const Complex& rhs)       //Checks if the Complex Numbers are Unequal
        {
                return(real!=rhs.real&&imag!=rhs.imag);
    }
      Complex operator~()                        ///Returns Conjugate of the Complex Number
        {
                *this=Conjugate();
                return *this;
    }
        Complex operator+(Complex rhs)             ///Adds Two Complex Numbers
    {
        Complex res;
        res.real=real+rhs.real;
        res.imag=imag+rhs.imag;
        return res;
    }
    Complex operator+(ld rhs)                  ///Adds Constant to Complex Number
    {
        Complex res;
        res.real=real+rhs;
        res.imag=imag;
        return res;
    }
        Complex operator-(Complex rhs)             ///Subtracts Two Complex Numbers
    {
        Complex res;
        res.real=real-rhs.real;
        res.imag=imag-rhs.imag;
        return res;
    }
    Complex operator-(ld rhs)                  ///Subtracts Constant from Complex Number
    {
        Complex res;
        res.real=real-rhs;
        res.imag=imag;
        return res;
    }
    Complex operator*(Complex rhs)             ///Multiplies Two Complex Numbers
    {
        Complex res;
        res.real=(real*rhs.real)-(imag*rhs.imag);
        res.imag=(real*rhs.imag)+(imag*rhs.real);
        return res;
    }
    Complex operator*(ld rhs)                   ///Multiplies Complex z by a Constant
    {
        Complex res;
        res.real=real*rhs;
        res.imag=imag*rhs;
        return res;
    }
    Complex operator/(Complex rhs)               ///Divides Two Complex Numbers
    {
        rhs.Inverse();
        Complex res;
        res.real=(real*rhs.real)-(imag*rhs.imag);
        res.imag=(real*rhs.imag)+(imag*rhs.real);
        return res;
    }
    Complex operator/(ld rhs)                   ///Divides Complex z by a Constant
    {
        Complex res;
        res.real=real/rhs;
        res.imag=imag/rhs;
        return res;
    }
    void operator+=(Complex rhs)               ///Adds z2 to z1
    {
        real+=rhs.real;
        imag+=rhs.imag;
    }
    void operator-=(Complex rhs)               ///Subtracts z2 from z1
    {
        real-=rhs.real;
        imag-=rhs.imag;
    }
    void operator*=(Complex rhs)               ///Multiplies z2 and z1 and returns to z1
    {
        real=(real*rhs.real)-(imag*rhs.imag);
        imag=(real*rhs.imag)+(imag*rhs.real);
    }
    void operator/=(Complex rhs)               ///Divides z2 and z1 and returns to z1
    {
        rhs.Inverse();
        real=(real*rhs.real)-(imag*rhs.imag);
        imag=(real*rhs.imag)+(imag*rhs.real);
    }
    void operator+=(ld rhs)                     ///Adds Constant to z1
    {
        real+=rhs;
        imag=imag;
    }
    void operator-=(ld rhs)                     ///Subtracts Constant from z1
    {
        real-=rhs;
        imag=imag;
    }
    void operator*=(ld rhs)                     ///Multiplies z1 with a Constant and returns to z1
    {
        real*=rhs;
        imag*=rhs;
    }
    void operator/=(ld rhs)                     ///Divides z1 with a Constant and returns to z1
	    {
	        real/=rhs;
          imag/=rhs;
    }
        Complex operator^(ld power)                 ///Returns Complex z Raised to 'power'
    {
        ld a,b;
        a=Modulus();
        b=pow(a,power);
        ld c,d;
        d=Argument();
        c=degtorad(d);
        Complex res;
        res.real=b*cos(power*c);
        res.imag=b*sin(power*c);
        return res;
    }
    Complex operator^(Complex b)               ///Returns Complex z1 raised to Complex z2
    {
        Complex res,t1(0,1),t2(b.real/2,b.imag/2),t3,t4,t5,t6;
        ld a1,a2;
        a1=Normal();a2=degtorad(Argument());
        t3.RaiseToComplex(a1,t2);
        t4=t1*b;
        t5.real=t4.real*a2;
        t5.imag=t4.imag*a2;
        t6.RaiseToComplex(Eu,t5);
        res=t6*t3;
        return res;
    }
    ~Complex(){}                        ///Complex Destructor -- Does Nothing till now...
    ///Non - Member friend Overloads...
        friend Complex operator+(ld rhs,Complex c)
        {
                return(Complex(c.real+rhs,c.imag));
    }
        friend Complex operator-(ld rhs,Complex c)
    {
                return(Complex(c.real-rhs,c.imag));        
    }
        friend Complex operator*(ld rhs,Complex c)
    {
                return(Complex(c.real*rhs,c.imag*rhs));        
    }
        friend Complex operator/(ld rhs,Complex c)
    {
                return(Complex(c.real/rhs,c.imag/rhs));        
    }
        friend Complex operator^(ld rhs,Complex c)
        {
                Complex res;
                ld t1,t2,t3;
        t1=pow(rhs,c.real);
        t2=cos(c.imag*log(rhs));
        t3=sin(c.imag*log(rhs));
        res.real=t1*t2;
        res.imag=t1*t3;
    return res;
    }
};
	

Να είστε όλοι καλά,

Ο Άσπρος Γάτος

Επεξ/σία από White_Cat
  • Like 1
  • Sad 1

Κοινοποιήστε αυτήν την ανάρτηση


Σύνδεσμος στην ανάρτηση
Κοινοποίηση σε άλλες σελίδες
  • 0
7 ώρες πριν, Ψιτ είπε

Μα γιατί έδωσες τη λύση; Πως θα μάθει;;;

Δηλαδή με τη λύση αυτή, ο καθηγητής δε θα καταλάβει ότι δεν είναι δικιά του;

Κοινοποιήστε αυτήν την ανάρτηση


Σύνδεσμος στην ανάρτηση
Κοινοποίηση σε άλλες σελίδες
Επισκέπτης
Αυτό το θέμα είναι πλέον κλειστό για περαιτέρω απαντήσεις.
×
×
  • Δημιουργία νέου...

Χρήσιμες πληροφορίες

Με την περιήγησή σας στο insomnia.gr, αποδέχεστε τη χρήση cookies που ενισχύουν σημαντικά την εμπειρία χρήσης.