Computar raiz quadrada usando adições (turnos) e mudanças como primitivas

Pergunta: Dada uma$n$número natural bits , como calcular usando apenas adições e turnos de (bit)?$N$$\lceil \sqrt{N} \rceil$$O(n)$

A dica é usar a pesquisa binária. No entanto, não consegui atingir a complexidade necessária (obtive ).$O(n^2)$

O que isso significa por using only $O(n)$ (bit) additions and shifts:

Este é um exercício em um livro de algoritmos.
Na minha opinião, significa que adicionar dois números naturais , digamos bits, custa e mudar um número natural digamos bits, também custa . Então, só podemos usar essas operações vezes. Não menciona o custo da comparação. Acho que podemos ignorá-lo ou assumir que comparar dois números naturais , digamos bits, também custa .$n$$O(1)$$n$$O(1)$$O(1)$$O(n)$
$n$$O(1)$

Minhas $O(n^2)$algoritmo :

1. Determinar o intervalo do número de bits $t$ do $\lceil \sqrt{N} \rceil$: $$2^{\frac{n-1}{2}} \le \sqrt{N} \le 2^{\frac{n}{2}} \Rightarrow 2^{\lfloor \frac{n-1}{2} \rfloor} \le \lceil \sqrt{N} \rceil \le 2^{\lceil \frac{n}{2} \rceil}$$ Portanto, $$t_1 \triangleq \lfloor \frac{n-1}{2} \rfloor + 1 \le t \le \lceil \frac{n}{2} \rceil + 1 \triangleq t_2.$$
2. Pesquisa binária: Encontre entre e usando a pesquisa binária. Para cada número , para calcular usando adições e desvios quanto primitivas e compará-lo com .$\lceil \sqrt{N} \rceil$$2^{t_1}$$2^{t_2}$$x$$x^2$$N$

A complexidade é, portanto, para tempos de pesquisa binária e computação , cada um dos quais, por sua vez, recebe adições e turnos.$O(n \times n) = O(n^2)$$O(n)$$x^2$$O(n)$

Um algoritmo iterativo parece que deve funcionar.

Seja . Suponha que sabemos que é a aproximação inteira de , ou seja, , e suponha que sabemos o valor de (obtido anteriormente).$M=\lfloor N/4 \rfloor$$x$$\sqrt{M}$$x=\lceil \sqrt{M} \rceil$$x^2$

Agora queremos encontrar . Quais são os possíveis valores de ? Tenho certeza de que os únicos valores possíveis são ou . E é fácil tentar os dois e ver qual está correto. Em particular, para , temos , que pode ser obtido de por dois turnos à esquerda (tempo ); para , temos , que pode ser obtido a partir de e com quatro turnos à esquerda e duas adições (tempo ). Agora basta comparar esses dois valores com$y=\lceil \sqrt{N} \rceil$$y$$y=2x$$y=2x+1$$y=2x$$y^2=4x^2$$x^2$$O(1)$$y=2x+1$$y^2=4x^2+4x+1$$x^2$$x$$O(1)$$N$ para ver qual está correto.

Dessa maneira, obtemos um algoritmo iterativo onde fazemos iterações e onde cada iteração leva tempo . O tempo total de execução é , conforme necessário.$n/2$$O(1)$$O(n)$

Sei que isso não usou a pesquisa binária. Ah bem.

Estamos falando de números inteiros aqui? Onde N tem n bits?

A = 2(n/2), B = A  and C = A2
Step: B = B/2
     If C > N,  
         C = C - 2AB + B2    // too high - make smaller
         A = A - B
     Else 
         C = C + 2AB + B2   // keep this bit
         A = A + B                 
Repeat until B = 0                  // =1 on last loop

O loop é executado n / 2 vezes, o que deve fornecer desempenho de O (n)

Edit: Como funciona, e por quê?
Esta é uma versão da Aproximação sucessiva, que também é usada nos algoritmos CORDIC.
Começando com o maior bit único possível (com um quadrado menor que N), você define um bit de cada vez e calcula o novo quadrado.
Se o novo quadrado ainda for menor que N, mantenha o bit definido.
Se o novo quadrado for muito grande, limpe o bit, desfaça o efeito de adicioná-lo e passe para o próximo bit.

Exemplo: N = 441 (10111001 binário), n = 9

Start:  A = 24 = 16 (1 0000)  B = 16 C = 256 (100 0000)

1   B = 8 (1000) C = 256 + 2(16)(8) + (8)(8) = 576 (10 0100 0000) {high}
    A = 16 + 8 = 24
2   B = 4  (100) C = 576 - 2(16)(4) + (4)(4) = 400 (1 1001 0000) {low}
    A = 24 - 4 = 20
3   B = 2   (10) C = 400 + 2(20)(2) + (2)(2) = 484  (1 1110 0100) {high}
    A = 20 + 2 = 22
4   B = 1    (1) C = 484 - 2(20)(1) + (1)(1) = 441  (1 1011 1001) {keep this}
    A = 22 - 1 = 21
5   B = 1/2 or 0 in integer math; end

O método principal é preencher os bits de $\sqrt{N}$ da esquerda para a direita, mantendo a estimativa abaixo, ou melhor, o quadrado da estimativa abaixo $N$. Cada bit$b$ é uma potência de 2, portanto, ao quadrado ou multiplicação de outro número por $b$ é sempre um pouco de mudança.

Se a estimativa atual for $a$, $b=2^i$e nós sabemos $a^2$ já temos $(a+b)^2 = a^2 + 2ab + b^2$, e podemos reescrever o segundo e o terceiro termos como $a << (i+1)$ e $1 << (i << 1)$. Em seguida, adicionamos tudo e testamos (presumo que você possa fazer$<$) e definir bit $i$ se o quadrado ainda estiver abaixo $N$.

Começamos o ciclo em $i = n/2 = n >> 1$ e conte até zero, mantendo $a$ e $a^2$como nós vamos. É um tipo de pesquisa binária, mas onde os limites são mapeados para diferenças de bit único.

Gosto da resposta de Alan Campbell : com o rastreamento cuidadoso de suposições anteriores, a nova subtração é fácil a cada vez, e a raiz quadrada de troca e adição de binário é quase tão rápida quanto uma divisão de troca e adição de binário.

Mas pode ser possível ir mais rápido, ao invés de tornar sua próxima tentativa um único dígito binário, usando um algoritmo "Ab" x "Ab" e fazendo sua próxima tentativa a média da sua tentativa anterior e o número original dividido pelo palpite anterior. Parece que demoraria mais, não mais. No entanto, a divisão não precisa ser exata. Portanto, se a divisão for executada apenas na raiz quadrada do número de dígitos restantes a ser encontrado, você poderá economizar tempo. Além disso, se para a sua divisão você usar o método francês, da divisão taquigráfica, poderá realmente quebrar alguma velocidade no seu cálculo para grandes divisões.

Agora, se somarmos cálculos em paralelo que produzem resultados preliminares corrigíveis antes que a resposta seja encontrada ... então podemos entender alguma coisa.