#include <iostream>
#include "as-funcoes.h"

// Funcao mais simples possivel: Nao faz nada.
void nada()
{
}

// Esta trabalha a toa: o resultado do calculo nao e usado.
void calcula_10_fatorial()
{
    int fat{1};
    for (int i = 2; i <= 10; ++i) {
        fat *= i;
    }
}

// Esta tem um efeito colateral (escreve na tela)
void saudacao()
{
    std::cout << "Estou na funcao saudacao\n";
}

// Esta calcula fatorial de 10. Mas so de 10.
int fatorial_de_10()
{
    int fat{1};
    for (int i = 2; i <= 10; ++i) {
        fat *= i;
    }
    return fat;
}

// Esta calcula fatorial de um n dado; n precisa ser >= 0.
int fatorial(int n)
{
    int fat = 1;
    for (int i = 2; i <= n; ++i) {
        fat *= i;
    }
    return fat;
}

// Outra de fatorial, mas versao recursiva.
int fat_rec(int n)
{
    if (n <= 1) {
        return 1;
    }
    else {
        return n * fat_rec(n-1);
    }
}

// Calcula numero de combinacoes de n elemetos m a m.
int combinacoes(int n, int m)
{
    return fatorial(n) /
        (fatorial(m) * fatorial(n-m));
}

// Sequencia dos n primeiros numeros de Fibonacci
std::vector<int> fibonacci(int n)
{
    std::vector<int> sequencia{1, 1};
    for (int i = 2; i < n; ++i) {
        auto novo = sequencia[i-1] + sequencia[i-2];
        sequencia.push_back(novo);
    }

    return sequencia;
}

// Uma funcao que retorna dois valores.
// Tem que retornar uma tupla com os dois valores.
// std::tuple<int, int> indica uma tupla com dois int
std::tuple<int, int> div_mod(int n, int m)
{
    auto div = n / m;
    auto mod = n % m;
    return {div, mod};
}

// Esta funcao altera o conteudo do vetor v.
// Para alterar o conteudo do argumento, nao podemos
// fazer uma copia, mas temos que usar referencia.
// Por isso o & antes do nome do argumento.
// Isto faz com que v desta funcao seja apenas um novo
// nome (sinonimo) da variavel passada na chamada da
// funcao.
void escala(std::vector<int> &v, int c)
{
    for (auto &vi: v) {
        vi *= c;
    }
}

// Soma de todos os elementos de v.
// Evita copiar o vetor usando uma referencia,
// mas como nao queremos alterar o vetor, marcamos
// como const
int soma(std::vector<int> const &v)
{
    int resultado{0};
    for (auto vi: v) {
        resultado += vi;
    }
    return resultado;
}

// Uma funcao com dois parametros com valores assumidos.
// Os valores assumidos sao especificados no prototipo (acima)
std::vector<double> comb_lin(std::vector<double> const &v1,
                             std::vector<double> const &v2,
                             double a, double b)
{
    auto n = static_cast<int>(v1.size());
    std::vector<double> resultado(n);
    for (int i = 0; i < n; ++i) {
        resultado[i] = a * v1[i] + b * v2[i];
    }

    return resultado;
}

// As tres funcoes abaixo tem o mesmo nome, mas operam sobre
// argumentos de tipos diferente.
// Quando funcoes tem o mesmo nome, dizemos que existe
// sobrecarga de nome de funcao.
bool muito_grande(int i)
{
    return i > 100;
}

bool muito_grande(double x)
{
    return x > 10;
}

bool muito_grande(std::string s)
{
    return s.length() > 10;
}