private void Exercicio_5_24()
{
Clear();
int Limite;
Write(" Digite ate onde você quer saber a soma dos numeros -> ");
Limite = int.Parse(ReadLine());
Contador contador = new Contador(1, Limite, 1);
Produtorio produtorio = new Produtorio();
while (contador.Prosseguir())
{
WriteLine();
Write(contador.Valor);
WriteLine();
produtorio.Multiplicar(contador.Valor);
}
Write("\n\n============================\n\n");
WriteLine(" PRODUTO TOTAL = {0} ", produtorio.Valor);
Tratador();
}
private static void LerArquivo()
{
Clear();
WritePos(2, 2, "Insira o nome do arquivo texto: ");
WritePos(2, 3, "(localizado na pasta root do projeto)");
WritePos(2, 4, @"..\..\ .txt");
SetCursorPosition(8, 4);
string caminho;
try // executa o código verificando por exceções
{
string arquivo = ReadLine();
if (arquivo.EndsWith(".txt")) // verifica se o usuário inseriu ".txt" no fim do
{ // nome do arquivo, se não, insere automaticamente
caminho = @"..\..\" + arquivo;
}
else // também é feita uma concatenação, completando o nome
{ // do arquivo com um comando para voltar duas pastas no
caminho = @"..\..\" + arquivo + ".txt"; // sistema de arquivos, de modo a encontrar o arquivo na
} // pasta root do projeto, e não em "\bin\Debug"
var reader = new StreamReader(caminho); // instancia um StreamReader usando a string concatenada com o arquivo
var somaGeral = new Somatoria(); // somatória de todos os números lidos
var somaV = new Somatoria(); // somatória dos valores V lidos com peso P
var somaP = new Somatoria(); // somatória apenas dos valores P lidos
var prodGeral = new Produtorio(); // produtório de todos os números lidos
var somaInversos = new Somatoria(); // somatória dos inversos de todos os números lidos
while (!reader.EndOfStream)
{
string linhaLida = reader.ReadLine(); // lê a linha e divide os valores em
double v = double.Parse(linhaLida.Substring(0, 8)); // v,
double p = double.Parse(linhaLida.Substring(8, 8)); // p
somaGeral.Somar(v); // adiciona v e p à soma geral
somaGeral.Somar(p);
somaV.Somar(v * p); // adiciona v com peso p à somaV
somaP.Somar(p); // adiciona p à somaP
prodGeral.Multiplicar(v); // adiciona v e p ao produtório geral
prodGeral.Multiplicar(p);
somaInversos.Somar(1 / v); // adiciona os inversos de v e p à soma dos inversos
somaInversos.Somar(1 / p);
} // repete até o fim do arquivo
var mat = new MatematicaDouble(prodGeral.Valor);
WritePos(2, 6, $"RMQ = {Math.Sqrt(somaGeral.MediaAritmetica())}"); // calcula RMQ como a raiz da MA
WritePos(2, 7, $"MA = {somaGeral.MediaAritmetica()}"); // calcula MA
WritePos(2, 8, $"MP = {somaV.Valor / somaP.Valor}"); // calcula MP como média entre V com peso e P
WritePos(2, 9, $"MG = {mat.NEsimaRaiz(prodGeral.Qtos)}"); // calcula MG como a n-ésima raiz do produto geral
WritePos(2, 10, $"MH = {somaGeral.Valor / somaInversos.Valor}"); // calcula MH como a soma geral dividida pela soma dos inversos
}
catch (Exception e) // se houver exceção, recebê-la e escrever sua mensagem
{
WritePos(2, 5, "O arquivo não pode ser lido:\n\n");
WritePos(2, 6, e.Message);
WriteLine();
}
EsperarEnterEstilo();
}
public double Elevado(double a)
{
var pot = new Produtorio();
var vez = new Contador(1, nInt, 1);
while (vez.Prosseguir())
{
pot.Multiplicar(a);
}
return(pot.Valor);
}
public int Fatorial()
{
var fat = new Produtorio();
var contador = new Contador(1, nInt, 1);
while (contador.Prosseguir())
{
fat.Multiplicar(contador.Valor);
}
return((int)fat.Valor);
}
public double Fatorial()
{
var fat = new Produtorio();
var vez = new Contador(1, numeroInteiro, 1);
while (vez.Prosseguir()) // faz a contagem neste método
{
fat.Multiplicar(vez.Valor);
}
return(fat.Valor);
}
public int Fatorial()
{
var oFatorial = new Produtorio();
var umContador = new Contador(1, numeroInteiro, 1);
while (umContador.Prosseguir())
{
oFatorial.Multiplicar(umContador.Valor);
umContador.Contar(); // gera o próximo número
}
return(Convert.ToInt32(oFatorial.Valor));
}
public double Elevado(double a)
{
var potencia = new Produtorio();
var vez = new Contador(1, numeroInteiro, 1);
while (vez.Prosseguir())
{
potencia.Multiplicar(a);
}
return(potencia.Valor);
}
public int MMC(int outroValor)
{
int oMMC = 0;
int dividendo1 = numeroInteiro;
int dividendo2 = outroValor;
int quociente1 = 0;
int quociente2 = 0;
var umContador = new Contador(2, numeroInteiro * outroValor, 1);
var umMultiplicador = new Produtorio();
while (dividendo1 != 1 || dividendo2 != 1 && umContador.Prosseguir())
{
numeroInteiro = umContador.Valor;
if (Divisores() == $"1, {umContador.Valor}") // O contador é primo?
{
while (dividendo1 % umContador.Valor == 0 || dividendo2 % umContador.Valor == 0)
{
quociente1 = dividendo1 / umContador.Valor;
quociente2 = dividendo2 / umContador.Valor;
umMultiplicador.Multiplicar(umContador.Valor);
if (dividendo1 % umContador.Valor == 0)
{
dividendo1 = quociente1;
}
if (dividendo2 % umContador.Valor == 0)
{
dividendo2 = quociente2;
}
quociente1 = 0;
quociente2 = 0;
}
}
else
{
quociente1 = 0;
quociente2 = 0;
}
umContador.Contar();
}
oMMC = Convert.ToInt32(umMultiplicador.Valor);
return(oMMC);
}
// Esta função calcula o fatorial do valor armazenado no atributo numeroInteiro
public int Fatorial()
{
var fat = new Produtorio(); // cria na memória um objeto da classe Produtorio
// abaixo criamos o gerador de inteiros de 1 a numeroInteiro (Contador)
var parcela = new Contador(1, numeroInteiro, 1);
while (parcela.Prosseguir()) // gera números e vê se prossegue a contagem
{
fat.Multiplicar(parcela.Valor); // acumula o número gerado (parcela.Valor)
}
return((int)fat.Valor); // (int) ---> Type Cast ou conversão de tipo
}
public double Elevado(double a)
{
var pot = new Produtorio();
var cont = new Contador(1, numeroInteiro, 1);
while (cont.Prosseguir())
{
pot.Multiplicar(a);
}
return(pot.Valor);
}
public double Fatorial()
{
var produtos = new Produtorio();
var contador = new Contador(1, numeroInteiro, 1);
while (contador.Prosseguir)
{
produtos.Multiplicar(contador.Valor);
contador.Contar();
}
return(produtos.Valor);
}
public double Elevado(double a) // exercício 32
{
int x = numeroInteiro;
var prod = new Produtorio();
var cont = new Contador(1, x, 1);
while (cont.Prosseguir)
{
prod.Multiplicar(a);
cont.Contar();
}
return(prod.Valor);
}
public double Elevado(double a)
{
var umContador = new Contador(1, numeroInteiro, 1); // instancia um objeto da classe contador que terá como valor incial 1, valor final um número x digitado pelo usuário e o passo1
var umMultiplicador = new Produtorio(); // instancia um objeto da classe Produtório
while (umContador.Prosseguir()) // esse comando fará com que após a realização dos comandos entre chaves, o fluxo de execução retorne a ele
// o método entre parenteses fará com que se o contador for menor ou igual a número digitado pelo usuário o fluxo de execução entre nos comandos entre parêntese.
{
umMultiplicador.Multiplicar(a); // esse método fa´ra com que o valor presente na variável "a" seja multiplicado pelo valor presente na variável "oProduto".
umContador.Contar();
}
return(umMultiplicador.Valor); // retorna o valor que está na variável "oProduto"
}
public double Elevado(double a)
{
int expoente = numeroInteiro;
double Base = a;
var Conta = new Contador(1, expoente, 1);
var Produtorio = new Produtorio();
while (Conta.Prosseguir())
{
Produtorio.Multiplicar(Base);
}
return(Produtorio.Valor);
}
static void LerArquivo()
{
int N = 0;
double result = 0, result2 = 0;
Clear();
ForegroundColor = ConsoleColor.DarkCyan;
WritePos(5, 1, "=============================================================================");
WritePos(5, 2, " Estatística de uma lista de valores lidos de um arquivo texto ");
WritePos(5, 3, "=============================================================================");
WritePos(8, 7, "Por favor digite o nome do arquivo desejado: ");
string arquivo = ReadLine();
var soma = new Somatoria();
var leitor = new StreamReader(arquivo);
var produto = new Produtorio();
while (!leitor.EndOfStream) // leitura de cada linha e chamada de cálculos sobre estas
{
string linha = leitor.ReadLine();
V = Convert.ToDouble(linha.Substring(inicioV, tamanhoV));
P = Convert.ToDouble(linha.Substring(inicioP, tamanhoP));
soma.Somar(V + P);
produto.Multiplicar(V + P);
soma.SomarComPeso(V, int.Parse(P + ""));
soma.SomarInversos(V + P);
}
leitor.Close();
double mediaAritmeticaCalculada = soma.MediaAritmetica();
double mediaGeometricaCalculada = produto.MediaGeometrica();
double raizMediaQuadraticaCalculada = soma.RaizMediaQuadratica();
double mediaPonderadaCalculada = soma.MediaPonderada();
double mediaHarmonicaCalculada = soma.MediaHarmonica();
WritePos(8, 12, $"O valor da média aritmética é " + mediaAritmeticaCalculada); //exibição de resultados
WritePos(8, 14, $"O valor da média geométrica é " + mediaGeometricaCalculada); //exibição de resultados
WritePos(8, 16, $"O valor da raiz média quadrática é " + raizMediaQuadraticaCalculada); //exibição de resultados
WritePos(8, 18, $"O valor da média ponderada é " + mediaPonderadaCalculada); //exibição de resultados
WritePos(8, 20, $"O valor da média harmônica é " + mediaHarmonicaCalculada); //exibição de resultados
WritePos(8, 25, "Pressione [Enter] para prosseguir");
ReadLine();
}
public int MMC(int y)
{
int numeroInteiro = nInt;
var cont = new Contador(2, int.MaxValue, 1); // contador que será os divisores
var mmc = new Produtorio(); // instancia um produtório que aclculará o MMC
bool jaMultiplicado; // verifica se o valor dividido já foi multiplicado no MMC
while (true)
{
var mat = new Matematica(cont.Valor);
if (mat.EhPrimo()) //verifica se o valor é primo
{
jaMultiplicado = false; // no inicio já foi multiplicado recebe false
if (numeroInteiro % cont.Valor == 0) // verifica se o primeiro valor é divisível por cont.Valor
{
numeroInteiro /= cont.Valor; // divide o premeiro numero
mmc.Multiplicar(cont.Valor);
jaMultiplicado = true; // cont.Valor já foi multiplicado no MMC
}
if (y % cont.Valor == 0) // verifica se o segundo é divisível por cont.Valor
{
if (!jaMultiplicado) // se já foi multiplicado antes, não devemos fazer novamente
{
mmc.Multiplicar(cont.Valor);
}
y /= cont.Valor; // divide o premeiro numero
}
}
if (numeroInteiro % cont.Valor != 0 && y % cont.Valor != 0) // verifica se os valor ainda são divisiveis pelo cont.Valor
{
cont.Contar(); // soma um ao contador
}
if (numeroInteiro == 1 && y == 1) // se os dois valores chegaram a 1, o MMC foi encontrado
{
return((int)mmc.Valor); // retorna o MMC
}
}
}
public double CalculoMMC(int outroValor)
{
int dividendo1 = numeroInteiro;
int dividendo2 = outroValor;
int quociente1 = 0;
int quociente2 = 0;
var oMMC = new Produtorio();
for (int contador = 2; dividendo1 != 1 || dividendo2 != 1; contador++)
{
numeroInteiro = contador;
if (EhPrimo())
{
while (dividendo1 % contador == 0 || dividendo2 % contador == 0)
{
oMMC.Multiplicar(contador);
if (dividendo1 % contador == 0)
{
quociente1 = dividendo1 / contador;
dividendo1 = quociente1;
quociente1 = 0;
}
if (dividendo1 % contador == 0)
{
quociente2 = dividendo2 / contador;
dividendo2 = quociente2;
quociente2 = 0;
}
}
}
}
return(oMMC.Valor);
}
public double Cosseno(double anguloEmGraus)
{
double cosseno = 1;
double anguloEmRadianos = (PI * anguloEmGraus) / 180.0; // Converte o valor do angulo em graus para o angulo em Radianos
var umContador1 = new Contador(2, 2 * numeroInteiro, 2);
var umSomador = new Somatoria();
int positivoNegativo = -1;
while (umContador1.Prosseguir())
{
var umContador2 = new Contador(1, umContador1.Valor, 1);
var oFatorial = new Produtorio();
while (umContador2.Prosseguir())
{
oFatorial.Multiplicar(umContador2.Valor);
umContador2.Contar();
}
umSomador.Somar(positivoNegativo * (Pow(anguloEmRadianos, umContador1.Valor) / oFatorial.Valor));
positivoNegativo = positivoNegativo * (-1);
umContador1.Contar();
}
cosseno = cosseno + umSomador.Valor;
return(cosseno);
}
public int MMC(int outroValor)
{
int A = numeroInteiro;
int B = outroValor;
var mmc = new Produtorio();
var divisor = new Contador(2, int.MaxValue, 1);
while (A != 1 || B != 1) // condição para a continuação das sucessivas divisões
{
int quocA = A / divisor.Valor;
int restoA = A - quocA * divisor.Valor;
int quocB = B / divisor.Valor;
int restoB = B - quocB * divisor.Valor;
if (restoA == 0 || restoB == 0)
{
mmc.Multiplicar(divisor.Valor);
}
if (restoA == 0)
{
A = quocA;
}
if (restoB == 0)
{
B = quocB;
}
if (restoA != 0 && restoB != 0)
{
divisor.Contar();
}
}
return((int)mmc.Valor); // retornao valor do MMC
}
