Newsgroup: it.comp.lang.visual-basic
Titolo: VB 6 PORTE DI COMUNICAZIONE

1)	Non gridar (=maiuscolo)
2)	Dai un'occhiata al Sito Comune di questo NG (c'è una DLL che fa al caso tuo)
Ciao,
Moreno
#sirri#@
tin.it
(togliete "#" dall'indirizzo)
---------------------------------------------------------------------------
Le risposte alle tue domande le trovi sul Sito Comune di questo NewsGroup:
 
http://www.murialdo.it/it_lang_vb
---------------------------------------------------------------------------

...
    HO INTRAPRESO DA POCO LA PROGRAMMAZIONE IN VB6
    E CHIEDO SE QUALCUNO POTREBBE INDICARMI QUALCHE
    FONTE DI INFORMAZZIONE SULL UTILIZZO DELLE PORTE DI
    COMUNICAZIONE "SERIALE PARALLELA ECC." E SE ESISTO
    NO DEGLI OGGETTI GIA PRONTI .
    GRAZIE
    Vedi(msg di Moreno) + (non postare in HTML)
    Ciao

Ho tradotto questa sub dal vecchio fortran66 (mantenendo la struttura
originaria), non l'ho testata, se a qualcuno interessa ..........
Enrico
Sub FFT(a, b, ntot, n, nspan, isn)
'  multivariate complex fourier transform, computed in place
'  using mixed-radix fast fourier transform algorithm.
'  by r. c. singleton, stanford research institute, sept. 1968
'  arrays a and b originally hold the real and imaginary
'  components of the data, and return the real and
'  imaginary components of the resulting fourier coefficients.
'  NTOT= is the total number of complex data values.
'  N= is the dimension of the current variable.
'  NSPAN/N= is the spacing of consecutive data values
'  while indexing the current variable.
'  the sign of ISN determines the sign of the complex
'  exponential, and the magnitude of ISN is normally one.
'  a tri-variate transform with a(n1,n2,n3), b(n1,n2,n3)
'  is computed by
'      call fft(a,b,n1*n2*n3,n1,n1,1)
'      call fft(a,b,n1*n2*n3,n2,n1*n2,1)
'      call fft(a,b,n1*n2*n3,n3,n1*n2*n3,1)
'  for a single-variate transform,
'  ntot = n = nspan = (number of complex data values), e.g.
'      call fft(a,b,n,n,n,1)
'  the data can alternatively be stored in a single complex array c
'  in standard fortran fashion, i.e. alternating real and imaginary
'  parts. then with most fortran compilers, the complex array c can
'  be equivalenced to a real array a, the magnitude of isn changed
'  to two to give correct indexing increment, and a(1) and a(2) used
'  to pass the initial addresses for the sequences of real and
'  imaginary values, e.g.
'       complex c(ntot)
'       real    a(2*ntot)
'       equivalence (c(1),a(1))
'       call fft(a(1),a(2),ntot,n,nspan,2)
'  arrays at(maxf), ck(maxf), bt(maxf), sk(maxf), and np(maxp)
'  are used for temporary storage.  if the available storage
'  is insufficient, the program is terminated by a stop.
'  maxf must be >= the maximum prime factor of n.
'  maxp must be > the number of prime factors of n.
'  in addition, if the square-free portion k of n has two or
'  more prime factors, then maxp must be >= k-1.
      'Dim a(1), b(1)
'  array storage in nfac for a maximum of 15 prime factors of n.
'  if n has more than one square-free factor, the product of the
'  square-free factors must be <= 210
      Dim nfac(11), np(209)
'  array storage for maximum prime factor of 23
      Dim at(23), ck(23), bt(23), sk(23)
      'equivalence (i,ii)
'  the following two constants should agree with the array dimensions.
      maxp = 209
      maxf = 23
      If (n < 2) Then Exit Sub
      inc = isn
      c72 = 0.309016994374947
      s72 = 0.951056516295154
      s120 = 0.866025403784439
      rad = 6.2831853071796
      If (isn >= 0) Then GoTo 10
      s72 = -s72
      s120 = -s120
      rad = -rad
      inc = -inc
10    nt = inc * ntot
      ks = inc * nspan
      kspan = ks
      nn = nt - inc
      jc = ks / n
      radf = rad * jc * 0.5 'radf = rad * Float(jc) * 0.5
      i = 0
      jf = 0
'  determine the factors of n
      m = 0
      k = n
      GoTo 20
15    m = m + 1
      nfac(m) = 4
      k = k / 16
20    If (k - Int(k / 16) * 16 = 0) Then GoTo 15
      j = 3
      jj = 9
      GoTo 30
25    m = m + 1
      nfac(m) = j
      k = k / jj
30    If (k Mod jj = 0) Then GoTo 25
      j = j + 2
      jj = j ^ 2
      If (jj <= k) Then GoTo 30
      If (k > 4) Then GoTo 40
      kt = m
      nfac(m + 1) = k
      If (k <> 1) Then m = m + 1
      GoTo 80
40    If (k - Int(k / 4) * 4 <> 0) Then GoTo 50
      m = m + 1
      nfac(m) = 2
      k = k / 4
50    kt = m
      j = 2
60    If (k Mod j <> 0) Then GoTo 70
      m = m + 1
      nfac(m) = j
      k = k / j
70    j = ((j + 1) / 2) * 2 + 1
      If (j <= k) Then GoTo 60
80    If (kt = 0) Then GoTo 100
      j = kt
90    m = m + 1
      nfac(m) = nfac(j)
      j = j - 1
      If (j <> 0) Then GoTo 90
'  compute fourier transform
100   sd = radf / kspan 'sd = radf / Float(kspan)
      cd = 2# * Sin(sd) ^ 2
      sd = Sin(sd + sd)
      kk = 1
      i = i + 1
      If (nfac(i) <> 2) Then GoTo 400
'  transform for factor of 2 (including rotation factor)
      kspan = kspan / 2
      k1 = kspan + 2
210   k2 = kk + kspan
      ak = a(k2)
      bk = b(k2)
      a(k2) = a(kk) - ak
      b(k2) = b(kk) - bk
      a(kk) = a(kk) + ak
      b(kk) = b(kk) + bk
      kk = k2 + kspan
      If (kk <= nn) Then GoTo 210
      kk = kk - nn
      If (kk <= jc) Then GoTo 210
      If (kk > kspan) Then GoTo 800
220   c1 = 1# - cd
      s1 = sd
230   k2 = kk + kspan
      ak = a(kk) - a(k2)
      bk = b(kk) - b(k2)
      a(kk) = a(kk) + a(k2)
      b(kk) = b(kk) + b(k2)
      a(k2) = c1 * ak - s1 * bk
      b(k2) = s1 * ak + c1 * bk
      kk = k2 + kspan
      If (kk < nt) Then GoTo 230
      k2 = kk - nt
      c1 = -c1
      kk = k1 - k2
      If (kk > k2) Then GoTo 230
      ak = c1 - (cd * c1 + sd * s1)
      s1 = (sd * c1 - cd * s1) + s1
      c1 = 2# - (ak ^ 2 + s1 ^ 2)
      s1 = c1 * s1
      c1 = c1 * ak
      kk = kk + jc
      If (kk < k2) Then GoTo 230
      k1 = k1 + inc + inc
      kk = (k1 - kspan) / 2 + jc
      If (kk <= jc + jc) Then GoTo 220
      GoTo 100
'  transform for factor of 3 (optional code)
320   k1 = kk + kspan
      k2 = k1 + kspan
      ak = a(kk)
      bk = b(kk)
      aj = a(k1) + a(k2)
      bj = b(k1) + b(k2)
      a(kk) = ak + aj
      b(kk) = bk + bj
      ak = -0.5 * aj + ak
      bk = -0.5 * bj + bk
      aj = (a(k1) - a(k2)) * s120
      bj = (b(k1) - b(k2)) * s120
      a(k1) = ak - bj
      b(k1) = bk + aj
      a(k2) = ak + bj
      b(k2) = bk - aj
      kk = k2 + kspan
      If (kk < nn) Then GoTo 320
      kk = kk - nn
      If (kk <= kspan) Then GoTo 320
      GoTo 700
'  transform for factor of 4
400   If (nfac(i) <> 4) Then GoTo 600
      kspnn = kspan
      kspan = kspan / 4
410   c1 = 1#
      s1 = 0
420   k1 = kk + kspan
      k2 = k1 + kspan
      k3 = k2 + kspan
      akp = a(kk) + a(k2)
      akm = a(kk) - a(k2)
      ajp = a(k1) + a(k3)
      ajm = a(k1) - a(k3)
      a(kk) = akp + ajp
      ajp = akp - ajp
      bkp = b(kk) + b(k2)
      bkm = b(kk) - b(k2)
      bjp = b(k1) + b(k3)
      bjm = b(k1) - b(k3)
      b(kk) = bkp + bjp
      bjp = bkp - bjp
      If (isn < 0) Then GoTo 450
      akp = akm - bjm
      akm = akm + bjm
      bkp = bkm + ajm
      bkm = bkm - ajm
      If (s1 = 0) Then GoTo 460
430   a(k1) = akp * c1 - bkp * s1
      b(k1) = akp * s1 + bkp * c1
      a(k2) = ajp * c2 - bjp * s2
      b(k2) = ajp * s2 + bjp * c2
      a(k3) = akm * c3 - bkm * s3
      b(k3) = akm * s3 + bkm * c3
      kk = k3 + kspan
      If (kk <= nt) Then GoTo 420
440   c2 = c1 - (cd * c1 + sd * s1)
      s1 = (sd * c1 - cd * s1) + s1
      c1 = 2# - (c2 ^ 2 + s1 ^ 2)
      s1 = c1 * s1
      c1 = c1 * c2
      c2 = c1 ^ 2 - s1 ^ 2
      s2 = 2# * c1 * s1
      c3 = c2 * c1 - s2 * s1
      s3 = c2 * s1 + s2 * c1
      kk = kk - nt + jc
      If (kk <= kspan) Then GoTo 420
      kk = kk - kspan + inc
      If (kk <= jc) Then GoTo 410
      If (kspan = jc) Then GoTo 800
      GoTo 100
450   akp = akm + bjm
      akm = akm - bjm
      bkp = bkm - ajm
      bkm = bkm + ajm
      If (s1 <> 0) Then GoTo 430
460   a(k1) = akp
      b(k1) = bkp
      a(k2) = ajp
      b(k2) = bjp
      a(k3) = akm
      b(k3) = bkm
      kk = k3 + kspan
      If (kk <= nt) Then GoTo 420
      GoTo 440
'  transform for factor of 5 (optional code)
510   c2 = c72 ^ 2 - s72 ^ 2
      s2 = 2# * c72 * s72
520   k1 = kk + kspan
      k2 = k1 + kspan
      k3 = k2 + kspan
      k4 = k3 + kspan
      akp = a(k1) + a(k4)
      akm = a(k1) - a(k4)
      bkp = b(k1) + b(k4)
      bkm = b(k1) - b(k4)
      ajp = a(k2) + a(k3)
      ajm = a(k2) - a(k3)
      bjp = b(k2) + b(k3)
      bjm = b(k2) - b(k3)
      aa = a(kk)
      bb = b(kk)
      a(kk) = aa + akp + ajp
      b(kk) = bb + bkp + bjp
      ak = akp * c72 + ajp * c2 + aa
      bk = bkp * c72 + bjp * c2 + bb
      aj = akm * s72 + ajm * s2
      bj = bkm * s72 + bjm * s2
      a(k1) = ak - bj
      a(k4) = ak + bj
      b(k1) = bk + aj
      b(k4) = bk - aj
      ak = akp * c2 + ajp * c72 + aa
      bk = bkp * c2 + bjp * c72 + bb
      aj = akm * s2 - ajm * s72
      bj = bkm * s2 - bjm * s72
      a(k2) = ak - bj
      a(k3) = ak + bj
      b(k2) = bk + aj
      b(k3) = bk - aj
      kk = k4 + kspan
      If (kk < nn) Then GoTo 520
      kk = kk - nn
      If (kk <= kspan) Then GoTo 520
      GoTo 700
'  transform for odd factors
600   k = nfac(i)
      kspnn = kspan
      kspan = kspan / k
      If (k = 3) Then GoTo 320
      If (k = 5) Then GoTo 510
      If (k = jf) Then GoTo 640
      jf = k
      s1 = rad / k 's1 = rad / Float(k)
      c1 = Cos(s1)
      s1 = Sin(s1)
      If (jf > maxf) Then GoTo 998
      ck(jf) = 1#
      sk(jf) = 0#
      j = 1
630   ck(j) = ck(k) * c1 + sk(k) * s1
      sk(j) = ck(k) * s1 - sk(k) * c1
      k = k - 1
      ck(k) = ck(j)
      sk(k) = -sk(j)
      j = j + 1
      If (j < k) Then GoTo 630
640   k1 = kk
      k2 = kk + kspnn
      aa = a(kk)
      bb = b(kk)
      ak = aa
      bk = bb
      j = 1
      k1 = k1 + kspan
650   k2 = k2 - kspan
      j = j + 1
      at(j) = a(k1) + a(k2)
      ak = at(j) + ak
      bt(j) = b(k1) + b(k2)
      bk = bt(j) + bk
      j = j + 1
      at(j) = a(k1) - a(k2)
      bt(j) = b(k1) - b(k2)
      k1 = k1 + kspan
      If (k1 < k2) Then GoTo 650
      a(kk) = ak
      b(kk) = bk
      k1 = kk
      k2 = kk + kspnn
      j = 1
660   k1 = k1 + kspan
      k2 = k2 - kspan
      jj = j
      ak = aa
      bk = bb
      aj = 0#
      bj = 0#
      k = 1
670   k = k + 1
      ak = at(k) * ck(jj) + ak
      bk = bt(k) * ck(jj) + bk
      k = k + 1
      aj = at(k) * sk(jj) + aj
      bj = bt(k) * sk(jj) + bj
      jj = jj + j
      If (jj > jf) Then jj = jj - jf
      If (k < jf) Then GoTo 670
      k = jf - j
      a(k1) = ak - bj
      b(k1) = bk + aj
      a(k2) = ak + bj
      b(k2) = bk - aj
      j = j + 1
      If (j < k) Then GoTo 660
      kk = kk + kspnn
      If (kk <= nn) Then GoTo 640
      kk = kk - nn
      If (kk <= kspan) Then GoTo 640
'  multiply by rotation factor (except for factors of 2 and 4)
700   If (i = m) Then GoTo 800
      kk = jc + 1
710   c2 = 1# - cd
      s1 = sd
720   c1 = c2
      s2 = s1
      kk = kk + kspan
730   ak = a(kk)
      a(kk) = c2 * ak - s2 * b(kk)
      b(kk) = s2 * ak + c2 * b(kk)
      kk = kk + kspnn
      If (kk <= nt) Then GoTo 730
      ak = s1 * s2
      s2 = s1 * c2 + c1 * s2
      c2 = c1 * c2 - ak
      kk = kk - nt + kspan
      If (kk <= kspnn) Then GoTo 730
      c2 = c1 - (cd * c1 + sd * s1)
      s1 = s1 + (sd * c1 - cd * s1)
      c1 = 2# - (c2 ^ 2 + s1 ^ 2)
      s1 = c1 * s1
      c2 = c1 * c2
      kk = kk - kspnn + jc
      If (kk <= kspan) Then GoTo 720
      kk = kk - kspan + jc + inc
      If (kk <= jc + jc) Then GoTo 710
      GoTo 100
'  permute the results to normal order---done in two stages
'  permutation for square factors of n
800   np(1) = ks
      If (kt = 0) Then GoTo 890
      k = kt + kt + 1
      If (m < k) Then k = k - 1
      j = 1
      np(k + 1) = jc
810   np(j + 1) = np(j) / nfac(j)
      np(k) = np(k + 1) * nfac(j)
      j = j + 1
      k = k - 1
      If (j < k) Then GoTo 810
      k3 = np(k + 1)
      kspan = np(2)
      kk = jc + 1
      k2 = kspan + 1
      j = 1
      If (n <> ntot) Then GoTo 850
'  permutation for single-variate transform (optional code)
820   ak = a(kk)
      a(kk) = a(k2)
      a(k2) = ak
      bk = b(kk)
      b(kk) = b(k2)
      b(k2) = bk
      kk = kk + inc
      k2 = kspan + k2
      If (k2 < ks) Then GoTo 820
830   k2 = k2 - np(j)
      j = j + 1
      k2 = np(j + 1) + k2
      If (k2 > np(j)) Then GoTo 830
      j = 1
840   If (kk < k2) Then GoTo 820
      kk = kk + inc
      k2 = kspan + k2
      If (k2 < ks) Then GoTo 840
      If (kk < ks) Then GoTo 830
      jc = k3
      GoTo 890
'  permutation for multivariate transform
850   k = kk + jc
860   ak = a(kk)
      a(kk) = a(k2)
      a(k2) = ak
      bk = b(kk)
      b(kk) = b(k2)
      b(k2) = bk
      kk = kk + inc
      k2 = k2 + inc
      If (kk < k) Then GoTo 860
      kk = kk + ks - jc
      k2 = k2 + ks - jc
      If (kk < nt) Then GoTo 850
      k2 = k2 - nt + kspan
      kk = kk - nt + jc
      If (k2 < ks) Then GoTo 850
870   k2 = k2 - np(j)
      j = j + 1
      k2 = np(j + 1) + k2
      If (k2 > np(j)) Then GoTo 870
      j = 1
880   If (kk < k2) Then GoTo 850
      kk = kk + jc
      k2 = kspan + k2
      If (k2 < ks) Then GoTo 880
      If (kk < ks) Then GoTo 870
      jc = k3
890   If (2 * kt + 1 >= m) Then Exit Sub      'return
      kspnn = np(kt + 1)
'  permutation for square-free factors of n
      j = m - kt
      nfac(j + 1) = 1
900   nfac(j) = nfac(j) * nfac(j + 1)
      j = j - 1
      If (j <> kt) Then GoTo 900
      kt = kt + 1
      nn = nfac(kt) - 1
      If (nn > maxp) Then GoTo 998
      jj = 0
      j = 0
      GoTo 906
902   jj = jj - k2
      k2 = kk
      k = k + 1
      kk = nfac(k)
904   jj = kk + jj
      If (jj >= k2) Then GoTo 902
      np(j) = jj
906   k2 = nfac(kt)
      k = kt + 1
      kk = nfac(k)
      j = j + 1
      If (j <= nn) Then GoTo 904
'  determine the permutation cycles of length greater than 1
      j = 0
      GoTo 914
910   k = kk
      kk = np(k)
      np(k) = -kk
      If (kk <> j) Then GoTo 910
      k3 = kk
914   j = j + 1
      kk = np(j)
      If (kk < 0) Then GoTo 914
      If (kk <> j) Then GoTo 910
      np(j) = -j
      If (j <> nn) Then GoTo 914
      maxf = inc * maxf
'  reorder a and b, following the permutation cycles
      GoTo 950
924   j = j - 1
      If (np(j) < 0) Then GoTo 924
      jj = jc
926   kspan = jj
      If (jj > maxf) Then kspan = maxf
      jj = jj - kspan
      k = np(j)
      ii = i 'equivalence(i,ii)
      kk = jc * k + ii + jj
      k1 = kk + kspan
      k2 = 0
928   k2 = k2 + 1
      at(k2) = a(k1)
      bt(k2) = b(k1)
      k1 = k1 - inc
      If (k1 <> kk) Then GoTo 928
932   k1 = kk + kspan
      k2 = k1 - jc * (k + np(k))
      k = -np(k)
936   a(k1) = a(k2)
      b(k1) = b(k2)
      k1 = k1 - inc
      k2 = k2 - inc
      If (k1 <> kk) Then GoTo 936
      kk = k2
      If (k <> j) Then GoTo 932
      k1 = kk + kspan
      k2 = 0
940   k2 = k2 + 1
      a(k1) = at(k2)
      b(k1) = bt(k2)
      k1 = k1 - inc
      If (k1 <> kk) Then GoTo 940
      If (jj <> 0) Then GoTo 926
      If (j <> 1) Then GoTo 924
950   j = k3 + 1
      nt = nt - kspnn
      ii = nt - inc + 1
      i = ii 'equivalence(i,ii)
      If (nt >= 0) Then GoTo 924
'  error finish, insufficient array storage
998   isn = 0
999   errore$ = "44h0array bounds exceeded within subroutine fft"
End Sub

