/*
Teste para analisar a complexidade temporal de algoritmos, especificando como 
o tempo de execução de um algoritmo aumenta em relação ao tamanho da entrada. 

>>> SomaSequencial(nInicio, nFinal)


    faz uma série de operações matemáticas, mas não realiza nenhum loop que 
    dependa diretamente do tamanho da entrada. Portanto, a complexidade 
    temporal desta função é constante, ou seja, O(1), porque o tempo de 
    execução não cresce com o tamanho da entrada.
        
    * Mesmo que tenha chamadas de Delay() dentro da função, elas não afetam a 
    complexidade assintótica.

>>> SomaSequencialConvencional(nInicio, nFinal)

    essa função usa um loop "for" que itera do valor inicio ao valor final. O 
    número de iterações deste loop depende diretamente do tamanho da entrada, 
    ou seja, é proporcional ao valor final - inicio. Portanto, a complexidade 
    temporal desta função é linear, ou seja, O(n), onde "n" é igual a 
    final - inicio.

    * Portanto, para a função SomaSequencialConvencional, a complexidade 
    temporal é O(n), onde "n" é o tamanho da entrada (ou seja, final - inicio).

** a notação Big O descreve o comportamento assintótico do algoritmo, ou seja, 
como o tempo de execução aumenta em relação ao tamanho da entrada quando a 
entrada se torna muito grande. Neste caso, a função SomaSequencial é mais 
eficiente em termos de complexidade temporal do que a função 
SomaSequencialConvencional.

*/


// compilar com: hbmk2 teste_calc2.prg


// Ativa o delay com True, reduz o tempo com False
#define MODO_DEBUG  .T.


FUNCTION Main()
    LOCAL x, nInicio := 1, aFinal := {10, 50, 100}
    CLS
    ? "Teste de Calculos Sequencial"
    ? "Arquivo: " ; setcolor("bg/n") ; ?? NomeArquivo() ; setcolor("w/n")
    ? "Delay: " ; setcolor("w+/n")  ; ?? iif( MODO_DEBUG, "Ativo (.2)", "Semi-Ativo  (.01)") ; setcolor("w/n")
    ? ">>> calcular o tempo gasto pelas funcoes"
    FOR x := 1 TO LEN(aFinal)
        ? REPLICAT("-",80)
        ? "De " ; setcolor("gr+/n") ; ?? alltrim(str(nInicio)) ; setcolor("w/n") ; ?? " ate " ; setcolor("gr+/n") ; ?? ALLTRIM(STR(aFinal[x])) ; setcolor("w/n")
        nTempo1 = TIME() ; ? "Resultado: " + ALLTRIM(STR(INT(SomaSequencial(nInicio,aFinal[x]))))        ; nTempo2 = TIME() ; ?? " Tempo Gasto: " ; setcolor("r/n") ; ?? ElapTime(nTempo1, nTempo2) ; setcolor("w/n") ; ?? " (SomaSequencial)"
        nTempo1 = TIME() ; ? "Resultado: " + ALLTRIM(STR(SomaSequencialConvencional(nInicio,aFinal[x]))) ; nTempo2 = TIME() ; ?? " Tempo Gasto: " ; setcolor("r/n") ; ?? ElapTime(nTempo1, nTempo2) ; setcolor("w/n") ; ?? " (SomaSequencialConvencional)"
    NEXT
    ? REPLICAT("-",80)
RETURN Nil


// Funcao para causar um retardo intencional nos processos
FUNCTION Delay()
    INKEY(iif(MODO_DEBUG,.2,.01))
RETURN Nil

// Funcao que calcula a sequencia de uma unica vez.
FUNCTION SomaSequencial(nInicio, nFinal)
    LOCAL nReserva := 0
    LOCAL nTotTermos := (nFinal - nInicio) +1
    LOCAL nMetade, nDoisTermos, nResultado
    if ((nTotTermos % 2) != 0) // paridade: IMPAR
        nReserva := nFinal ; Delay()
        nFinal-- ; Delay()
        nTotTermos-- ; Delay()
    endif
    nMetade := nTotTermos / 2 ; Delay()
    nDoisTermos := nFinal + nInicio ; Delay()
    nResultado := (nMetade * nDoisTermos) + nReserva ; Delay() // Nessa funcao, eu tenho 6 delays!
RETURN nResultado


// Funcao que utiliza um laço "for" para calcular a sequencia
FUNCTION SomaSequencialConvencional(nInicio, nFinal)
    LOCAL n, nResultado := 0
    FOR n := nInicio to nFinal
        nResultado += n ; Delay() // Nessa funcao, eu so tenho esse delay!
    NEXT
RETURN nResultado


// Retorna o nome do arquivo
FUNCTION NomeArquivo()
    cNomeArquivo := procfile()
    nTam := len(cNomeArquivo) -4
RETURN substr(cNomeArquivo, 1, nTam)