home *** CD-ROM | disk | FTP | other *** search
/ The Datafile PD-CD 4 / DATAFILE_PDCD4.iso / utilities / utilsf / fftgraph / !FFT_2D / scr / s / MCFFTlib
Encoding:
Text File  |  1995-09-16  |  7.0 KB  |  246 lines
  1.  
  2. ;MCPower
  3. ; C prototype : MCPower(float *a, float *b, int count)
  4. ; return a[n] = sqrt(a[n]*a[n] + b[n]*b[n])
  5. ;
  6. a1 RN 0
  7. a2 RN 1
  8. a3 RN 2
  9. a4 RN 3
  10. v1 RN 4
  11. v2 RN 5
  12. v3 RN 6
  13. v4 RN 7
  14. v5 RN 8
  15. v6 RN 9
  16. sl RN 10
  17. fp RN 11
  18. ip RN 12
  19. sp RN 13
  20. lr RN 14
  21. pc RN 15
  22.  
  23. f0 FN 0
  24. f1 FN 1
  25. f2 FN 2
  26. f3 FN 3
  27. f4 FN 4
  28. f5 FN 5
  29. f6 FN 6
  30. f7 FN 7
  31.  
  32.         AREA     |C$$code|, CODE, READONLY
  33.  
  34.         IMPORT  |x$stack_overflow|
  35.  
  36.     EXPORT    |MCPower|
  37.         EXPORT  |MCRevbin|
  38.     EXPORT    |MCstepfft|
  39.         EXPORT  |MCSwap|
  40.     EXPORT    |MCHanning|
  41.  
  42. |MCPower|
  43.  
  44.         MOV     ip, sp
  45.         STMFD   sp!, {a1,a2,a3,a4,v1,v2,v3,v4,fp,ip,lr,pc}
  46. ;        SFMFD    f4,4,[sp]!
  47.         STFE    f7, [sp, #-12]!
  48.         STFE    f6, [sp, #-12]!
  49.         STFE    f5, [sp, #-12]!
  50.         STFE    f4, [sp, #-12]!
  51.         SUB     fp, ip, #4
  52.         CMPS    sp, sl
  53.         BLLT    |x$stack_overflow|
  54.  
  55. Powerloop
  56.         ADD    v1, a1, a3, ASL#2    ; v1 = a[n]
  57.     ADD    v2, a2, a3, ASL#2    ; v2 = b[n]
  58.  
  59.     LDFS    f1, [v1,#0]        ; f1 = a[n]
  60.     MUFS    f1, f1, f1        ; f1 = a[n] * a[n]
  61.     LDFS    f2, [v2,#0]        ; f2 = b[n]
  62.     MUFS    f2, f2, f2        ; f2 = b[n] * b[n]
  63.     ADFS    f1, f1, f2        ; f1 = a[n] * a[n] + b[n] * b[n]
  64.     SQTS    f1, f1
  65.     STFS    f1, [v1,#0]        ; a[n] = sqrt(a[n]*a[n] + b[n]*b[n]
  66.     SUBS    a3, a3, #1
  67.     BNE    Powerloop
  68.  
  69.         LDFE    f4, [fp, #-92]
  70.         LDFE    f5, [fp, #-80]
  71.         LDFE    f6, [fp, #-68]
  72.         LDFE    f7, [fp, #-56]
  73.         LDMEA   fp, {v1,v2,v3,v4,fp,sp,pc}^
  74.  
  75.  
  76.  
  77. ;    s.MCRevbin
  78. ;       MCRevbin - Returns the reversed ordered bits of the argument
  79. ;       C prototype: extern int MCRevbin(int x, int m)
  80.  
  81.  
  82. |MCRevbin|
  83.  
  84.     MOV    a3, #32            ; r2 = word size is loop counter
  85.     MOV    a4, #0            ; r3 = 0
  86.     RSB    a2, a2, #31        ; r1 = 31 - m
  87. Revbinloop
  88.     MOVS    a1, a1, LSL#1        ; put top bit in carry
  89.         MOVS    a4, a4, RRX        ; get carry in top bit
  90.     SUBS    a3, a3, #1        ; counter--
  91.     BNE    Revbinloop
  92.     MOV    a1, a4, LSR a2        ; shift right by (31-m)
  93.         MOV     pc, lr
  94.  
  95. ;     s.MCstepfft
  96.  
  97.  
  98. |MCstepfft|
  99.  
  100.         MOV     ip, sp
  101.         STMFD   sp!, {a1,a2,a3,a4,v1,v2,v3,v4,fp,ip,lr,pc}
  102. ;        SFMFD    f4,4,[sp]!
  103.         STFE    f7, [sp, #-12]!
  104.         STFE    f6, [sp, #-12]!
  105.         STFE    f5, [sp, #-12]!
  106.         STFE    f4, [sp, #-12]!
  107.         SUB     fp, ip, #4
  108.         CMPS    sp, sl
  109.         BLLT    |x$stack_overflow|
  110.         MOV     v3, a1            ; v3 = a
  111.         MOV     v2, a2            ; v2 = b
  112.         MOV     v4, a3            ; v4 = n
  113.         MOV     v1, a4                  ; v1 = span
  114.  
  115.     ADR    a1, pi
  116.         LDFS    f1, [a1,#0]        ; f1 = pi
  117.         FLTS    f0, v1            ; f0 =(float)span
  118.         DVFS    f5, f1, f0        ; angle = f5 = pi/span
  119.         SINS    f0, f5            ; incsin = f0 = sin(angle)
  120.         MVFS    f4, f0            ; incsin = f4 = f0
  121.         MUFS    f5, f5, #0.5        ; f5 = angle * 0.5
  122.     SINS    f0, f5            ; f0 = sin(angle * 0.5)
  123.         MUFS    f6, f0, #2              ; f6 = 2 * sin(angle * 0.5)
  124.         MUFD    f0, f6, f0        ; inccos = f0 = 2 * sin(angle * 0.5) * sin(angle * 0.5)
  125.         MVFS    f2, f0            ; inccos = f2 = f0
  126.         MNFS    f1, #2                  ; f1 = -2
  127.         MUFS    f0, f0, f1              ; dcossin = f0 = -2 * inccos
  128.         STFS    f0, [sp, #0]        ; push dcossin
  129.         MVFS    f1, #1                  ; cosine = f1 = 1
  130.         MVFS    f0, #0                  ; sine   = f0 = 0
  131.         MOV     lr, v1, ASL #1        ; twospan = lr = 2 * span
  132. pi
  133.         DCFS    3.1415926535897931
  134.  
  135.         MOV     a2, #0            ; i = a2 = 0
  136. i_loop
  137.         MOV     a1, a2                  ; j = a1 = i
  138. j_loop
  139.         ADD     a4, a1, v1              ; a4 = j + span
  140.         ADD     a3, v3, a4, ASL #2      ; a3 = (a + (j+span)) << 2 ie addr of a[j+span]
  141.         LDFS    f7, [a3, #0]            ; f7 = a[j+span]
  142.         MUFS    f3, f7, f1              ; f3 = a[j+span] * cosine
  143.         ADD     ip, v2, a4, ASL #2      ; ip = (b + (j+span)) << 2 ie addr of b[j+span]
  144.         LDFS    f5, [ip, #0]            ; f5 = b[j+span]
  145.         MUFS    f6, f5, f0              ; f6 = b[j+span] * sine
  146.         SUFS    f3, f3, f6              ; termr = f3 = a[j+span] * cosine - b[j+span] * sine
  147.         MVFS    f6, f3            ; f6 = termr
  148.         MUFS    f7, f7, f0              ; f7 = a[j+span] * sine
  149.         MUFS    f5, f5, f1              ; f5 = b[j+span] * cosine
  150.         ADFS    f5, f7, f5              ; termi = f5 = a[j+span] * sine + b[j+span] * cosine
  151.         ADD     a4, v3, a1, ASL #2    ; a4 = (a + j) << 2  ie addr a[j]
  152.         LDFS    f7, [a4, #0]        ; f7 = a[j]
  153.         SUFS    f3, f7, f3        ; f3 = a[j] - termr
  154.         STFS    f3, [a3, #0]        ; a[j+span] = a[j] - termr
  155.         ADD     a3, v2, a1, ASL #2    ; a3 = (b + j) << 2  ie addr b[j]
  156.         LDFS    f3, [a3, #0]        ; f3 = b[j]
  157.         SUFS    f3, f3, f5        ; f3 = b[j] - termi
  158.         STFS    f3, [ip, #0]        ; b[j+span] = b[j] - termi
  159.         LDFS    f3, [a4, #0]        ; f3 = a[j]
  160.         ADFS    f3, f3, f6        ; f3 = a[j] + termr
  161.         STFS    f3, [a4, #0]        ; a[j] = a[j] + termr
  162.         LDFS    f3, [a3, #0]        ; f3 = b[j]
  163.         ADFS    f3, f3, f5        ; f3 = b[j] + termi
  164.         STFS    f3, [a3, #0]        ; b[j] = b[j] + termi
  165.         ADD     a1, a1, lr        ; j = j + twospan
  166.         CMPS    a1, v4            ; j < n ?
  167.     BLT    j_loop
  168.  
  169.         LDFS    f3, [sp, #0]        ; pop dcossin in f3
  170.         MUFS    f3, f3, f1        ; f3 = dcossin * cosine
  171.         ADFS    f2, f3, f2        ; inccos = dcossin * cosine + inccos
  172.         ADFS    f1, f1, f2        ; cosine = cosine + inccos
  173.         LDFS    f3, [sp, #0]        ; pop dcossin in f3
  174.         MUFS    f3, f3, f0        ; f3 = dcossin * sine
  175.         ADFS    f4, f3, f4        ; incsin = dcossin * sine + incsin
  176.         ADFS    f0, f0, f4        ; sine = sine + incsin
  177.         ADD     a2, a2, #1        ; i = i + 1
  178.         CMPS    a2, v1            ; i < span ?
  179.         BLT     i_loop
  180.  
  181.         LDFE    f4, [fp, #-92]
  182.         LDFE    f5, [fp, #-80]
  183.         LDFE    f6, [fp, #-68]
  184.         LDFE    f7, [fp, #-56]
  185.         LDMEA   fp, {v1,v2,v3,v4,fp,sp,pc}^
  186.  
  187.  
  188. ;    s.MCSwap
  189. ;       MCSwap - swap word sized variables
  190. ;       C prototype: extern void MCSwap(*a, *b)
  191.  
  192.  
  193.  
  194. |MCSwap|
  195.         MOV     ip, sp
  196.         STMFD   sp!, {a1,a2,a3,a4,v1,v2,v3,v4,fp,ip,lr,pc}
  197.         SUB     fp, ip, #4
  198.         CMPS    sp, sl
  199.         BLLT    |x$stack_overflow|
  200.  
  201.     LDR    v2, [a2,#0]
  202.     SWP    v1, v2, [a1]
  203.     STR    v1, [a2,#0]
  204.  
  205.         LDMEA   fp, {v1,v2,v3,v4,fp,sp,pc}^
  206.  
  207.  
  208. ;MCHanning
  209. ; C prototype : MCHanning(float *hanning, int n_data)
  210. ; return hanning[n] = cos(angle)*cos(angle)
  211. ;            angle = -pi/2.0 + ((pi/n_data)*n)
  212.  
  213. |MCHanning|
  214.         MOV     ip, sp
  215.         STMFD   sp!, {a1,a2,a3,a4,v1,v2,v3,v4,fp,ip,lr,pc}
  216. ;        SFMFD    f4,4,[sp]!
  217.         STFE    f7, [sp, #-12]!
  218.         STFE    f6, [sp, #-12]!
  219.         STFE    f5, [sp, #-12]!
  220.         STFE    f4, [sp, #-12]!
  221.         SUB     fp, ip, #4
  222.         CMPS    sp, sl
  223.         BLLT    |x$stack_overflow|
  224.  
  225.     FLTS    f2, a2            ; f2 = (float)n_data
  226.     LDFS    f1, = 3.1415926535897931
  227.     DVFS    f1, f1, f2        ; step = f1 = PI/n_data
  228.     LDFS    f2, = -1.5707963267948966 ; an = f2 = -PI/2
  229.     MOV    v1, #0
  230. Hanningloop
  231.     COSS    f3, f2            ;f3 = cos(an)
  232.     MUFS    f3, f3, f3        ;f3 = cos(an) * cos(an)
  233.     STFS    f3,[a1],#4        ;hanning[n++] = cos(an) * cos(an)
  234.     ADFS    f2, f2, f1        ;an = an + step
  235.     ADD    v1, v1, #1        ;n++
  236.     CMP    v1, a2
  237.     BLT    Hanningloop
  238.  
  239.         LDFE    f4, [fp, #-92]
  240.         LDFE    f5, [fp, #-80]
  241.         LDFE    f6, [fp, #-68]
  242.         LDFE    f7, [fp, #-56]
  243.         LDMEA   fp, {v1,v2,v3,v4,fp,sp,pc}^
  244.  
  245.         END
  246.