Cara o que eu posso fazer é comentar o código e dai você procura as
"traduções". valeu?
Os meus comentários estarão entre {}. É tudo muito intuitivo.
******************
Attribute VB_Name = "Module1" {nome do módulo com as funções}
{aqui começa a declaração de variáveis globais e como você pode ver, são todas
públicas.}
{Após os 'As', vem o tipo de variável}
Public dist() As Single 'Array bidimensional para armazenar a matriz de
distancia
Public adj() As Integer 'Array bidimensional para armazenar a matriz de
adjacencia
Public adjprod() As Integer 'Array bidimensional para armazenar a matriz de
caminhos
Public num_vert As Integer 'Numero de vertices do grafo
Public i, j As Integer 'indices para as matrizes
Public allcells As String
Public Fnum, num_linhas As Integer
Public TxtBoxGotFocus As Boolean 'flag para controlar o foco na apresentação de
FormDados
Public Shortest() As Single 'Array bidimensional para armazenar as distancias
calculadas pelo algoritmo de Floyd
Public Caminho As String 'String para armazenar o caminho
Public para() As Single 'Array para armazenar o caminho temporario de um
vertice i ate um
'vertice j
Public lim_inferior As Integer
Public lim_superior As Integer
{aqui temos uma única função que deve retornar um inteiro e termina em 'End
Function'}
'Funcao para determinar a existencia de caminho entre os vertices do grafo
'Não foi necessária neste contexto
Function Determina_Caminho( n As Integer) As Integer
{'Dim' é uma forma de declarar variáveis}
Dim k As Integer
{'ReDim' (abaixo) é uma função que até onde eu sei, não existe no Delphi e
chega a ser um ponto crítico}
{na tradução deste código. está função redefine uma variável já declarada}
'Redimensionamento da matriz de adjacencia
ReDim adjprod(n, n)
{dois loops FOR, encadeados. 'Next' marca o fim do loop}
'Inicialização das matrizes
For i = 1 To n
For j = 1 To n
adjprod(i, j) = adj(i, j)
Next j
Next i
'Multiplicação boolena
For k = 1 To n
For i = 1 To n
For j = 1 To n
adjprod(i, j) = adjprod(i, j) Or (adjprod(i, k) And
adjprod(k, j))
Next j
Next i
Next k
End Function
{aqui começa os procedimentos, ou procedure. 'End Sub' marca o fim da procedure}
'Sub-rotina para inicialização da matriz de distancia
Sub init_mtDistancia( n As Integer)
'Redimensionamento da matriz de distancia
ReDim dist(n, n)
For i = 1 To n
For j = 1 To n
dist(i, j) = 3.402823E+38
Next j
Next i
End Sub
'Sub-rotina para inicialização da matriz de adjacencia
'Sub init_mtAdjacencia( n As Integer)
'Redimensionamento da matriz de adjacencia
' ReDim adj(n, n)
' For i = 1 To n
' For j = 1 To n
' adj(i, j) = 0
' Next j
' Next i
'End Sub
{outra procedure}
'Sub-rotina para desalocação de memória
Sub destrutor()
{limpa os arrays}
Erase dist
Erase adj
End Sub
{outra procedure}
'Sub-rotina para acrescimo de um arco.
Sub Add_Arco(d As Single, nodo_1 As Integer, nodo_2 As Integer)
'Ao ser acrescentado um arco, sera atribuido o valor 1 na matriz de adjacencia
para indicar que existe um caminho entre os dois arcos e o valor deste arco na
matriz de distancias
'adj(nodo_1, nodo_2) = 1 'nao foi necessaria neste contexto
dist(nodo_1, nodo_2) = d
End Sub
{outra procedure}
'Sub-rotina para remocao de um arco
Sub Rem_Arco(nodo_ 1 As Integer, nodo_2 As Integer)
'Ao ser removido...
'adj(nodo_1, nodo_2) = 0
dist(nodo_1, nodo_2) = 3.402823E+38 'flag para distancia infinita
End Sub
{outra função}
'Funcao para determinar o menor caminho pelo algoritmo de Floyd
Function Floyd(n As Integer) As Single
Dim u, v, w As Integer
Dim changed As Integer
'array bidimensional auxiliar
changed = 1
Max = num_vert
ReDim Shortest(n, n)
ReDim para(n, n)
For v = 1 To n
For w = 1 To n
Shortest(v, w) = dist(v, w)
para(v, w) = w
Next w
Next v
{o nosso conhecido 'while' finalizado em 'Wend'}
While changed 'Testa o valor de changed
changed = 0
For u = 1 To n
For v = 1 To n
For w = 1 To n
{o nosso conhecido 'If' finalizado em 'End If'}
If Shortest(v, u) + Shortest(u, w) < Shortest(v, w) Then
Shortest(v, w) = Shortest(v, u) + Shortest(u, w)
para(v, w) = para(v, u)
changed = 1
End If
Next w
Next v
Next u
Wend
End Function
{outra função}
'Funcao para imprimir a rota
Function print_shortest( a As Integer, b As Integer) As String
Dim rota As String
Dim aux As String
While a <> b
rota = "->" + CStr(para(a, b))
aux = aux + rota
a = para(a, b)
Wend
print_shortest = aux
End Function
****************
__________________________________________________
Fale com seus amigos de graça com o novo Yahoo! Messenger
http://br.messenger.yahoo.com/
[As partes desta mensagem que não continham texto foram removidas]
