PC Toledo

Vou aguçar a curiosidade e capacidade de entendimento com a resolução de alguns algorítmos, quase impensáveis em Clipper, antes
restritos às linguagens C, C++, Fortran, Assembler e outras:
Esses algorítmos utilizam estruturas simples, tais como a For .. Next, e cálculos aritméticos também simples.
Em outros exemplos usaremos funções nativas do Clipper.

Se alguém quiser saber o que o algorítmo abaixo faz, basta compilá-lo e executá-lo.

Código: Selecionar todos

***********************************************************
* Forma de usar o Clipper em cálculo infinitesimal
***********************************************************
local n, i, y, x
setcolor("w+/b,g+/n,,,bg+/b")
clear
set decimal to 17
n := 1
i := 3

for y := 1 to 20000000

    n -= (1/i)
    i += 2
    n += (1/i)
    i += 2

next

x := n * 4

@ 10,10 say "O valor de " + chr(80) + chr(73) + ;
            " calculado ‚: " get x pict "@E #.##############"
clear gets
inkey(0)

Não sei se alguém tentou ver o que o primeiro algorítmo que enviei faz.
Esse agora colocado é para mostrar como são calculados os logarítmos neperianos e decimais.
Todos sabemos que o Clipper já tem a função LOG que pode ser usada tranquilamente.
Inclusive o nosso amigo Eolo citou muito no seu tópico de calculadora financeira.
Mas fica aqui registrado a forma do cálculo infinitesimal que a produz.
Como são milhões de iterações feitas, demora alguns segundos, dependendo do equipamento, mas sai o resultado.
Para quem quiser se aprofundar mais, existem alguns livros que exploram o cálculo infinitesimal (Piskunov);
Se também souberem de um fórmula mais sucinta ou mais rápida, divulgar.
Para conferência dos resultados, já que ninguém deve ter guardado a Tábua de Logarítmos da FTD, pode usar a calculadora científica do Windows.

Código: Selecionar todos

******************************************************
* Cálculo do logaritmo de um número qualquer
******************************************************
local nr,x,k,ln10,nx,ln,lognr,prova
setcolor("w+/b,g+/n,,,bg+/b")
clear

do while .t.

   nr := 0
   @ 10,10 say "Informe o número para calcular o log: " get nr pict "@E #,###,###.####"
   read

   if lastkey() == 27 .or. nr == 0
      clear
      return
   endif

   x      := 10
   k      := ( (x-1) / x ) 
   ln10  := k   

   for nx  :=  2 to 1000000

       ln10 += ( ( k**nx ) / nx )

   next

   k  := ( ( nr - 1 ) / nr )
   ln := k

   for nx := 2 to 10000000

       ln += ( ( k**nx ) / nx )

   next

   lognr := ln / ln10

   @ 12,10 say "O Logarítmo decimal procurado  é: " + ;
                transform(lognr,"@E ###.##########")
   prova  := ( 10**lognr )
   @ 14,10 say "Prova : 10^log = " + transform(prova,"@E #,###,###.####")
   inkey(0)
   @ 12,10 clear to 14,60
 
enddo

Billy,

Antes, uma curiosidade: vc é de 43? Pergunto porque eu sou de 50. Cara, haja história pra contar. hehehe

Concordo com o seu título, o Clipper tem muita história pra contar também. É óbvio que os software e hardware atuais fazem muito mais, e isso é muito bom, mas eu costumo citar que o homem foi à Lua em 1969 (será que foi mesmo?) e, nessa época, acho que nem o Clipper existia ainda... Bem, é muito melhor estar hoje usando um i7 ao invés de um 386 DLX, mas o Clipper não é fraco, não.

Quanto ao LOG, lembro que na faculdade (1970 e alguma coisa), não se tinha acesso a calculadoras financeiras ou científicas e a gente tinha mesmo é que fazer na unha, usando a tábua de logaritmos que vc citou, além de tabelas de coeficientes de juros compostos (um livrão de 500 páginas): a gente elegia um juro imaginado (era de 0,5 em 0,5%), fazia as contas com o coeficiente, se estivesse longe escolhia outro, refazia tudo, e via de regra, no final, tinha que usar de interpolação entre dois coeficientes do livro pra achar a taxa mais próxima da real. Hoje, aperta meia dúzia de botões na HP12C e tá feito, com um monte de casas decimais. Moleza.

Também se usava LOG nos cálculos, só não lembro mais como era (meus livros sumiram em uma das várias mudanças). A única coisa que lembro (se não estou errado) era que se 3^4 = 81, então LOG³81 (log de 81 na base 3) = 4. Dei uma conferida no help do xHarbour e lá tem as funções Log e Log10. A primeira calcula o log natural na base “e” (o tal número de Euler, aproximadamente 2,718 281 828 459 045 235 360 287). A segunda, na base 10. Mas e quando é outra base?

Rodei as duas funções com o mesmo número 81, e as respostas foram LOG=4,394449... e LOG10=1,908485... Na calculadora do Windows7, a resposta é a mesma de LOG10. Já na HP12C, dá o mesmo resultado de LOG, o que permite concluir que, em matemática financeira, é usado o LOG (na base “e”).

Vamos ver se algum outro colega ilumina o túnel.

Respondendo ao Eolo, sou sim de 1943.
Passei por tudo isso que você citou, na faculdade onde não existia calculadora nenhuma, somente alfarábios enormes, gastava-se papel a bessa em cálculos financeiros, interpolando logarítmos e quejandos.

Mas aprendemos muito, na unha.

Para não fundir muito a cuca dos prezados colegas, mas que nas horas vagas interessam-se por outros assuntos que não legislação
tributária, NFe, Sped, etc. aqui vão mais dois pequenos exemplos do que o Clipper responde de letra:

a) calculo da RAIZ QUADRADA
todos sabemos que o Clipper tem a função SQRT mas existe um pequeno algorítmo que a calcula

Código: Selecionar todos

****************************************
* algoritmo - calculo da raiz quadrada
****************************************
local a,b,m,n,nx 
setcolor("w+/b,g+/n,,,bg+/b")
clear
@ 5,15 say "EXTRAIR A RAIZ QUADRADA DE UM NUMERO"

do while .t.

   n := 0
   @ 10,10 say "Informe um numero qualquer: " get n pict "@E ###,###.##" valid n > 0
   read

   if lastkey() == 27
      clear 
      return
   endif

   m := n    

   for nx := 1 to 100
    
       a := n / m   
       b := a + m   
       m := b / 2   

   next

   @ 12,10 say "A raiz quadrada do numero :   " + str(m,12,5)
   inkey(0) 

enddo

b) calculo de seno e cosseno
neste campo o Clipper não tem função pronta como nas outras que citei, mas o algorítmo é interessante
quem quiser pode conferir os resultados na calculadora científica do Windows ou com algum engenheiro

Código: Selecionar todos

********************************************************
* calculo de seno e cosseno para uso em topografia;
* sao informados: grau, minuto e segundo do angulo;
* esses valores sao usados posteriormente juntamente com
* o quadrante (NE, SE, SW e NW) e a distancia entre as
* medicoes, para o calculo da poligonal fechada
* o calculo utiliza o PI e o fatorial dos expoentes
*******************************************************
local ngrau, nminuto, nsegundo, totseg
local nseno, ncose, dimin, aumen
setcolor("w+/b,g+/n,,,bg+/b")
clear
@ 5,15 say " CALCULO DE SENO E COSSENO DE UM ANGULO "
set decimal to 14

do while .t.

   @ 10,10 clear to 16,70
   ngrau := nminuto := nsegundo := 0 
   @ 10,10 say "Informe o grau...: " get ngrau pict "99" valid ngrau < 91
   read

   if lastkey() == 27
      exit
   endif

   if ngrau < 90
      @ 11,10 say "Informe minutos..: " get nminuto pict "99" ;
              valid nminuto < 60 
      read
      if nminuto < 60
         @ 12,10 say "Informe segundos.: " get nsegundo pict "99" ;
                 valid nsegundo < 60 
         read
      endif
   endif

   if ngrau == 0 .and. nminuto == 0 .and. nsegundo == 0
      loop
   endif

   if lastkey() == 27
      exit
   endif

   totseg := nminuto * 60        // apura segundos dos minutos
   totseg += nsegundo            // soma segundos
   totseg /= 3600                // converte para decimal de grau
   ngrau  += totseg              // adiciona aos graus 
   ngrau  *= (3.14159265358979 / 180) // transforma graus em comprimento arco

   nseno  := ngrau               // ponto de partida do grau
   dimin  := (ngrau ** 3) / 6    // 
   nseno  -= dimin
   aumen  := (ngrau ** 5) / 120
   nseno  += aumen
   dimin  := (ngrau ** 7) / 5040
   nseno  -= dimin
   aumen  := (ngrau ** 9) / 362880
   nseno  += aumen
   dimin  := (ngrau ** 11) / 39916800
   nseno  -= dimin
   aumen  := (ngrau ** 13) / 6227020800
   nseno  += aumen
   @ 14,10 say "Seno encontrado..: " + transform(nseno,"@E #.##############")

   ncose  := 1
   dimin  := (ngrau ** 2) / 2
   ncose  -= dimin
   aumen  := (ngrau ** 4) / 24 
   ncose  += aumen
   dimin  := (ngrau ** 6) / 720 
   ncose  -= dimin
   aumen  := (ngrau ** 8) / 40320 
   ncose  += aumen
   dimin  := (ngrau ** 10) / 3628800 
   ncose  -= dimin
   aumen  := (ngrau ** 12) / 47900160 
   ncose  += aumen
   dimin  := (ngrau ** 14) / 87178291200 
   ncose  -= dimin
   @ 24,10 say "Tecle algo para outro calculo" color "gr+/b"
   @ 16,10 say "Coseno encontrado: " + transform(ncose,"@E #.##############")
   inkey(0)
   @ 24,0

enddo

return

Amiguinhos,

Então eu sou o mais novo dos mais velhos aqui. Mas lembro-me de passar pelo juramento a bandeira na escola, palmatória, chapéu de burro e castigo no canto da sala de aula e não ficar na rua depois das 10.

Esta reflexão de cálculos é realmente uma delicia e com certeza o aprendizado em Clipper se define por uso de criação de funções para cálculos matemáticos.

Lembro me de ter criado as minhas funções para minha calculadora(que se perdeu no tempo) e depois encontrar um livro do Antonio Ramalho.

Inclusive em meu sistema na versão DOS tinha um módulo de auxilio ao financeiro que possuia algumas interfaces para calcular juros, prestações, depreciações, etc.

Mas na versão Windows, meus clientes nem chegaram a testar para dar suporte.

Continuem nos brindando com estas técnicas.

a) calculo da RAIZ QUADRADA
todos sabemos que o Clipper tem a função SQRT mas existe um pequeno algorítmo que a calcula

Putz, essa foi fundo. A gente tinha que calcular raiz quadrada na unha. Raiz cúbica, então, não dava tempo. Continuava na aula seguinte. Deuzulivre. O mundo hoje é muito melhor.

Rochinha, vc diz que é o mais novo, então cante o seu ano de nascimento, vamos conferir. Ficar na rua depois das 10? Po, sua mãe era boazinha. Em casa, 9 horas era todo mundo na cama. Seis da manhã o Velho entrava no quarto, abria as cortinas e não falava nada (nem precisava).

Amiguinho

Sou de 65, se não me engano foi o ano de Getúlio se foi. Mas antigamente era assim mesmo.

Legal êsse tópico.
Eu mesmo, uns vinte anos atrás, já fiz um programa em clipper que "dividia como na escola". Utilizava para "achar" dízimas periódicas grandes. Por exemplo:
1 / 1.33 tem a dízima periódica de 18 algarismos. 1 / 1.333 tem muuito mais.

Pois é, Billy ( eu sou de 1950 ) poderia melhorar um pouco o cálculo do PI
calculou: 3,141592678590525 (e demorou muuuito)
o valor é: 3.141592653589793238462643383279502884
(poderia pelo menos ´acertar´ umas quinze casas após a virgula)

Amiguinho Rochinha: Acho que o ´nosso´ Getúlio se foi em 1954. 1965 estava em plena ditadura militar...
T+
Euclides

Trivia: Getúlio se foi dia 24-08-50. Não esqueço porque foi meu aniversário de 4 anos.

Concordo com o Euclides. Legal este tópico. Eu ainda acho que, no mundo dos i7 e Windows8, os programadores têm que saber o que acontece quando eles clicam no botão X. Sob dois aspectos: primeiro, saber o que está por trás do botão X - não simplesmente copiar/colar. Segundo, e o mais importante, é saber visualizar o resultado que "aquele clique" vai ter na vida real dos usuários finais. Nós somos uma elite que está um passo à frente das pessoas comuns, precisamos ter consciência disso. Fazer programa não é só fazer programa. Nós estamos mudando alguma coisa...

Ao amigo Rochinha: o Getúlio se foi no dia 24/08/54, lembro-me como se fosse hoje, eu liguei para o colégio em que fazia a primeira série do Ginásio, +- lá para às 10:00 horas e perguntei se haveria aula naquele dia e me perguntaram porque ?
Naquele tempo não havia TV e o rádio é que noticiava tudo e no Ernesto Monte de Bauru não tinha rádio algum ...

Ao Euclides: não tem porque, se tiver o algorítmo que faça em menor tempo (não estava preocupado com isso, verdade) e com maior
precisão, estamos todos interessados (ao menos eu)

Como o Eolo informou, o que me moveu a transcrever vários algorítmos foi o "querer saber como se faz";

Por isso hoje, exponho os fontes das funções que fiz em lugar das DEC2HEX e HEX2DEC, ambas da LIB PTOOL52.
A razão é que se quisermos passar o Clipper para outro ambiente (XHarbour, Harbour, etc.) essas funções não causarão problemas
pois estarão no código nativo dele;

Código: Selecionar todos

*******************************************************
* função: decimal para hexadecimal e vice versa
* utilidade: permite verificar valores em codigo objeto
* permite tambem guardar valores maiores que o campo
* de bancos de dados que não podemos mais alterar a
* estrutura
****************************************************** 
local tela := savescreen()
local numero  := 0 
local cadeia  := space(8)
local ctipo   := " "
setcolor("w+/b,g+/n,,,bg+/b")
clear

do while .t.

   @ 8,05 clear to 18,75
   @ 8,05 to 18,75 double
   @ 10,14 say "CONVERSÃO DE DECIMAL PARA HEXADECIMAL E VICE VERSA"
   @ 12,14 say "1 - Decimal/Hexadecimal 2 - Hexadecimal/Decimal: " get ctipo ;
                 pict "9" valid ctipo $ "1.2"
   read

   if lastkey() == 27
      restscreen(,,,,tela)
      return
   endif

   if ctipo == "1"

      @ 14,9 say "Informe o número .....: " get numero pict "@E #,###,###,###"
      read

      if numero > 0
         reth := dec2hex(numero)
         @ 15,9 say "Hexadecimal convertido: " 
         @ 15,col()+1 say reth color "gr+/b"
      endif

   else

      @ 14,9 say "Informe o hexadecimal.: " get cadeia pict "@!" 
      read

      if len(cadeia) > 0
         retd := hex2dec(alltrim(cadeia))
         @ 15,9 say "Decimal convertido ...: " 
         @ 15,col()+1 say alltrim(str(retd,10)) color "gr+/b"
      endif

   endif
   
   @ 24,0
   @ 24,15 say "Tecle algo para outra conversão - <ESC> sai "
   inkey(0) 
   numero  := 0 
   cadeia  := space(8)

   if lastkey() == 27
      restscreen(,,,,tela)
      exit
   endif
    
enddo

**************************
* decimal para hexadecimal
**************************
PROCEDURE dec2hex(num)
local matrizc := {"1","2","3","4","5","6","7","8","9","A","B","C","D","E","F"}
local caract  := ""
local resto   := 0
local tamanho := 0
local retorno := ""
local nx

do while .t.

   inteiro := int(num/16)
   resto   := mod(num,16)

   if resto > 0
      caract  += matrizc[resto]
   else
      caract  += "0"
   endif

   num := inteiro 

   if num > 16
      loop
   else
      resto  := mod(num,16) 
      caract += matrizc[resto]
      exit
   endif

enddo

tamanho := len(caract)

if tamanho == 0
   return("")
endif

for nx := tamanho to 1 step -1
    retorno += substr(caract,nx,1)
next

return(retorno)

*
*************************
* Hexadecimal para numero
*************************
PROCEDURE hex2dec(strings)
local matrizv := {1,16,256,4096,65536,1048576,16777216,268435456}
local tamanho := len(alltrim(strings))
local nx 
local valor   := 0
local posicao := 0

if tamanho == 0
   return 0
endif

for nx := 1 to tamanho

    if ! (substr(strings,nx,1) $ "0123456789ABCDEF")
       return 0
    endif

next

for nx := tamanho to 1 step -1

    posicao ++
    hexa := substr(strings,nx,1) 
    
    if hexa $ "0.1.2.3.4.5.6.7.8.9"
       valor += (val(hexa) * matrizv[posicao])
    elseif hexa == "A"  
       valor += (10 * matrizv[posicao])
    elseif hexa == "B"
       valor += (11 * matrizv[posicao])
    elseif hexa == "C"
       valor += (12 * matrizv[posicao])
    elseif hexa == "D"
       valor += (13 * matrizv[posicao])
    elseif hexa == "E"
       valor += (14 * matrizv[posicao])
    else
       valor += (15 * matrizv[posicao])
    endif

next

return (valor)

O amigo Eolo diz que é de 1950 e que o Getúlio morreu no dia 24/08/50, quando ele completou 4 anos

?!!!!!!!

Billy, falha na CPU: nasci em 1950, o Getúlio foi-se em 1954.

Falando em velharias, aqui vai a dica de um livrinho bom pra quem mexe com números: "O homem que calculava", de Malba Tahan (pseudônimo de um engenheiro de Queluz-SP).

Eu li o livro de Malba Tahan há mutos anos atrás, mas lembro-me bem ainda dos casos de matemática (dos 35 camelos) e de lógica (escravas de olhos pretos e azuis) entre outros;

Livros como esse deveriam fazer parte do aprendizado nas escolas, mas a molecada só quer saber de games...

Como o Eolo citou anteriormente, o livro "O homem que calculava" de Malba Tahan, trazia muitos cálculos e exercícios.

Para quem quiser revê-lo ou lê-lo, ele se encontra disponível em:

http://www.tse.gov.br/hotSites/bibliote ... culava.pdf

PC Toledo

Do que o Clipper é capaz - II

Do que o Clipper é capaz - I

Do que o Clipper é capaz - II

Do que o Clipper é capaz - II

Do que o Clipper é capaz - II

Do que o Clipper é capaz - II

Do que o Clipper é capaz - II

Do que o Clipper é capaz - II

Do que o Clipper é capaz - II

Do que o Clipper é capaz - II

Do que o Clipper é capaz - II

Do que o Clipper é capaz - II

Do que o Clipper é capaz - II

Do que o Clipper é capaz - II

Do que o Clipper é capaz - II

Do que o Clipper é capaz - II