Exercicio de treinamento cpp 15/03

intercept

@@ -0,0 +1,21 @@
+Calculo: Goulomb
+0		1
+1		2
+2		2
+3		3
+4		3
+5		3
+6		4
+7		4
+8		4
+9		5
+10		1
+11		2
+12		2
+13		3
+14		3
+15		3
+16		4
+17		4
+18		4
+19		5

src/Calculo.cpp

@@ -31,7 +31,7 @@ unsigned int Calculo::numeroResultados(){
     return 0;
 }
 
-int Calculo::resultado(unsigned int indice){
+unsigned long Calculo::resultado(unsigned int indice){
    // TODO: Implementar
     return 0;
 }

src/Calculo.h

@@ -46,7 +46,7 @@ class Calculo {
      * @param indice
      * @return 
      */
-    virtual int resultado(unsigned int indice);
+    virtual unsigned long resultado(unsigned int indice);
 
     /**
      * Nome do cálculo

src/Fibonacci.cpp

@@ -7,24 +7,30 @@
 
 #include "Fibonacci.h"
 #include <sstream>
+#include <stdio.h>
+#include <string.h>
 
 Fibonacci::Fibonacci(int inicio, unsigned int tamanho, Interceptador *interceptador): Calculo(inicio, tamanho, interceptador) {
     this->resultados.reserve(tamanho);
 }
 
 void Fibonacci::calcula(){
-    int nr = this->inicio;
-    int last = nr;
+    unsigned long nr = this->inicio;
+    unsigned long last = nr;
+
     this->resultados.push_back(nr);
     while(this->resultados.size() < this->tamanho){
         if(last == nr){
             nr = nr + 1;
         }else{
-            int lst = last;
+            unsigned long long lst = last;
             last = nr;
             nr = nr + lst;
+
+
         }
         this->resultados.push_back(nr);
+
     }
 }
 
@@ -36,20 +42,24 @@ string Fibonacci::nome() const{
     return "Fibonacci";
 }
 
-int Fibonacci::resultado(unsigned int indice){
-    int rtn = 0;
+unsigned long Fibonacci::resultado(unsigned int indice){
+    unsigned long rtn = 0;
     if(indice + 1 <= this->resultados.size()) {
         rtn = this->resultados.at(indice);
+
     }
+    //printf("\n index %d result %d\n", indice, rtn);
     return this->interceptador->intercepta(rtn);
+
 }
 
 string Fibonacci::toString(char sep){
     stringstream ss;
-    unsigned int i = 0;
-    for(vector<int>::iterator it = this->resultados.begin(); it != this->resultados.end(); it++){
+    unsigned long i = 0;
+    for(vector<unsigned long>::iterator it = this->resultados.begin(); it != this->resultados.end(); it++){
         ss << *it;
         if(i < (this->resultados.size() - 1)){
+
             ss << sep;
         }
         i++;

src/Fibonacci.h

@@ -47,7 +47,7 @@ class Fibonacci: public Calculo {
      * @param indice
      * @return 
      */
-    virtual int resultado(unsigned int indice);
+    virtual unsigned long resultado(unsigned int indice);
 
     /**
      * Retorna o nome do calculo
@@ -71,7 +71,7 @@ class Fibonacci: public Calculo {
     /**
      * Lista de resultados
      */
-    vector<int> resultados;
+    vector<unsigned long> resultados;
 
 };
 

src/Goulomb.cpp

@@ -0,0 +1,82 @@
+/* 
+ * File:   Goulomb.cpp
+ * Author: Diogo Dias
+ * 
+ * Created on 14 de Marco de 2017, 09:50
+ */
+
+#include "Goulomb.h"
+#include <sstream>
+
+Goulomb::Goulomb(int inicio, unsigned int tamanho, Interceptador *interceptador): Calculo(inicio, tamanho, interceptador) {
+    this->resultados.reserve(tamanho);
+}
+
+void Goulomb::calcula(){
+    int nr = this->inicio;
+    //int last = nr;
+    unsigned int iter = 0;
+    if(nr == 0){
+	this->resultados.push_back(1);
+	iter = 1;
+	//resultados[iter-1] = nr;
+	}else{
+    	this->resultados.push_back(nr);
+	iter = nr;
+	//resultados[iter-1] = nr;
+	}
+//    iter = 1;
+    while(iter < this->tamanho){
+
+       if(iter != 0 && iter != 1){
+
+	//    resultados[iter] = 1;
+      //  }else{
+	resultados[iter] = 1 + resultados[iter - resultados[resultados[iter-1]]];
+        }
+	if(iter == 1){
+		resultados[iter] = 1;
+	}
+	nr = resultados[iter];
+	++iter;
+        this->resultados.push_back(nr);
+    }
+}
+
+unsigned int Goulomb::numeroResultados(){
+    return this->resultados.size();
+}
+
+string Goulomb::nome() const{
+    return "Goulomb";
+}
+
+unsigned long Goulomb::resultado(unsigned int indice){
+    unsigned long rtn = 0;
+    if(indice + 1 <= this->resultados.size()) {
+        rtn = this->resultados.at(indice);
+    }
+    return this->interceptador->intercepta(rtn);
+}
+
+string Goulomb::toString(char sep){
+    stringstream ss;
+    unsigned int i = 0;
+    for(vector<int>::iterator it = this->resultados.begin(); it != this->resultados.end(); it++){
+        ss << *it;
+        if(i < (this->resultados.size() - 1)){
+            ss << sep;
+        }
+        i++;
+    }
+    return ss.str();
+}
+
+void Goulomb::limpaCalculo() {
+    this->resultados.clear();
+}
+
+Goulomb::~Goulomb() {
+    this->limpaCalculo();
+}
+

src/Goulomb.h

@@ -0,0 +1,79 @@
+/* 
+ * File:   Goulomb.h
+ * Author: Diogo Dias
+ *
+ * Created on 14 de Marco de 2017, 09:40
+ */
+
+#ifndef GOULOMB_H
+#define GOULOMB_H
+
+#include <vector>
+#include "Calculo.h"
+
+using namespace std;
+
+/**
+ * Implementa o calculo de Fibonacci.
+ */
+class Goulomb: public Calculo {
+
+public:
+    /**
+     * Constructor
+     * @param inicio Inicio do calculo
+     * @params tamanho Numero de resultados para calcular
+     */
+    Goulomb(int inicio = 0, unsigned int tamanho = 10, Interceptador *interceptador = 0);
+
+    /**
+     * Calcula
+     */
+    void calcula();
+
+    /**
+     * Resultados
+     * @return 
+     */
+    virtual unsigned int numeroResultados();
+
+    /**
+     * Limpa o calculo
+     */
+    virtual void limpaCalculo();
+
+    /**
+     * Retorna o resultado em uma determinada posição
+     * @param indice
+     * @return 
+     */
+    virtual unsigned long resultado(unsigned int indice);
+
+    /**
+     * Retorna o nome do calculo
+     * @return 
+     */
+    virtual string nome() const;
+
+    /**
+     * Transforma o resultado em string.
+     * @param sep Separador
+     * @return 
+     */
+    virtual string toString(char sep);
+
+    /**
+     * Destructor
+     */
+    virtual ~Goulomb();
+private:
+
+    /**
+     * Lista de resultados
+     */
+    vector<int> resultados;
+
+};
+
+#endif /* GOULOMB_H */
+

src/Interceptador.cpp

@@ -17,7 +17,7 @@ Interceptador::Interceptador() {
     //
 }
 
-int Interceptador::intercepta(int i){
+unsigned long Interceptador::intercepta(unsigned long i){
     return i;
 }
 

src/Interceptador.h

@@ -30,7 +30,7 @@ class Interceptador {
      * @param i
      * @return 
      */
-    virtual int intercepta(int i);
+    virtual unsigned long intercepta(unsigned long i);
 
     /**
      * Destrutor

src/Main.cpp

@@ -10,8 +10,11 @@
 #include "Calculo.h"
 #include "Fibonacci.h"
 #include "Primos.h"
+#include "Goulomb.h"
 #include "SalvaCalculo.h"
+#include "Interceptador.h"
 #include <map>
+#include <typeinfo>
 
 #ifdef WITH_UNIT_TEST
 #include <gtest/gtest.h>
@@ -33,11 +36,14 @@ void imprimeCalculo(Calculo *calculo) {
     printf("%s\n", calculo->nome().c_str());
     printf("%s\t\t%s\n", "Indice", "Valor");
     for (unsigned int i = 0; i < calculo->numeroResultados(); i++) {
-        printf("%d\t\t%d\n", i, calculo->resultado(i));
+
+        printf("%d\t\t%lu\n", i, calculo->resultado(i));
+
     }
+
 }
 
-/*
+/*;
  * Este é o ponto de início da aplicação.
  * @param argc Número de argumentos passados
  * @param argv Vetor com os parâmetros
@@ -48,29 +54,41 @@ int main(int argc, char** argv) {
         printf("%s", "Ex: ./calculo 1 100 fibonacci ./teste_fibonacci\n");
         return EXIT_SUCCESS;
     }
-
-    int inicio = atoi(argv[1]);
-    int tamanho = atoi(argv[2]);
+    int intercept_output = 0;
+    unsigned int inicio = atoi(argv[1]);
+    unsigned int tamanho = atoi(argv[2]);
 
     map<string, Calculo*> calculos;
     calculos.insert(pair<string, Calculo*>("fibonacci", new Fibonacci(inicio, tamanho)));
     calculos.insert(pair<string, Calculo*>("primos", new Primos(inicio, tamanho)));
+    calculos.insert(pair<string, Calculo*>("goulomb", new Goulomb(inicio, tamanho)));
+    //calculos.
+    Interceptador *interceptator = new Interceptador();
+    intercept_output = interceptator->intercepta(tamanho);
+    printf("tamanho %d", intercept_output);
+
 
     // Retorna sucesso
     if (argc > 3) {
         if (calculos.count(argv[3]) > 0) {
             Calculo *calculo = calculos.at(argv[3]);
             calculo->calcula();
+//            printf("map b4 %lu\n",calculo->resultado(48));
+
             if (argc > 4) {
                 SalvaCalculo *sc = new SalvaCalculo(calculo);
                 sc->salva(argv[4]);
             } else {
                 imprimeCalculo(calculo);
+
+
             }
         }
     } else {
         for (map<string, Calculo*>::iterator it = calculos.begin(); it != calculos.end(); it++) {
+
             imprimeCalculo(it->second);
+
         }
     }