Melhor resposta
1º Método
= UNICHAR (8730) fornece o símbolo de raiz quadrada no Microsoft Excel.
Testado no Excel 2016
2º método
- Vá para Guia Inserir e clique no Símbolo do grupo Símbolos.
- Em Símbolos, selecione Operadores matemáticos do subconjunto e use o símbolo de raiz quadrada.
Resposta
A maioria das CPUs modernas fornece uma operação de raiz quadrada nativamente. Portanto, com uma linguagem de programação típica em um hardware moderno típico, é quase certo que a operação será no final das contas.
Então, vamos falar sobre o método que quase todas as CPUs modernas de uso geral usam.
Representação numérica
A primeira coisa que precisamos entender é como um computador realmente representa o tipo de números de que estamos falando. Eles são armazenados em um tipo de notação científica.
Agora, o tipo de notação científica com o qual você pode estar familiarizado, onde um número como -134,5 é representado como -1,345 \ vezes 10 ^ {2}.
Qualquer número que não seja zero pode ser representado nesta forma, que conceitualmente tem três partes: o sinal (isto é, é o número positivo ou negativo), a mantissa (um número entre 1 e 10, incluindo 1, mas não incluindo 10, neste caso 1,345) e a expoente (a potência à qual a raiz é elevada, neste caso 2; observe que o expoente pode ser negativo ou zero em geral).
A representação que quase todos os computadores modernos usam é muito semelhante, exceto que o número é armazenado usando uma representação binária em vez de decimal. Portanto, ignorando o bit de sinal e zero (uma vez que encontrar a raiz quadrada de zero é trivial, e a raiz quadrada de um número negativo não é um número real), os números positivos são armazenados na forma m \ vezes 2 ^ {e} onde m é um número entre 1 e 2 (incluindo 1, mas não incluindo 2).
Esta representação é referida como “ponto flutuante”, devido à maneira como você pode mover o ponto binário (análogo ao ponto decimal com o qual você pode estar familiarizado) ajustando o expoente.
A razão pela qual tudo isso é importante é porque a CPU usa a representação para ajudar a calcular as raízes quadradas. Suponha que o expoente seja par. Então:
\ sqrt {m \ times 2 ^ {2 \ epsilon}} = \ sqrt {m} \ times 2 ^ {\ epsilon}
Da mesma forma, se o expoente for ímpar, então:
\ sqrt {m \ times 2 ^ {2 \ epsilon + 1}} = \ sqrt {2} \ sqrt {m} \ times 2 ^ {\ epsilon}
Lembre-se de que m está no intervalo [1,2). Isso significa que reduzimos o problema de calcular a raiz quadrada de qualquer número a um de calcular a raiz quadrada de um número nesse intervalo. Ou, se não quisermos pré-calcular \ sqrt {2}, um número no intervalo [1,4). De qualquer forma, simplificamos drasticamente o problema, porque agora podemos usar métodos que se comportam bem nessa faixa de números.
Multiplicação e divisão
Agora que chegamos até aqui, você pode pensar (se olhou para as outras respostas) que a solução agora é usar um método como a iteração de Newton-Raphson para calcular o quadrado raiz. Para calcular a raiz quadrada de n, escolha uma estimativa inicial x\_0 e itere:
x\_ {i + 1} = \ frac {1} {2} \ left (x\_i + \ frac {n} {x\_i } \ right)
Esta resposta está errada . Bem, não é errado, pois vai lhe dar uma resposta correta. Mas é errado que nenhum designer de CPU que se preze (ou qualquer escritor de biblioteca se tivesse que implementá-lo em software) implementaria raiz quadrada de ponto flutuante desta forma.
A divisão por dois é muito barata operação em binário (que, lembre-se, é de base 2, portanto, está apenas deslocando o ponto binário em uma posição). No entanto, a outra divisão é uma operação muito cara e, neste caso, você precisa realizar a operação várias vezes.
A divisão é tão cara, na verdade, que CPUs modernas usam um algoritmo iterativo semelhante para (mas não realmente) iteração Newton-Raphson para realizar a divisão! É claro que não queremos fazer isso no hardware, em um loop interno.
No hardware de computador moderno, é muito mais barato executar uma operação de multiplicação do que uma operação de divisão. O motivo é um pouco complexo de explicar; tem a ver com o fato de que podemos encaixar muito mais transistores em um chip do que antes, e a multiplicação é um problema que você pode mover para muitos transistores com eficiência. Procure árvores Wallace se estiver interessado nos detalhes.
De qualquer forma, a questão é que a multiplicação é uma operação comparativamente barata. Portanto, se pudermos implementar a operação de raiz quadrada em termos de multiplicação em vez de divisão, seria melhor.
Newton-Raphson, pegue dois
Agora vem o primeiro insight importante: em vez de calcular a raiz quadrada, calcule o recíproco da raiz quadrada. Ou seja, em vez de \ sqrt {n}, calcule \ frac {1} {\ sqrt {n}}. Acontece que este é um número muito mais fácil de calcular e, se você precisar da raiz quadrada, multiplique esse número por n e pronto.
O método Newton-Raphson para raiz quadrada recíproca é semelhante a este . Se x\_0 é uma estimativa inicial para \ frac {1} {\ sqrt {n}}, iterar:
x\_ {i + 1} = \ frac {1} {2} x\_i \ left (3 – n {x\_i} ^ 2 \ right)
Novamente, a divisão por dois é bem barata, e todo o resto é multiplicação e adição / subtração.
Esta é uma ótima maneira de implementar em software. Além disso, é importante ressaltar que em muitas situações práticas (por exemplo, normalizar um vetor usando o teorema de Pitágoras), a raiz quadrada recíproca é na verdade mais útil do que a raiz quadrada, uma vez que dividir por uma raiz quadrada é menos eficiente do que multiplicar por um quadrado recíproco root.
No entanto, não é assim que geralmente é implementado no hardware.
Algoritmo de Goldschmidt
Agora podemos olhar o algoritmo de Goldschmidt, que calcula a raiz quadrada e a raiz quadrada recíproca juntas.
Dado b\_0 = n, se pudermos encontrar uma série de números Y\_i tal que b\_n = b\_0 { Y\_0} ^ 2 {Y\_1} ^ 2 \ cdots {Y\_ {n-1}} ^ 2 se aproxima de 1, então y\_n = {Y\_0} {Y\_1} \ cdots {Y\_ {n-1}} se aproxima de \ frac {1} {\ sqrt {b\_0}} e x\_n = b\_0 {Y\_0} {Y\_1} \ cdots {Y\_ {n-1}} irá se aproximar de \ sqrt {b\_0}.
A série que usamos é essencialmente a Etapa de atualização Newton-Raphson:
\ begin {align *} b\_i & = b\_ {i-1} {Y\_ {i-1}} ^ 2 \\ Y\_i & = \ frac {1} {2 } (3 – b\_i) \ end {align *}
E então podemos rastrear a raiz quadrada:
\ begin {align *} x\_0 & = n Y\_0 \\ x\_ {i} & = x\_ {i-1} Y\_i \ end {align *}
E a raiz quadrada recíproca:
\ begin {align *} y\_0 & = Y\_0 \\ y\_ {i} & = y\_ {i-1} Y\_i \ end {align *}
Mas se acompanharmos x\_i e y\_i, observe que b\_i = x\_ {i-1} y\_ {i-1}. Portanto, nunca realmente precisamos acompanhar b\_i:
\ begin {align *} Y\_i & = \ frac {1} {2} \ left (3 – b\_i \ right) \\ & = 1 + \ frac {1} {2} \ left (1 – b\_i \ right) \\ & = 1 + \ frac {1} {2} \ left (1 – x\_ {i-1} y\_ {i-1} \ right ) \ end {align *}
E agora, nem precisamos acompanhar Y\_i:
\ begin {align *} x\_i & = x\_ {i-1} \ esquerda (1 + \ frac {1} {2} \ esquerda (1 – x\_ {i-1} y\_ {i-1} \ direita) \ direita) \\ & = x\_ {i-1} + x\_ {i- 1} \ frac {1} {2} \ left (1 – x\_ {i-1} y\_ {i-1} \ right) \\ y\_i & = y\_ {i-1} \ left (1 + \ frac {1 } {2} \ left (1 – x\_ {i-1} y\_ {i-1} \ right) \ right) \\ & = y\_ {i-1} + y\_ {i-1} \ frac {1} { 2} \ left (1 – x\_ {i-1} y\_ {i-1} \ right) \ end {align *}
Há alguns cálculos redundantes aqui, que podemos remover, sugerindo o seguinte algoritmo. Dado Y como uma aproximação de \ frac {1} {\ sqrt {n}}, defina:
\ begin {align *} x\_0 & = n Y \\ y\_0 & = Y \ end {align * }
Em seguida, itere:
\ begin {align *} r\_i & = \ frac {1} {2} \ left (1 – x\_i y\_i \ right) \\ x\_ {i +1} & = x\_i + x\_i r\_i \\ y\_ {i + 1} & = y\_i + y\_i r\_i \ end {alinhar *}
Mesmo que a divisão por dois seja barata, podemos evitar isso também mantendo o controle de h\_i = \ frac {1} {2} y\_i em vez de y\_i. Este é o algoritmo de Goldschmidt.
Suponha que Y seja uma aproximação de \ frac {1} {\ sqrt {n}}. Definir:
\ begin {align *} x\_0 & = n Y \\ h\_0 & = \ frac {Y} {2} \ end {align *}
Em seguida, iterar:
\ begin {align *} r\_i & = \ frac {1} {2} – x\_i h\_i \\ x\_ {i + 1} & = x\_i + x\_i r\_i \\ h\_ {i + 1} & = h\_i + h\_i r\_i \ end {align *}
Então x\_i converge para \ sqrt {n} e h\_n converge para \ frac {1} {2 \ sqrt {n}}.
Implementando isso em hardware
Até aqui tudo bem. Certamente é um algoritmo muito simples. Mas por que é melhor?
As CPUs modernas geralmente têm um circuito rápido que executa uma operação de multiplicação-acumulação otimizada, geralmente chamada de multiplicação fundida adicionar, ou FMA para breve. Se você consultou a referência às árvores Wallace antes, deve estar claro para você como o FMA pode ser quase tão eficiente quanto uma operação de multiplicação direta.
O FMA é um dos primitivos mais úteis para se ter por aí. Se você precisa avaliar um polinômio, por exemplo:
p (x) = a\_0 + a\_1 x + a\_2 x ^ 2 + \ cdots a\_n x ^ n
você pode usar Horner regra, que é essencialmente um bando de FMAs:
\ begin {align *} p\_ {n-1} & = a\_ {n-1} + x a\_n \\ p\_ {n-2} & = a\_ {n-2} + x p\_ {n-1} \\ & \ vdots \\ p\_1 & = a\_1 + x p\_2 \\ p\_0 & = a\_0 + x p\_1 \ end {align *}
O loop interno do algoritmo de Goldschmidt é três FMAs e nada mais.É por isso que é uma vantagem: você só precisa de um tipo de circuito (possivelmente apenas um circuito; observe que os dois segundos FMAs são independentes e, portanto, podem se beneficiar do pipelining) mais alguma lógica de controle para implementar tudo. E é um circuito útil em muitas outras operações, então você não está desperdiçando muito hardware apenas na operação da raiz quadrada.
A penúltima peça do quebra-cabeça é como obter uma boa inicial estimativa, e a resposta curta é que o melhor método é usar uma consulta de tabela. Mesmo uma mesa de tamanho modesto, porque procuramos apenas raízes quadradas em um intervalo tão pequeno, é bastante eficiente.
A última peça do quebra-cabeça é: como saberemos quando terminarmos iterando? E a resposta para isso é que sabemos a precisão dos números que estamos usando e quão boa é a estimativa inicial. A partir disso, podemos calcular o número máximo de iterações necessárias com antecedência. Portanto, na verdade não fazemos loop como tal, apenas fazemos a iteração um número fixo de vezes.