Expoentes são importantes no mundo financeiro, na notação científica e nos campos da epidemiologia e saúde pública. Então, o que eles são e como funcionam?

Expoentes são escritos como (3^2) ou (10^3).

O que acontece, porém, quando você eleva um número à potência (0) assim?

$$10^0 = \text{?}$$

Este artigo vai abordar

• os fundamentos dos expoentes,
• o que eles significam, e
• mostrará que (10^0) é igual a (1) usando expoentes negativos

Tudo o que estou assumindo é que você tem um entendimento de multiplicação e divisão.

Expoentes são compostos de uma base e um expoente (ou potência)

Primeiro, vamos começar com as partes de um expoente.

Há duas partes em um expoente:

• a base
• o expoente ou potência

No início, tínhamos um expoente (3^2). O "3" aqui é a base, enquanto o "2" é o expoente ou potência.

Lemos isso como

Três é elevado à potência de dois.

ou

Três elevado a dois.

Além disso, geralmente, expoentes são escritos como (a^b), onde (a) e (b) podem ser qualquer par de números.

Expoentes são multiplicação para os "preguiçosos"

Agora que entendemos um pouco sobre como falar sobre expoentes, como descobrimos a que número ele equivale?

Usando nosso exemplo acima, podemos escrever e expandir "três elevado a dois" como

$$3^2 = 3 \times 3 = 9$$

O número mais à esquerda no expoente é o número que estamos multiplicando repetidamente. É por isso que você vê vários "3". O número mais à direita no expoente é o número de multiplicações que fazemos. Então, em nosso exemplo, o número 3 (a base) é multiplicado duas vezes (o expoente).

Alguns outros exemplos de expoentes são:

$$10^3 = 10 \times 10 \times 10 = 1000$$

$$2^{10} = 2 \times 2 \times 2 \times 2 \times 2 \times 2 \times 2 \times 2 \times 2 \times 2 = 1024$$

Além disso, em geral, podemos escrever esses expoentes assim:

$$\textcolor{orange}{b}^\textcolor{blue}{n} = \underbrace{\textcolor{orange}{b} \times \dots \times \textcolor{orange}{b}}_{\textcolor{blue}{n} \textrm{ vezes}}$$

onde, a letra b é a base que estamos multiplicando repetidamente e n é a potência ou expoente, que é o número de vezes que estamos multiplicando a base por ela mesma.

Para os exemplos acima, os valores dos expoentes são relativamente pequenos. Você pode imaginar, porém, que se as potências forem muito grandes, torna-se redundante continuar escrevendo os números repetidamente usando sinais de multiplicação.

Em suma, os expoentes ajudam a tornar a escrita dessas longas multiplicações mais eficiente.

Números elevados a zero são iguais a um

Os exemplos anteriores mostram potências maiores que um, mas o que acontece quando é zero?

A resposta rápida é que qualquer número, (b), elevado a zero é igual a um.

$$b^0 = 1$$

Com base em nossas definições anteriores, só precisamos de zero do valor base. Aqui, vamos ter nosso número base como 10.

$$10^0 = ? = 1$$

O que significa, porém, ter um "zero" número de números base? Por que isso acontece?

Podemos descobrir isso dividindo várias vezes para diminuir o valor da potência até chegarmos a zero.

Vamos começar com

$$10^3 = 10 \times 10 \times 10 = 1000$$

Para diminuir as potências, precisamos entender brevemente os conceitos de combinação de expoentes e de potências de um.

Em nossa busca para diminuir o expoente de (10^3) ("dez à terceira potência") para (10^0) ("dez à potência de zero"), continuaremos fazendo o contrário de multiplicar, que é dividir.

$$\frac{10^3}{10} = \frac{10 \times 10 \times 10}{10} = \frac{1000}{10} = 100$$

As partes mais à direita desta equação provavelmente fazem sentido. Como escrevemos, no entanto, os expoentes quando temos (10^3) dividido por (10)?

Como funcionam as potências de um

Primeiro, qualquer expoente com potência de um é igual ao número base.

$$\textcolor{orange}{b^1} = \textcolor{blue}{b}$$

Há somente um valor sendo "multiplicado", então obtemos o valor em si.

Precisamos dessa definição de "potência de um" para que possamos reescrever a fração com expoentes.

$$\frac{10^3}{10} = \frac{10^3}{10^1}$$

Como diminuir expoentes para zero

Como um lembrete, uma maneira de descobrir como (10^0) é igual a 1 é continuar dividindo por 10 até chegarmos a um expoente de zero.

Sabemos pelo lado direito da equação acima que devemos obter 100 de (\frac{10^3}{10^1}).

$$\frac{10^3}{10} = \frac{10^3}{10^1} = \frac{10 \times 10 \times 10}{10^1}$$

Antes de terminarmos de dividir por um 10, podemos multiplicar o topo e o fundo por 1 como marcadores ao cancelar números.

$$\frac{10 \times 10 \times 10}{10^1} = \frac{10 \times 10 \times 10 \times 1}{10^1 \times 1} = \frac{10 \times 10 \times \cancel{10} \times 1}{\cancel{10^1} \times 1} = \frac{10 \times 10 \times 1}{1}$$

$$\frac{10 \times 10 \times 1}{1} = \frac{10 \times 10}{1} = \frac{10^2}{1} = \frac{100}{1}$$

Podemos dividir por 10 mais duas vezes para finalmente chegar a (10^0).

$$\frac{10^2 \times 1}{10 \times 10 \times 1} = \frac{\cancel{10} \times \cancel{10} \times 1}{\cancel{10} \times \cancel{10} \times 1} = \frac{10^0 \times 1}{1} = \frac{1}{1} = 1$$

Por termos dividido por dois 10 quando tínhamos apenas dois 10 no topo da fração, temos zero dezenas no topo. Ter zero dezenas basicamente significa que obtivemos (10^0).

Como funcionam os expoentes negativos

Agora, o (10^0) meio que surge do nada, então vamos explorar isso um pouco mais usando "expoentes negativos".

Em geral, essa divisão repetitiva pela mesma base é o mesmo que multiplicar por "expoentes negativos".

Um expoente negativo é uma maneira de reescrever a divisão.

$$\frac{1}{\textcolor{purple}{b^n}}= \textcolor{green}{b^{-n}}$$

Um expoente negativo pode ser reescrito como uma fração com o denominador (ou a parte inferior de uma fração) com o mesmo expoente, mas com uma potência positiva (o lado esquerdo desta equação).

Agora, usando expoentes negativos, podemos mostrar a divisão anterior de outra maneira.

$$\frac{10^2 \times 1}{10 \times 10 \times 1} = \frac{10^2}{10^2} = 10^2 \times \frac{1}{10^2} = 10^2 \times 10^{-2}$$

Observação: uma regra dos expoentes é que, ao multiplicar expoentes com o mesmo número base (lembre-se, nosso número base aqui é 10), você pode somar os expoentes.

$$10^2 \times 10^{-2} = 10^{2 + (-2)} = 10^{2 - 2} = 10^{0}$$

Juntando tudo

Sabendo disso, podemos combinar cada uma dessas equações acima para resumir nosso resultado.

$$\textcolor{purple}{\frac{10^2}{10^2}} = 10^2 \times 10^{-2} = 10^{2 + (-2)} = 10^{2 - 2} = \textcolor{blue}{10^{0}} \textcolor{orange}{= 1}$$

Sabemos que dividir um número por ele mesmo vai ser igual a um. Mostramos que dividir um número por ele mesmo também é igual a dez elevado a zero. A matemática diz que as coisas que são iguais à mesma coisa também são iguais entre si.

Assim, dez elevado a zero é igual a um. O exercício acima se generaliza para qualquer número base, então qualquer número elevado a zero é igual a um.

Em resumo

Expoentes são maneiras convenientes de fazer multiplicação repetitiva.

Geralmente, os expoentes seguem o padrão abaixo, com algum número base sendo multiplicado repetidamente um número n de vezes.

$$\textcolor{orange}{b}^\textcolor{blue}{n} = \underbrace{\textcolor{orange}{b} \times \dots \times \textcolor{orange}{b}}_{\textcolor{blue}{n} \textrm{ vezes}}$$

Usando expoentes negativos, podemos pegar o que sabemos de multiplicação e divisão (como para a fração 10 sobre 10,(\frac{10}{10})) para mostrar que (b^0) é igual a um para qualquer número (b) (como (10^0 = 1)).

Siga o autor no Twitter e confira seu blog pessoal, onde ele compartilha outros insights e recursos úteis para programação, estatística e aprendizagem de máquina.

Agradecemos pela leitura!

Todos nós amamos computadores. Eles podem fazer muitas coisas incríveis. Em algumas décadas, os computadores revolucionaram completamente quase todos os aspectos da vida humana.

Eles podem realizar tarefas de vários graus de sofisticação, tudo simplesmente invertendo zeros e uns. É notável ver como uma ação tão simples pode levar a tanta complexidade.

Tenho certeza, no entanto, de que todos vocês sabem que tal complexidade não pode ser alcançada (na prática) apenas invertendo os números aleatoriamente. De fato, há algum raciocínio por trás disso. Existem regras que regem a maneira como isso deve ser feito. Neste artigo, discutiremos essas regras e veremos como elas governam a maneira como os computadores "pensam".

O que é a álgebra booleana?

As regras que mencionei acima são descritas por um campo da matemática chamado Álgebra Booleana.

Em seu livro de 1854, o matemático britânico George Boole propôs um conjunto sistemático de regras para a manipulação dos valores de verdade. Essas regras deram uma base matemática para lidar com proposições lógicas. Esses conjuntos de fundamentos levaram ao desenvolvimento da Álgebra Booleana.

Para entender melhor a Álgebra Booleana, primeiro temos que entender as semelhanças e diferenças entre a Álgebra Booleana e outras formas de Álgebra.

A álgebra, em geral, lida com o estudo de símbolos matemáticos e as operações que podem ser realizadas nesses símbolos.

Esses símbolos não têm um significado próprio. Eles representam alguma outra "quantidade". É essa "quantidade" que dá algum valor a esses símbolos e é nessa "quantidade" que as operações estão realmente sendo realizadas.

A Álgebra Booleana também lida com símbolos e com as regras que governam as operações nesses símbolos, mas a diferença está no que esses símbolos representam.

No caso da Álgebra comum, os símbolos representam os números reais, enquanto, na Álgebra Booleana, eles representam os valores de verdade.

A imagem abaixo mostra todo o conjunto de números reais. O conjunto de números reais inclui números naturais (1, 2, 3, 4 ....), números inteiros (todos os números naturais, incluindo o 0 e os negativos: .....-2, -1, 0, 1, 2, 3 ...) e assim por diante. A Álgebra comum lida com todo esse conjunto de números.

Os valores de verdade, em comparação, consistem em um conjunto de apenas dois valores: Falso e Verdadeiro. Aqui, gostaria de salientar o fato de que podemos usar qualquer outro símbolo para representar esses valores.

Por exemplo, em Ciência da Computação, representamos esses valores, em geral, usando 0 e 1. 0 é usado para Falso e 1 para Verdadeiro.

Você também pode fazer isso de maneiras mais sofisticadas, representando valores de verdade com alguns outros símbolos, como Gatos e Cães ou Bananas e Laranjas.

O ponto aqui é que o significado interno desses símbolos permanecerá o mesmo, independentemente do símbolo que você usar. Certifique-se, porém, de não alterar os símbolos durante a execução das operações.

Agora a questão é que se verdadeiro, falso, 0 e 1 são apenas as representações, o que exatamente eles estão tentando representar?

O significado subjacente por trás dos valores de verdade vem do campo da Lógica, onde os valores de verdade são usados para dizer se uma proposição é "Verdadeira" ou "Falsa". Aqui, os valores de verdade representam a relação de uma proposição com a verdade, isto é, se a proposição é verdadeira ou falsa.

Uma proposição é apenas uma declaração como: "Todos os gatos são fofos".

Se a proposição acima for verdadeira, atribuímos a ela o valor de verdade de "Verdadeiro" ou "1". Caso contrário, atribuímos a ela "Falso" ou "0".

Na eletrônica digital, os valores de verdade são usados para representar os estados "Ligado" e "Desligado" dos circuitos eletrônicos. Discutiremos mais sobre isso mais adiante neste artigo.

Operações booleanas e as tabelas verdade

Da mesma forma que na Álgebra comum, a Álgebra Booleana também possui operações que podem ser aplicadas aos valores para obter alguns resultados. Essas operações, contudo, não são semelhantes às da álgebra como porque, como discutimos anteriormente, a álgebra booleana funciona com valores de verdade em vez de números reais.

A álgebra booleana tem três operações básicas.

OR (em português, OU): também conhecida como Disjunção. Essa operação é executada com duas variáveis booleanas. A saída da operação OR será 0 quando os dois operandos forem 0. Caso contrário, será 1.

Para obter uma imagem mais clara do que essa operação faz, podemos visualizá-la com a ajuda de uma Tabela Verdade abaixo.

Tabelas verdade nos dão uma representação interessante do que fazem as operações booleanas, além de servirem como uma ferramenta útil para realizar as operações booleanas.

		Operação OR

Variável 1	Variável 2	Resultado
  0		0		0
  0		1		1
  1		0		1
  1		1		1

AND (em português, E): também conhecida como Conjunção. Essa operação é executada com duas variáveis booleanas. A saída das operações AND será 1 quando os dois operandos forem 1. Caso contrário, será 0. A representação da tabela verdade é a seguinte.

		Operação AND

Variável 1	Variável 2	Resultado
  0		0		0
  0		1		0
  1		0		0
  1		1		1

NOT (em português, NÃO): também conhecida como Negação. Essa operação é executada apenas com uma variável. Se o valor da variável for 1, a operação simplesmente converte o valor em 0 e, se o valor da variável for 0, ela converte o valor em 1.

	Operação NOT

Variável 1	Resultado
  0		1	
  1		0			

Álgebra booleana e os circuitos digitais

Após seu desenvolvimento inicial, a Álgebra Booleana, por muito tempo, permaneceu um daqueles conceitos em Matemática que não teve uma aplicação prática significativa.

Na década de 1930, Claude Shannon, um matemático americano, percebeu que a Álgebra Booleana poderia ser usada em circuitos onde as variáveis binárias  (0 e 1) poderiam representar os sinais de tensão "baixa" e "alta" ou os estados "ligado" e "desligado".

Essa ideia simples de fazer circuitos com a ajuda da Álgebra Booleana levou ao desenvolvimento da Eletrônica Digital, que contribuiu fortemente para o desenvolvimento de circuitos para computadores.

Os circuitos digitais implementam Álgebra Booleana com a ajuda de Portas Lógicas. Portas lógicas são os circuitos que representam uma operação booleana. Por exemplo, uma porta OR representará uma operação OR. Isso também vale para os portões NOT e AND.

Juntamente com as portas lógicas básicas, também temos portas lógicas que podem ser criadas usando a combinação das portas lógicas básicas.

NAND (em português, NÃO E): a porta NAND é formada pela combinação das portas NOT e AND. A porta NAND tem como resultado 0 se as duas entradas forem 1. Caso contrário, seu valor é 1.

A porta NAND tem a propriedade da Completude Funcional, o que significa que qualquer função booleana pode ser implementada simplesmente utilizando apenas uma combinação de portas NAND.

		Porta NAND

Variável 1	Variável 2	Resultado
  0		0		1
  0		1		1
  1		0		1
  1		1		0

NOR (em português, NÃO OU): a porta NOR é formada por uma combinação das portas NOT e OR. A porta NOR tem o resultado de 1 se as duas entradas forem 0. Caso contrário, seu valor é 0.

A porta NOR, Assim como a porta NAND, tem a propriedade da Completude Funcional (ver acima), o que significa que qualquer função booleana pode ser implementada simplesmente utilizando apenas uma combinação de portas NOR.

		Porta NOR

Variável 1	Variável 2	Resultado
  0		0		1
  0		1		0
  1		0		0
  1		1		0

A maioria dos circuitos digitais é construída usando portas NAND ou NOR devido à sua propriedade de completude funcional e também porque são fáceis de fabricar.

Além das portas mencionadas acima, também temos alguns tipos especiais de portas que servem a um propósito específico. São elas:

XOR (em português, OU EXCLUSIVO): a porta XOR, ou "eXclusive-OR", é um tipo especial de porta lógica que retorna 0 como resultado se as duas entradas forem 0 ou 1. Caso contrário, ela retorna 1.

		Porta XOR

Variável 1	Variável 2	Resultado
  0		0		0
  0		1		1
  1		0		1
  1		1		0

XNOR (em português, NÃO OU EXCLUSIVO): a porta XNOR, ou "eXclusive-NOR", é um tipo especial de porta lógica que retorna 1 como resultado se as duas entradas forem 0 ou 1. Caso contrário, ela retorna 0.

		Porta XNOR

Variável 1	Variável 2	Resultado
  0		0		1
  0		1		0
  1		0		0
  1		1		1

Conclusão

Com isso, podemos agora concluir nossa discussão sobre Álgebra Booleana. Espero que, agora, você tenha uma imagem clara do que a Álgebra Booleana é.

Isso definitivamente não é tudo que você precisa saber sobre Álgebra Booleana. A Álgebra Booleana tem muitos conceitos e detalhes que não pudemos discutir neste artigo.

O método de Euler é um procedimento numérico de primeira ordem para resolver equações diferenciais ordinárias (EDO ou, em inglês, ODE – ordinary differential equations) com um valor inicial fornecido.

O problema do valor inicial geral

Metodologia

O método de Euler usa a fórmula simples,

para construir a tangente no ponto x e obter o valor de y(x+h), cuja inclinação é

No método de Euler, você pode aproximar a curva da solução pela tangente em cada intervalo (ou seja, por uma sequência de segmentos de linha curtos), em passos de h.

Em geral, se você usar um tamanho de passo menor, a precisão da aproximação aumenta.

Fórmula geral

onde:

• y1+1 é o próximo valor de solução estimado;
• y1 é o valor atual;
• h é o intervalo entre os passos;
• f(x1, y1) é o valor da derivada no ponto atual (x1, y1).

Valor da função em qualquer ponto b, dado por y(b)

onde:

• n = número de passos
• h = largura do intervalo (tamanho de cada passo)

Pseudocódigo

1. defina f(x, y)
2. insira x0, y0
3. insira h, n
4. para j de 0 a (n-1), faça

• yj+1 = yj + hf(xj, yj)
• xj+1 = xj + h
• imprima xj + 1 e yj + 1

5. fim

Exemplo

Encontre y(1), dado que

Resolvendo analiticamente, a solução é y = e^x e y(1)= 2.71828. (Observação: essa solução analítica é apenas para comparar a precisão.)

Usando o método de Euler, considerando que h = 0.2, 0.1, 0.01, você pode ver os resultados no diagrama abaixo.

Quando h = 0.2, y(1) = 2.48832 (erro = 8.46 %)

Quando h = 0.1, y(1) = 2.59374 (erro = 4.58 %)

Quando h = 0.01, y(1) = 2.70481 (erro = 0.50 %)

Como é possível observar, a precisão aumenta quando os passos são menores.

Escrito por: Moshe Binieli

Introdução

Este artigo tratará do método estatístico do erro quadrático médio. Nele, descreverei a relação deste método com a linha de regressão.

O exemplo consiste em pontos sobre o eixo cartesiano. Vamos definir uma função matemática que nos dará a linha reta que melhor passa entre todos os pontos do eixo cartesiano.

Desse modo, aprenderemos a conexão entre esses dois métodos e qual a aparência do resultado de sua conexão.

Explicação geral

Esta é a definição da Wikipédia:

Em estatística, o erro quadrático médio (MSE - Mean Squared Error) de um estimador (de um procedimento para estimar uma quantidade não observada) mede a média dos quadrados dos erros - ou seja, a diferença quadrática média entre os valores estimados e o que é estimado. O MSE é uma função de risco, correspondendo ao valor esperado da perda do erro quadrático. O fato do MSE ser quase sempre estritamente positivo (e diferente de zero) é devido à aleatoriedade ou porque o estimador não dá conta das informações que poderiam produzir uma estimativa mais precisa.

A estrutura do artigo

• Saiba qual é a ideia, veja a visualização gráfica e conheça a equação do erro quadrático médio.
• A parte matemática contém as manipulações algébricas e uma derivada de duas funções variáveis para encontrar um mínimo. Esta seção é para aqueles que querem entender como obtemos as fórmulas matemáticas mais tarde. Você pode ignorá-la se isso não for do seu interesse.
• Uma explicação das fórmulas matemáticas que recebemos e o papel de cada variável na fórmula.
• Exemplos

Saiba qual é a ideia

Digamos que temos sete pontos e que nosso objetivo é encontrar uma linha que minimize as distâncias quadráticas para esses pontos diferentes.

Vamos tentar entender isso.

Vou pegar um exemplo e desenharei uma linha entre os pontos. É claro que meu desenho não é o melhor, mas é apenas para fins de demonstração.

Você pode estar se perguntando: o que é esse gráfico?

• os pontos roxos são os pontos do gráfico. Cada ponto tem uma coordenada x e uma coordenada y.
• A linha azul é a nossa linha de previsão. Essa é uma linha que passa por todos os pontos e os ajusta da melhor maneira possível. Essa linha contém os pontos previstos.
• A linha vermelha entre cada ponto roxo e a linha de previsão são os erros. Cada erro é a distância entre o ponto e o seu ponto previsto.

Você deve se lembrar dessa equação de seus dias de escola, y=Mx+B, onde M é a declive da linha e B é o ponto em que a linha intercepta o eixo y (texto em inglês).

Queremos encontrar M (o declive) e B (o ponto de interceptação de y) que minimizam o erro quadrático!

Vamos definir uma equação matemática que nos dará o erro quadrático médio para todos os nossos pontos.

Vamos analisar o que essa equação realmente significa.

• Em matemática, o personagem que parece um E estranho (o sigma, em grego) é chamado de somatório. É a soma de uma sequência de números, de i=1 até i=n. Vamos imaginar isso como um array de pontos, onde passamos por todos os pontos, do primeiro (i=1) ao último (i=n).
• Para cada ponto, tomamos a coordenada y do ponto e a coordenada y' do ponto. A coordenada y é o nosso ponto roxo. O ponto y' está na linha que nós criamos. Subtraímos o valor da coordenada y do valor da coordenada y' e calculamos o quadrado do resultado.
• A terceira parte é pegar a soma de todos os valores (y-y')² e dividi-la por n, o que dará a média.

Nosso objetivo é minimizar esta média, o que nos proporcionará a melhor linha que passa por todos os pontos.

Do conceito às equações matemáticas

Esta parte é para as pessoas que querem entender como chegamos às equações matemáticas. Você pode pular para a próxima parte, se quiser.

Como você sabe, a equação da linha é y=mx+b, onde m é o declive e b é o ponto onde a linha intercepta o eixo y (texto em inglês).

Vamos pegar cada ponto no gráfico e faremos no cálculo de (y-y')². O que é, no entanto, y', e como nós o calculamos? Não temos esse valor como parte dos dados.

Sabemos, contudo, que, para calcular y', precisamos usar nossa equação de linha, y=mx+b, e colocar o x na equação.

A partir daqui, obtemos a seguinte equação:

Vamos reescrever esta expressão para simplificá-la.

Vamos começar abrindo todos os parênteses da equação. Eu colori a diferença entre as equações para facilitar a compreensão.

Agora, vamos aplicar outra manipulação. Pegaremos cada parte e a colocaremos em conjunto. Pegaremos todos os y, (-2ymx) e assim por diante e os colocaremos todos lado a lado.

Nesse ponto, estamos começando a ficar confusos. Então, vamos pegar a média de todos os valores quadrados para y, xy, x, x².

Vamos definir, para cada um desses valores, um novo personagem que representará a média de todos os valores quadráticos.

Vejamos um exemplo, vamos pegar todos os valores y e dividi-los por n, já que é a média, e chamar esse valor de de y(ao quadrado e com a linha sobrescrita).

Se multiplicarmos ambos os lados da equação por n, obtemos:

O que nos levará à seguinte equação:

Se olharmos para o que temos, podemos ver que temos uma superfície 3D. Parece um vidro, que se eleva acentuadamente para cima.

Queremos encontrar M e B que minimizem a função. Faremos uma derivada parcial com respeito à M e uma derivada parcial com respeito à B.

Como estamos procurando um ponto mínimo, pegaremos as derivadas parciais e compararemos com 0.

Vamos pegar as duas equações que recebemos, isolando a variável b de ambas, e depois subtraindo a equação superior da equação inferior.

Vamos subtrair a primeira equação da segunda equação

Vamos nos livrar dos denominadores da equação.

Pronto. Esta é a equação para encontrar M. Vamos pegar isso e escrever a equação B.

Equações para declive e interceptação de y

Vamos fornecer as equações matemáticas que nos ajudarão a encontrar o declive e a interceptação em y (texto em inglês) necessários.

Você, provavelmente, deve estar pensando: que raios são essas equações estranhas?

Elas são realmente simples de entender. Vamos falar um pouco sobre elas.

Agora que entendemos nossas equações, é hora de juntar tudo e mostrar alguns exemplos.

Exemplos

Um grande agradecimento à Khan Academy pelos exemplos.

Exemplo nº 1

Vamos pegar 3 pontos, (1,2), (2,1), (4,3).

Vamos encontrar M e B para a equação y=mx+b.

Depois de termos calculado as partes relevantes para nossa equação de M e para a equação de B, vamos colocar esses valores dentro das equações e obter o declive e o ponto de interceptação do eixo y (texto em inglês).

Vamos pegar esses resultados e colocá-los dentro da equação da linha y=mx+b.

Agora, vamos desenhar a linha e ver como ela passa através das linhas de tal forma que minimize as distâncias quadráticas.

Exemplo nº 2

Vamos pegar 4 pontos, (-2,-3), (-1,-1), (1,2), (4,3).

Vamos encontrar M e B para a equação y=mx+b.

Fazemos o mesmo que fizemos antes. Vamos colocar esses valores dentro das nossas equações para encontrar M e B.

Vamos pegar esses resultados e colocá-los dentro da equação da linha y=mx+b.

Agora, vamos desenhar a linha e ver como a linha passa através das linhas de tal forma que minimize as distâncias quadráticas.

Em conclusão

Como você pode ver, toda a ideia é simples. Precisamos apenas entender as partes principais e como trabalhamos com elas.

Você pode trabalhar com as fórmulas para encontrar a linha em outro gráfico e fazer um cálculo simples e obter os resultados para o declive e o ponto de interceptação de y (texto em inglês).

Isso é tudo. Simples, não?

Todo comentário e todo feedback é bem-vindo – se for necessário, o autor ajustará o artigo. Fique à vontade para entrar em contato diretamente com o autor pelo LinkedIn.

As pessoas usam números aleatórios há milênios. Portanto, o conceito não é novo. Desde a loteria na antiga Babilônia, passando pelas mesas de roleta em Monte Carlo até os jogos de dados em Las Vegas, o objetivo é deixar o resultado final nas mãos de uma chance aleatória.

Jogos de azar à parte, a aleatoriedade tem muitos usos na ciência, estatística, criptografia e muito mais. No entanto, o uso de dados, moedas ou meios similares como um dispositivo para produzir a aleatoriedade tem suas limitações.

Por causa da natureza mecânica destas técnicas, gerar grandes quantidades de números aleatórios requer muito tempo e trabalho. Graças à engenhosidade humana, temos ferramentas e métodos mais poderosos à nossa disposição.

Métodos para a geração de números aleatórios

Números verdadeiramente aleatórios

Vamos considerar dois métodos principais usados para gerar números aleatórios. O primeiro método é baseado em um processo físico e colhe a fonte da aleatoriedade de algum fenômeno físico que se espera que seja aleatório.

Tal fenômeno se dá fora do computador. Ele é medido e ajustado para possíveis enviesamentos devido ao processo de medição. Exemplos incluem a decadência radioativa, o efeito fotoelétrico, a radiação cósmica de fundo, o ruído atmosférico (que usaremos neste artigo) e muitos outros.

Assim, os números aleatórios gerados com base nessa aleatoriedade são considerados números aleatórios "verdadeiros".

Tecnicamente, a parte de hardware consiste em um dispositivo que converte energia de uma forma para outra (por exemplo, radiação para um sinal elétrico), um amplificador e um conversor analógico-digital para transformar a saída em um número digital.

O que são números pseudoaleatórios?

Como alternativa aos números aleatórios "verdadeiros", o segundo método de geração de números aleatórios envolve algoritmos computacionais que podem produzir resultados aparentemente aleatórios.

Por que aparentemente aleatórios? Porque os resultados finais obtidos são, de fato, completamente determinados por um valor inicial também conhecido como o valor de seed ou key. Portanto, se você souber o valor de chave (key) e como o algoritmo funciona, poderá reproduzir esses resultados aparentemente aleatórios.

Geradores de números aleatórios deste tipo são frequentemente chamados de geradores de números pseudoaleatórios e, como resultado, a saída deles são os números pseudoaleatórios.

Mesmo que este tipo de gerador, normalmente, não reúna nenhum dado de fontes de aleatoriedade natural, essa coleta de chaves pode ser possível quando necessário.

Vamos comparar alguns aspectos dos verdadeiros geradores de números aleatórios (ou TRNGs) e dos geradores de números pseudoaleatórios (ou PRNGs).

Os PRNGs são mais rápidos do que os TRNGs. Devido à sua natureza determinista, eles são úteis quando você precisa repetir uma sequência de eventos aleatórios. Isto ajuda muito nos testes de código, por exemplo.

Por outro lado, os TRNGs não são periódicos e funcionam melhor em funções sensíveis de segurança, como a criptografia.

Um período é o número de iterações que um PRNG passa antes de começar a se repetir. Assim, sendo todas as outras coisas iguais, um PRNG com um período mais longo levaria mais recursos computacionais para ser previsto e decifrado.

Exemplo de algoritmo para o gerador de números pseudoaleatórios

Um computador executa um código que é baseado em um conjunto de regras a serem seguidas. Para PRNGs em geral, essas regras giram em torno do seguinte:

1. Aceitar algum número de entrada inicial, ou seja, uma seed ou key.
2. Aplicar essa seed em uma sequência de operações matemáticas para gerar o resultado. Esse resultado é o número aleatório.
3. Usar esse número aleatório resultante como seed para a próxima iteração.
4. Repetir o processo para emular a aleatoriedade.

Vejamos um exemplo.

O gerador linear congruencial

Esse gerador produz uma série de números pseudoaleatórios. Dada uma seed inicial X₀ e parâmetros inteiros a como multiplicador, b como incremento, e m como módulo, o gerador é definido pela relação linear: Xn ≡ (aXn-1 + b)mod m. Ou, usando uma sintaxe mais amigável da programação: Xn = (a * Xn-1 + b) % m.

Cada um desses membros tem que satisfazer as seguintes condições:

• m > 0 (o módulo é positivo),
• 0 < a < m (o multiplicador é positivo, mas menor do que o módulo),
• 0 ≤ b < m (o incremento não é negativo, mas menor do que o módulo), e
• 0 ≤ X₀ < m (a seed não é negativa, mas é menor que o módulo).

Vamos criar uma função em JavaScript que tome os valores iniciais como argumentos e retorne um array de números aleatórios de um determinado comprimento:

    // x0=seed; a=miltiplicador; b=incremento; m=módulo; n=tamanho do array desejado; 
	const linearRandomGenerator = (x0, a, b, m, n) => {
        const results = []
        for (let i = 0; i < n; i++) {
        	x0 = (a * x0 + b) % m
            results.push(x0)
        }
        return results
    }
	

O gerador linear congruencial é um dos mais antigos e mais conhecidos algoritmos PRNG.

Quanto aos algoritmos geradores de números aleatórios que são executáveis por computadores, eles datam dos anos 40 e 50 (o método do quadrado do meio e o gerador de Lehmer, por exemplo – textos explicativos em inglês) e continuam a ser escritos hoje (Xoroshiro128+, Squares RNG e mais – textos explicativos em inglês).

Um gerador de números aleatórios de amostra

Quando decidi escrever este artigo sobre a incorporação de um gerador de números aleatórios em uma página da web, tive que fazer uma escolha.

Eu poderia ter usado a função Math.random() do JavaScript como base e gerar a saída em números pseudoaleatórios como já fiz em artigos anteriores (veja Multiplication Chart - Code Your Own Times Table – texto em inglês).

Este artigo, no entanto, é sobre a geração de números aleatórios. Portanto, decidi aprender a reunir dados "verdadeiros" baseados na aleatoriedade e compartilhar a minha descoberta com vocês.

Assim, abaixo vemos um gerador de números aleatórios "verdadeiros". Defina os parâmetros e pressione Generate (em português, Gerar).

O código busca dados de uma das APIs, cortesia da Random.org. Este recurso on-line tem uma infinidade de ferramentas úteis e customizáveis e vem com excelente documentação para acompanhá-lo.

A aleatoriedade vem do ruído atmosférico. Consegui usar funções assíncronas. Isso é um enorme benefício para o futuro. A função principal se parece com isto:

    // Gera um número aleatório dentro do intervalo indicado pelo usuário
   	const getRandom = async (min, max, base) => {
   		const response = await 	fetch("https://www.random.org/integers/?num=1&min="+min+"
    &max="+max+"&col=1&base="+base+"&format=plain&rnd=new")
          	return response.text() 
   	} 

Os parâmetros necessários permitem que um usuário personalize a saída de números aleatórios. Por exemplo, min e max permitem definir limites inferiores e superiores na saída gerada. A base determina se a saída é impressa como binária, decimal ou hexadecimal.

Novamente, escolhi esta configuração, mas há muitas mais disponíveis na fonte.

Ao clicar no botão Generate, a função handleGenerate() é chamada. Ela, por sua vez, invoca a função assíncrona getRandom(), gerencia o tratamento de erros e os resultados das saídas:

    // Tratamento do resultado
    const handleGenerate = () => {
    	handleActive(generateButton)
        const base = binary.checked ? 2 : decimal.checked ? 10 : 16
        if (!minimum.value || !maximum.value) {
            prompter.style.color = 'red' 
        	prompter.textContent = "Enter Min & Max values"
        } else {
        	getRandom(minimum.value, maximum.value, base).then((data) => {
        		resultValue.textContent = data
        		prompter.textContent = ""    
        	}).catch((error) => {
        		resultValue.textContent = 'ERROR'
        		prompter.textContent = 'Connection error. Unable to 						generate';    
        	})
       		 handleRestart()
        }
        
   }

O restante do código trata da estrutura do HTML, da aparência e do estilo.

O código está pronto para ser incorporado e utilizado dentro da página da web. Eu o separei em partes componentes e o forneci com comentários detalhados. Ele pode ser facilmente modificado. Você também pode modificar a funcionalidade e os estilos conforme suas necessidades.

Abaixo temos o link para o repositório no GitHub com o código completo: https://github.com/sandroarobeli/random-generator

A regra de Simpson é um método para a integração numérica. Em outras palavras, ela é a aproximação numérica de integrais definidas.

A regra de Simpson é a seguinte:

Nela,

• f(x) é chamado de integrando
• a = limite inferior da integração
• b = limite superior da integração

Regra 1/3 de Simpson

Como mostra o gráfico acima, o integrando f(x) é aproximado por um polinômio de segunda ordem; o interpolador quadrático é P(x).

Temos a aproximação conforme segue:

Substituindo (b-a)/2 por h, temos:

Como se pode ver, existe um fator de 1/3 na expressão acima. É por isso que ela é chamada de Regra 1/3 de Simpson.

Se uma função oscilar excessivamente e não tiver derivadas em determinados pontos, a regra acima pode não produzir resultados precisos.

Uma maneira comum de se lidar com isso é usar a abordagem composta da regra de Simpson. Para fazer isso, divida [a,b] em subintervalos menores, aplicando a regra de Simpson a cada subintervalo. Em seguida, some os resultados de cada cálculo para produzir uma aproximação da integral inteira.

Se o intervalo [a,b] for dividido em n subintervalos, e se n for um número par, a regra composta de Simpson é calculada com a seguinte fórmula:

onde x_j = a+jh para j = 0,1,…,n-1,n com h=(b-a)/n; especificamente, x₀ = a e x_n = b.

Exemplo em C++:

Para aproximar o valor da integral fornecida abaixo, onde n = 8:

#include<iostream>
#include<cmath>
using namespace std;

float f(float x)
{
	return x*sin(x);	//Defina a função f(x)
}

float simpson(float a, float b, int n)
{
	float h, x[n+1], sum = 0;
	int j;
	h = (b-a)/n;
	
	x[0] = a;
	
	for(j=1; j<=n; j++)
	{
		x[j] = a + h*j;
	}
	
	for(j=1; j<=n/2; j++)
	{
		sum += f(x[2*j - 2]) + 4*f(x[2*j - 1]) + f(x[2*j]);
	}
	
	return sum*h/3;
}

int main()
{
	float a,b,n;
	a = 1;		//Insira o limite inferior a
	b = 4;		//Insira o limite superior b
	n = 8;		//Insira o comprimento do passo n
	if (n%2 == 0)
		cout<<simpson(a,b,n)<<endl;
	else
		cout<<"n deve ser um número par";
	return 0;
}

Regra 3/8 de Simpson

A regra 3/8 de Simpson é semelhante à regra 1/3 de Simpson. A única diferença está no fato de que, para a regra 3/8, o interpolador é um polinômio cúbico. Embora a regra 3/8 use mais um valor de função, ela é duas vezes mais precisa que a regra 1/3.

A regra 3/8 de Simpson determina que:

Substituindo (b-a)/3 por h, temos:

A regra 3/8 de Simpson para n intervalos (onde n deve ser um múltiplo de 3):

onde x_j = a+jh para j = 0,1,…,n-1,n com h=(b-a)/n; especificamente, x₀ = a e x_n = b.

Números aleatórios gerados por computador entram em duas categorias possíveis: números verdadeiramente aleatórios e pseudoaleatórios.

Os números verdadeiramente aleatórios são gerados com base em fatores externos. Por exemplo, gerar aleatoriedade usando ruídos circundantes.

Porém, gerar números verdadeiramente aleatórios assim é uma tarefa que leva tempo. Por isso, podemos utilizar números pseudoaleatórios, que são gerados usando um algoritmo e um valor de seed.

Esses números pseudoaleatórios são o bastante para a maioria dos fins. Por exemplo, você pode usá-los em criptografia, na criação de jogos, como jogos de dados ou de cartas, bem como na geração de números de OTPs (em inglês, one-time passwords ou senhas de uso único).

Neste artigo, aprenderemos como gerar números pseudoaleatórios usando Math.random() em Java.

1. Usar Math.random() para gerar números inteiros

Math.random() retorna um número pseudoaleatório do tipo double, maior que ou igual a zero e inferior a um.

Vamos experimentar usando código:

    public static void main(String[] args) {
        double randomNumber = Math.random();
        System.out.println(randomNumber);
    }
    // resultado nº1 = 0.5600740702032417
    // resultado nº2 = 0.04906751303932033

randomNumber nos dará um número aleatório diferente para cada execução.

Digamos que nossa ideia é gerar números aleatórios dentro de um intervalo específico –  por exemplo, de zero a quatro.

    // gerar números aleatórios entre 0 e 4
    public static void main(String[] args) {
        // Math.random() gera um número aleatório entre 0.0 e 0.999
        // Assim, Math.random()*5 estará entre 0.0 e 4.999
        double doubleRandomNumber = Math.random() * 5;
        System.out.println("doubleRandomNumber = " + doubleRandomNumber);
        // fazer o casting do número para um número inteiro
        int randomNumber = (int)doubleRandomNumber;
        System.out.println("randomNumber = " + randomNumber);
    }
    /* Resultado nº1
    doubleRandomNumber = 2.431392914284627
    randomNumber = 2
    */

Quando fazemos o casting de um double para um int, o valor de int mantém apenas a parte inteira do número.

Por exemplo, no código acima, doubleRandomNumber é 2.431392914284627 . A parte inteira de doubleRandomNumber é 2 e a parte fracionária (números após a casa decimal) é 431392914284627 . Assim, randomNumber guardará apenas a parte inteira do número, 2.

Você pode ler mais sobre o método Math.random() na documentação do Java (em inglês).

Usar Math.random() não é a única forma de gerar números aleatórios em Java. A seguir, veremos como gerar números aleatórios usando a classe Random.

2. Usar a classe Random para gerar números inteiros

Na classe Random, temos muitos métodos de instância que fornecem números aleatórios. Nesta seção, trataremos de dois métodos de instância, nextInt(int bound) e nextDouble().

Como usar o método nextInt(int bound)

nextInt(int bound) retorna um número pseudoaleatório do tipo int, maior que ou igual a zero e menos que o valor de bound.

O parâmetro bound especifica o intervalo. Por exemplo, se especificarmos que bound (limite, em inglês) é 4, nextInt(4) retornará um valor do tipo int, maior que ou igual a zero e menor que quatro. 0,1,2,3 são os resultados possíveis de nextInt(4) .

Como esse é um método de instância, devemos criar um objeto da classe Random para acessá-lo. Vamos praticar.

    public static void main(String[] args) {
        // criar um objeto da classe Random
        Random random = new Random();
        // gerar um número aleatório de 0 a 3
        int number = random.nextInt(4);
        System.out.println(number);
    }

Como usar o método nextDouble()

Do mesmo modo que em Math.random(), nextDouble() retorna um número pseudoaleatório do tipo double, maior que ou igual a zero e menor que um.

    public static void main(String[] args) {
        // criar um objeto da classe Random
        Random random = new Random();
        // gerar um número aleatório de 0.0 até 0.99...
        double number = random.nextDouble();
        System.out.println(number);
    }

Para mais informações, é possível ler sobre a classe Random na documentação do Java (em inglês).

Que método para gerar números aleatórios devemos usar?

Math.random() usa a classe Random. Se queremos apenas números do tipo double em nossa aplicação, então podemos usar Math.random().

Do contrário, podemos usar a classe Random, já que ela fornece vários métodos para gerar números pseudoaleatórios de tipos diferentes, como nextInt(), nextLong(), nextFloat() e nextDouble().

Obrigado pela leitura.

A imagem da capa é de Brett Jordan e obtida no Unsplash

Você também pode se comunicar com o autor pelo Medium.

Feliz programação!

Às vezes, em situações do cotidiano, em que podemos ter de realizar a tarefa de encontrar a raiz quadrada de um número. E se não tivéssemos uma calculadora ou um smartphone à disposição? Poderíamos usar os bons e velhos lápis e papel para fazer isso ao estilo de uma divisão longa?

Sim, podemos. E existem diversos métodos. Alguns deles são mais complexos que outros. Outros fornecem resultados mais precisos.

O método que desejo compartilhar com vocês é um deles. Para tornar esse artigo mais amigável, cada etapa virá com ilustrações.

PASSO 1: Separar os algarismos em pares

Para começar, vamos organizar nosso espaço de trabalho. Dividiremos o espaço em três partes. Em seguida, vamos separar os algarismos do número em pares, indo da direita para a esquerda.

Por exemplo, o número 7.469,17 vira 74  69.  17. Ou, no caso de um número com uma quantidade ímpar de algarismos, como 19.036, começaremos com 1  90  36.

Em nosso caso, 2.025 vira 20  25.

PASSO 2: Encontre o maior número inteiro

Como próximo passo, precisamos encontrar o maior número inteiro (i) cujo quadrado seja inferior ou igual ao número mais à esquerda.

Em nosso exemplo, o número mais à esquerda é 20. Como 4² = 16 <= 20 e 5² = 25 > 20, o número inteiro em questão é o 4. Vamos depositar o 4 no canto superior direito e 4² = 16 no canto inferior direito.

PASSO 3: Agora, subtraímos esse número inteiro

Agora, precisamos subtrair o quadrado daquele número inteiro (igual a 16) do número mais à esquerda (20). O resultado é igual a 4 e escreveremos isso como mostrado acima.

PASSO 4: Passemos para o próximo par

Passemos para baixo o próximo par do nosso número (ou seja, 25). Escrevemos esse número ao lado do valor subtraído que já está lá (o 4).

Agora, multiplicamos o número no canto superior direito (que também é 4) por 2. O resultado é 8. Podemos escrever esse número no canto inferior direito, seguido de _ x _ =

PASSO 5: Encontrando o par perfeito

Hora de preencher cada espaço em branco com o mesmo número inteiro (i). Ele deve ser o maior número inteiro possível que permita que o produto seja inferior ou igual ao número da esquerda.

Por exemplo, se escolhermos o número 6, o primeiro número se torna 86 (8 e 6) e devemos multiplicá-lo também por 6. O resultado é 516 e maior do que 425. Um número abaixo e tentamos o 5. O número 8 e o número 5 nos dão 85. 85 vezes 5 resulta em 425, que é exatamente o número de que precisamos.

Escreva 5 ao lado do 4 no canto superior direito. É o segundo algarismo na raiz.

PASSO 6: Subtraímos novamente

Subtraia o produto que calculamos (425) do número que temos à esquerda no momento (que também é 425). O resultado é zero, o que significa que a tarefa está completa.

Observação: escolhi um quadrado perfeito (2025 = 45 x 45) de propósito. Dessa forma, pude mostrar as regras para a solução de problemas de raiz quadrada.

De fato, números consistem em vários algarismos, incluindo aqueles após a vírgula. Neste caso, repetimos os passos 4, 5 e 6 até chegarmos à precisão que buscamos.

No próximo exemplo, você verá o que eu quero dizer.

EXEMPLO: Vamos mais longe...

Desta vez, o número consiste em um número ímpar de algarismos, incluindo aqueles após a vírgula.

Como vemos nesse exemplo, o processo pode se repetir varias vezes até chegar ao nível desejado de precisão.