Notação de Dirac: álgebra linear em hardware

O recurso mais singular do C±: vetores e matrizes se operam com a notação bra-ket da física, e cada expressão vira código totalmente desenrolado, sem laços. Um produto interno de 4 elementos gera cerca de dez instruções em linha reta; as dimensões precisam ser constantes conhecidas na compilação, e é exatamente isso que permite o desenrolamento.

Os símbolos, e como digitá-los

Antes das formas, o obstáculo prático: dois dos símbolos não estão no teclado. O compilador reconhece exatamente estes quatro, e nenhuma variação deles.

Símbolo

Nome

Código Unicode

O que é

⟩

ket, fecha

U+27E9

Fecha um vetor coluna, como em |b⟩

⟨

bra, abre

U+27E8

Abre um vetor linha, como em ⟨b|

|0⟩

vetor nulo

usa o U+27E9

Zera o vetor inteiro

|I|

identidade

só ASCII

Matriz identidade, esta se digita normalmente

O ponto que causa mais perda de tempo: ⟨ e ⟩ não são os sinais de menor e maior do teclado. São caracteres diferentes, com códigos diferentes. Escrever a # |M|b>; não compila, e a mensagem de erro fala de sintaxe, sem dizer que o problema é o caractere. Os sinais < e > continuam sendo comparação em C±, e é por isso que o compilador não pode aceitá-los nos dois papéis.

Na AURORA: o editor completa

Não é preciso caçar o caractere. No editor, dentro de um arquivo .cmm, digite o nome da operação e aceite a sugestão:

Digite

E aceite para escrever

ket

|v⟩ com o cursor sobre o nome do vetor

bra

⟨v|

braket

⟨a|b⟩, o produto interno

dirac

a lista inteira: as quatro operações, a identidade, o vetor nulo e a leitura de porta

>> ou <<

o caractere ⟩ ou ⟨ sozinho, para inserir no meio de algo já escrito

Lista de autocompletar da AURORA num arquivo .cmm, mostrando as sugestoes da notacao de Dirac.

Figura 27 Digitar ket num .cmm traz as formas da notação; aceitar a sugestão insere o caractere correto.

A lista sai da mesma tabela de símbolos que o compilador usa, extraída do yanc, então ela não pode ensinar um símbolo que o compilador não aceite.

Fora da AURORA

Em qualquer outro editor, três caminhos:

  • copiar de um exemplo que já use a notação, que é o mais rápido;

  • no Windows, o Mapa de Caracteres (charmap), procurando pelo código U+27E8 ou U+27E9;

  • em editores que aceitam entrada Unicode, digitar o código e converter (no Word e no LibreOffice, 27E9 seguido de Alt+X).

As formas suportadas

O # marca a atribuição vetorial: a # |M|b⟩; faz \(a = M b\), A # |a⟩⟨b|; faz o produto externo, e ⟨w|x⟩ é o produto interno dentro de qualquer expressão. As dimensões precisam ser compatíveis e os tipos iguais dos dois lados (int com int, float com float), sem comp.

Todas as formas, com o que cada uma calcula: vetores em notação de Dirac, no manual do YANC. As usadas no tutorial abaixo:

Escrita

Calcula

e = d - ⟨w|x⟩;

produto interno dentro de expressão

a # |M|b⟩;

\(a = M b\) (matriz vezes vetor)

a # c|b⟩;

\(a = c\,b\) (escalar vezes vetor)

a # |b⟩ + c|d⟩;

\(a = b + c\,d\) (soma ponderada)

A # |B| - |a⟩⟨b|;

\(A = B - a\,b^{T}\)

A # c|B|;, A # c|I|;

escalar vezes matriz, identidade escalada

a # |0⟩;

zera o vetor

a # c -> |a⟩;

registrador de deslocamento: desloca a e insere c

Tutorial: um filtro RLS em 66 linhas

O filtro adaptativo RLS (Recursive Least Squares) é o caso de uso perfeito: seu miolo é puro produto de matriz e vetor, e em C com laços ele viraria uma página de índices. Em Dirac, cada linha do algoritmo matemático vira uma linha de código.

Crie um processador proc_rls (32 bits, mantissa 23, expoente 8, uma porta de entrada e uma de saída) e use o programa, que fixa a pilha de dados em 8:

Listagem 9 proc_rls.cmm, o nucleo do algoritmo
 1#NUBITS 32
 2#NBMANT 23
 3#NBEXPO 8
 4#NDSTAC 8
 5#SDEPTH 2
 6#NUIOIN 1
 7#NUIOOU 1
 8
 9#define N 4          // ordem do filtro
10
11void main()
12{
13    float x[N];      // entradas recentes
14    float w[N];      // coeficientes do filtro
15    float P[N][N];   // matriz de covariancia inversa
16    float Px[N];
17    float K[N];
18    float d, y, e, g;
19
20    P # 1000.0|I|;               // P = 1000 * identidade
21    w # |0⟩;                     // coeficientes zerados
22
23    while (1)
24    {
25        x # fin(0) -> |x⟩;       // desloca x e insere a amostra nova
26        d = fin(0);              // sinal desejado
27
28        y = ⟨w|x⟩;               // saida do filtro
29        e = d - y;               // erro
30
31        Px # |P|x⟩;              // P x
32        g = 1.0 / (1.0 + ⟨x|Px⟩);
33        K # g|Px⟩;               // ganho de Kalman
34
35        w # |w⟩ + e|K⟩;          // atualiza os coeficientes
36        P # |P| - |K⟩⟨Px|;       // atualiza a covariancia
37        P # 1.0101|P|;           // fator de esquecimento
38
39        fout(0, y);
40    }
41}

Leia o miolo do while ao lado das equações do RLS em qualquer livro de filtragem adaptativa: é uma transcrição. Esse é o argumento do recurso.

Editor com o codigo RLS em notacao de Dirac, com os brackets realcados.

Figura 28 O editor entende os brackets: realce e espaçamento próprios para a notação.

Quando usar

Dirac compensa quando o algoritmo é álgebra linear de dimensão pequena e fixa: filtros adaptativos, projeções, transformações de coordenadas, redes pequenas. Para dimensões grandes, o desenrolamento explode o número de instruções; o compilador avisa o tamanho gerado, e o relatório do TASM mostra o total. A alternativa nesses casos é escrever os laços em C± comum.