logo elektroda
logo elektroda
X
logo elektroda
REKLAMA
REKLAMA
Adblock/uBlockOrigin/AdGuard mogą powodować znikanie niektórych postów z powodu nowej reguły.

Wyznaczenie moduł i argument liczby zespolonej

botr 15 Sty 2005 14:15 8408 2
REKLAMA
  • #1 1140472
    botr
    Poziom 17  
    Witam
    Potrzebuje przykładowego algorytmu do wyznaczania modułu i argumentu liczby zespolonej .Moze to być za pomoca symulacyji w środowisku Matlab a najlepiej jak by było to w symulatorze procesora
    sygnałowego ADSP 21xx lub starter kitu ADSP-2181.
    Pozdrawiam

    albo chociasz słowami opisac :)
  • REKLAMA
  • #2 1141960
    shg
    Poziom 35  
    A tam od razu algorytm...
    liczba zespolona w postaci: z=a+bj, j - jednostka urojona (j, bo to jest forum elektroniczne, dla matematyków to będzie i) = sqrt(-1)

    Moduł:
    |z| = sqrt(a^2+b^2)
    argument:
    arg(z) = atan2(a, b)
    definicję funkcji atan2 masz tu:
    https://www.elektroda.pl/rtvforum/topic229995.html

    a algorytm obliczania pierwiastka (do modułu) jest w dziale "programowanie ogólne"

    Algorytm liczenia atan() - miałem, ale zgubiłem :D, a poważnie, to przykład przybliżonego (dość dokładnego) liczenia funkcji trygonometrycznych masz tu:
    http://www.ganssle.com/approx/sincos.cpp
    pierwiastek i atan tu:
    http://www.lightsoft.co.uk/PD/stu/StuChat36.html
    obie powyższe są tylko przybliżone. Dokładnego i możliwego do zaimplementowania w procku algorytmu na atan() jakoś nie mogę znaleźć, pozostaje ewentualnie rozwinięcie w szereg Taylora, czyli:
    $$\frac{x^1}{1}-\frac{x^3}{3}+\frac{x^5}{5}-\frac{x^7}{7}+\frac{x^9}{9}\ldots$$
  • #3 1143545
    botr
    Poziom 17  
    Mam takie cos ..to ty na to da sie takie cos zastosować ????


    .MODULE Square_root;

    {
    Square Root
    y = sqrt(x)

    Calling Parameters
    MR1 = MSW of x
    MR0 = LSW of x
    M3 = 1
    L3 = 0

    Return Values
    SR1 = y in 8.8 UNSIGNED format

    Altered Registers
    AX0,AY0,AY1,AR,MY0,MY1,MX0,MF,MR,SE,SR,I3

    Computation Time
    75 cycles (maximum)
    }

    .CONST base=H#0D49, sqrt2=H#5A82;

    .VAR/DM sqrt_coeff[5];

    .INIT sqrt_coeff : H#5D1D, H#A9ED, H#46D6, H#DDAA, H#072D;

    .ENTRY sqrt;

    sqrt: I3=^sqrt_coeff; {Pointer to coeff. buffer}
    SE=EXP MR1 (HI); {Check for redundant bits}
    SE=EXP MR0 (LO);
    AX0=SE, SR=NORM MR1 (HI); {Remove redundant bits}
    SR=SR OR NORM MR0 (LO);
    MY0=SR1, AR=PASS SR1;
    IF EQ RTS;
    MR=0;
    MR1=base; {Load constant value}
    MF=AR*MY0 (RND), MX0=DM(I3,M3); {MF = x**2}
    MR=MR+MX0*MY0 (SS), MX0=DM(I3,M3); {MR = base + C1*x}
    CNTR=4;
    DO approx UNTIL CE;
    MR=MR+MX0*MF (SS), MX0=DM(I3,M3);
    approx: MF=AR*MF (RND);
    AY0=15;
    MY0=MR1, AR=AX0+AY0; {SE + 15 = 0?}
    IF NE JUMP scale; {No, compute sqrt(s)}
    SR=ASHIFT MR1 BY -6 (HI);
    RTS;
    scale: MR=0;
    MR1=sqrt2; {Load 1/sqrt(2)}
    MY1=MR1, AR=ABS AR;
    AY0=AR;
    AR=AY0-1;
    IF EQ JUMP pwr_ok;
    CNTR=AR; {Compute (1/sqrt(2))^(SE+15)}
    DO compute UNTIL CE;
    compute: MR=MR1*MY1 (RND);
    pwr_ok: IF NEG JUMP frac;
    AY1=H#0080; {Load a 1 in 9.23 format}
    AY0=0; {Compute reciprocal of MR}
    DIVS AY1, MR1;
    DIVQ MR1; DIVQ MR1; DIVQ MR1;
    DIVQ MR1; DIVQ MR1; DIVQ MR1;
    DIVQ MR1; DIVQ MR1; DIVQ MR1;
    DIVQ MR1; DIVQ MR1; DIVQ MR1;
    DIVQ MR1; DIVQ MR1; DIVQ MR1;
    MX0=AY0;
    MR=0;
    MR0=H#2000;
    MR=MR+MX0*MY0 (US);
    SR=ASHIFT MR1 BY 2 (HI);
    SR=SR OR LSHIFT MR0 BY 2 (LO);
    RTS;
    frac: MR=MR1*MY0 (RND);
    SR=ASHIFT MR1 BY -6 (HI);
    RTS;
    .ENDMOD;

    ********************************************************************************************************************************

    .MODULE Arctan_Approximation;

    {
    Arctangent Approximation
    y = Arctan(x)

    Calling Parameters
    MR1 = Integer part of x
    MR0 = Fractional part of x
    M3 = 1
    L3 = 0

    Return Values
    AR = Arctan(x) in 1.15 scaled format
    (-0.5 for -90 degrees, 0.5 for 90 degrees)

    Altered Registers
    AX0,AX1,AY0,AY1,AR,AF,MY0,MY1,MX1,MF,MR,SR,SI

    Computation Time
    58 cycles (maximum)
    }

    .VAR/DM/RAM atn_coeff[5];

    .INIT atn_coeff : H#28BD, H#006D, H#EF3E, H#08C6, H#FED4;

    .ENTRY arctan;

    arctan: I3 = ^atn_coeff; {Point to coefficients}
    AY0=0;
    AX1=MR1;
    AR=PASS MR1;
    IF GE JUMP posi; {Check for positive input}
    AR=-MR0; {Make negative number positive}
    MR0=AR;
    AR=AY0-MR1+C-1;
    MR1=AR;
    posi: SR=LSHIFT MR0 BY -1 (LO); {Produce 1.15 value in SR0}
    AR=SR0;
    AY1=MR1;
    AF=PASS MR1;
    IF EQ JUMP noinv; {If input < 1, no need to invert}
    SE=EXP MR1 (HI); {Invert input}
    SR=NORM MR1 (HI);
    SR=SR OR NORM MR0 (LO);
    AX0=SR1;
    SI=H#0001;
    SR=NORM SI (HI);
    AY1=SR1;
    AY0=SR0;
    DIVS AY1,AX0;
    DIVQ AX0; DIVQ AX0; DIVQ AX0;
    DIVQ AX0; DIVQ AX0; DIVQ AX0;
    DIVQ AX0; DIVQ AX0; DIVQ AX0;
    DIVQ AX0; DIVQ AX0; DIVQ AX0;
    DIVQ AX0; DIVQ AX0; DIVQ AX0;
    AR=AY0;
    noinv: MY0=AR;
    MF=AR*MY0 (RND), MY1=DM(I3,M3);
    MR=AR*MY1 (SS), MX1=DM(I3,M3);
    CNTR=3;
    DO approx UNTIL CE;
    MR=MR+MX1*MF (SS), MX1=DM(I3,M3);
    approx: MF=AR*MF (RND);
    MR=MR+MX1*MF (SS);
    AR=MR1;
    AY0=H#4000;
    AF=PASS AY1;
    IF NE AR=AY0-MR1;
    AF=PASS AX1;
    IF LT AR=-AR;
    RTS;
    .ENDMOD;
REKLAMA