código-fonte aberto (e explicado)

["Benjamin Hinrichs" <hinsoft@xxxxxxxxx>]

-----Original Message-----
From: Benjamin Hinrichs [mailto:hinsoft@sinos.net]
Sent: Quarta-feira, 19 de Maio de 1999 21:31
To: Obm-Rj
Subject: código-fonte aberto (e explicado)


Olá,...

Como forma de aprimorar meu programa, estou enviando mais uma vez o código
fonte, com pequenos comentários seguindo cada linha. Se alguém achar alguma
falha lógica ou repetimento de comandos, coisa do gênero, eu agradeço e
ponho tal pessoa nos agradecimentos especiais... (poxa, que honra).


Sub Optimize()
--Início de um procedimento (não é o procedimento inicial. Tal se encontra
abaixo)--
'==============================================================
'Processo do Optimização da resposta
'==============================================================
    If Text2.Text = "É primo" Then Exit Sub
--Se na caixa de texto diz "É primo" então feche o procedimento (não há nada
a optimizar. Optimizar significa transformar 2*2 em 2^2, por exemplo). caixa
de texto dois contém o números decomposto em nos. primos, separados por
";"--

Dim i, XCopy, Answ, Count, where, where2, what
--Declaração de variáveis, necessário para o procedimento--

    XCopy = Text2.Text
--Faz com que xcopy (uma variável) contenha a mesma informação (números) que
a caixa de texto 2.--

UpMe:
--É uma subdivisão do procedimento. Uso isto para fazer uma repetição
eterna, colocando algumas condições...--

    where = InStr(1, XCopy, ";")
--Declara a variável 'where' como sendo o local onde está o primeiro ";"--

    what = Left(XCopy, where)
--Copia todo o que está a esquerda do ";", no caso um dos números primos da
resposta.--

    'While InStr(1, XCopy, what) = 1
--Isto é um comentário, acho que foi durante um dos meus testes, deixei prá
trás; desconsiderem a linha acima--

    While Left(XCopy, Len(what)) = what
--Enquanto a esquerda de xcopy (partindo do número de algarismos da variável
what) for igual ao conteúdo de what--

        Count = Count + 1
--Count, outra váriavel, aumenta em uma unidade. É a potência do no. primo--

        XCopy = Right(XCopy, Len(XCopy) - Len(what))
--xcopy=parte de texto (de xcopy) a direita, tendo o comprimento de
xcopy-what--

    Wend
--Volta para o while acima até que não seje mais verdadeiro (a condição
proposta acima). Se sempre for verdadeiro, depois de alguns minutos o
programa se sobrecarrega e trava. Pode ser desligado com ctrl+alt+del.--

    Answ = Answ & Left(what, Len(what) - 1) & "^" & Count & ";"
--variável answ = answ (==>é a parte já existente) + what - última letra (;)
+ símbolo de potência (^) + count (a potência) + separação para o próximo
termo (;)--

    Count = 0
--a potência é zerada, já que agora entra um novo primo--

    If Not XCopy = "" Then GoTo UpMe
--se não xcopy="" (==>no vb isto significa algo parecido como zero bytes,
vazio, se não me engano. Tem uns dez tipos diferentes de "informação
inexistente". Nulo, inexistente, vazio...) então volte para o subdivisão do
procedimento UpMe, logo acima. Este procedimento se repete até que a
variável fique vazia--

    Text2.Text = Answ
--caixa de texto 2 se torna igual a variável answ--

    While InStr(1, Text2, "^1;")
--enquanto se acha na resposta (text2, caixa de texto 2) o termo "^1;"
(potência 1. o ; é necessário para não se confundir com potências tipo
2^12;. Foi um dos primeiros bugs que eliminei)--

        where = InStr(1, Text2, "^1;") - 1
--variável where é o número de casas da esquerda pra direita -1 onde se acha
o ^, se não me engano. Estou um pouco enferrujado no vb--
        Text2 = Mid(Text2, 1, where) & Mid(Text2, where + 3, Len(Text2) -
where - 2)
--text2=parte escrita do text2, entre as letras 1 (a inclui) e variável
where + parte escrita de text2, entre where+3 e comprimento de text2 -
where -2--

    Wend
--volta até o while anterior até que não se ache mais a expressão "^1;" na
resposta.

End Sub
--Fim do procedimento de optimização da resposta. Leiam a seguir que vai ser
mais divertido (mentchira, mentchira, mentchira)--

'==============================================================
'Decompõe um número em seus fatores primos
'==============================================================
Private Sub Command1_Click()
--Início do procedimento. Acontece sempre que for apertado um botão
(command1)--

    If Len(Text1) > 4 Then
--Se o tamanho do text1 é maior que 4, então... (Este limite eu impus, caso
uma pessoa me insira um número de 50000 dígitos, pensando que depois de um
segundo a resposta tá fora, como numa calculadora)--

        Answ = MsgBox("Este cálculo pode demorar vários minutos ou até
horas. Deseja continuar?", vbOKCancel, "Cuidado...")
--Lança uma janela de mensagem, onde o usuário pode escolher entre parar ou
proseguir--

        If Answ = 2 Then Exit Sub
--Se a resposta à pergunta anterior for 'Calcelar', saia do procedimento (se
fosse um rpg, isto seria o fim do programa)--
    ElseIf Len(Text1) = 0 Then Exit Sub
--por outro lado, se o tamanho do text1 for = 0, não faz sentido proceder.
Achei outro bug; esta linha deve estar fora da condição proposta acima para
esta lista de comandos--

    End If
--fim da condição--

On Error GoTo MyErr
--Em caso de erro, proceda indo para a subdivisão MyErr, localizada abaixo.
Não estou bem certo, mas esta linha pode também ser excluída--

Dim X, i, XCopy, CCopy, si, hwtims
--Declaração de variáveis--

    XCopy = Text1
--xcopy torna se igual a text1--

    CCopy = Text1
--idem para ccopy--

    For i = 2 To Text1 / 2
--como se fosse um somatório, só sem soma. Define o segmento de números a
serem usados, um de cada vez, usando a lista de comandos abaixo até onde diz
'próximo i' (next i)--

HeyMan:
--Subdivisão do procedimento--

    If XCopy = 0 Or XCopy = 1 Then GoTo NextI
--Acho que achei uma falha. Se xcopy = 0 ou 1 então vá para a subdivisão
NextI (e não volte mais!!!). O resultado de uma divisão jamais é zero, caso
contrário já teriam descoberto quanto vale 10/0...)--

        XCopy = XCopy / i
--novo xcopy é igual xcopy/i, acho que nem preciso mais explicar comandos
tão "óbvios", isto é, claros--

        If InStr(XCopy, ",") = 0 Then
--Se não for achado vírgula, então proceda a seguinte lista de comandos até
o end if (fim da condição)--

            X = X & i & ";"
--A x (a resposta) = x (parte da resposta já existente) + i ( o número que
dividiu text1 e não deu vírgula) + ";"--

            CCopy = XCopy
--CCopy recebe um novo valor, já dividido pelo 'divisor antiprimo'....--

            GoTo HeyMan
--Volte até HeyMan, subdivisão do procedimento--

        Else
--Caso contrário (se uma vírgula for encontrada)--

            XCopy = CCopy
--"restaure o xcopy"--

        End If
--fim da condição--

    Next i
--vai ao próximo i, até que saia do 'segmento de reta' que são os limites de
i--

NextI:
--subdivisão de procedimento--

    Text2 = X
--text2 torna-se igual à x--

    If X = "" Then Text2 = "É primo"
--Se x = vazio, quer dizer que não foram encontrados divisores; logo text1 é
primo--

    Text2.Visible = True
--deve ser resíduo de uma versão mais antiga, onde a caixa text2 é
escondida--

    Optimize
--Vai ao procedimento Optimize. Quando terminá-lo, irá para a linha
seguinte--

    Exit Sub
--Sai do procedimento para não mostrar mensagem de erro abaixo--

MyErr:
--Subdivisão do procedimento--

    MsgBox "Há um erro. Verifique seus números"
--Mensagem de erro--

    Exit Sub
--Isto é completamente desnecessário, porém faz parte da cultura vb. Sai do
procedimento, que termina na linha seguinte--

End Sub
--Fim do procedimento. Graças a Deus...--

É isto, galera. Agora é a vez do Saldanha. Escrevi este programa durante as
férias, se não me engano. Faz um bom tempo, e se quisesse tentar entendê-lo
novamente, teria de pegar qualquer tarde destas e olhar direitinho. Pelo que
pude entender meus 'manuscritos', há erros como o i ir de 2 até text1/2
(este deve ser modificado para : "for i=2 to sqrt(text1)" (sqrt é square
root, corresponde a raiz quadrada).
Qualquer dia destes eu retomo o programa e o corrijo os erros que achar.

E depois de horas de pensamento, enrolamentos e etc., vejam como é lógica a
programação, ao alcance de todos (os que queiram se enterrar nela, né
Saldanha?). Requer bastante esforça e tempo...

Qualquer dúvida, me perguntem. Aliás, se há mais um matemático que goste de
vb, entre em contato comigo, por favor. Pode ser tanto pela lista ou pelo
meu e-mail (hinsoft@sinos.net).


Não querem que mande mais um programa???

Abraço,

Benjamin Hinrichs