PDL :: Tipsp - Online na nuvem

PROGRAMA:

NOME

PDL :: Dicas - Pequenos pedaços de arcanos úteis. Petiscos de programação e tal.

SINOPSE

usar PDL;

# Aconteça o que acontecer aqui.

DESCRIÇÃO

Esta página documenta expressões idiomáticas úteis, dicas úteis e dicas para usar Perl Data Language
v2.0.

Suporte
Use "ajuda ajuda" dentro perldl or pdl2 ou use o programa "pdldoc" da linha de comando
para acesso à documentação PerlDL. As versões HTML das páginas também devem ser
presente, no HtmlDocs / PDL diretório da distribuição PDL. Para encontrar este diretório,
tente o seguinte

pdl> foreach (map {"$ _ / PDL / HtmlDocs"} @ INC) {p "$ _ \ n" if -d $ _}

Indexação expressões idiomáticas
O código a seguir normaliza vários vetores em $ a. Isso funciona independentemente do
dimensionalidade de $ a.

$ a / = $ a-> soma->manequim(0);

O Quê is acontecendo?
Se você quiser ver o que o código está realmente fazendo, tente o comando

PDL :: Core ::set_debugging(1);

algum lugar. Isso expele uma grande quantidade de informações de depuração para PDL em STDOUT. Planos para o
futuro inclui tornar possível redirecionar a saída, e também tornar possível
selecione as mensagens com mais precisão.

Muitas das mensagens vêm de "Basic / Core / pdlapi.c" e você pode olhar a fonte para ver
o que está acontecendo.

Se você tiver algum tempo extra para trabalhar nesses mecanismos, informe o mailing pdl-porters
Lista.

Memória poupança
Se você estiver executando recursivamente algo que seleciona certos índices de um grande piddle,
como

enquanto(1) {
$ inds = onde ($ a> 0);
$ a = $ a-> índice ($ inds);
$ b = $ b-> índice ($ inds);
função ($ b, $ a);
}

Se você não está escrevendo em $ b, poupa muita memória alterá-lo para

$ b = $ b-> índice ($ inds) -> servidor;

O novo método "sever" faz com que a relação de write-back seja esquecida. É como
cópia exceto que muda o piddle original e o retorna).

Claro, a provavelmente melhor maneira de fazer o acima é

$ inds = xvals ($ a-> long);
enquanto(1) {
$ inds0 = onde ($ a> 0);
$ inds1 = $ inds-> index ($ inds) -> sever;
$ a = $ a0-> índice ($ inds1);
$ b = $ b-> índice ($ inds1) -> servidor;
função ($ b, $ a);
}

que não salva todas as instâncias temporárias de $ a na memória. Veja "mandel.pl" no
Demos subdiretório da distribuição PerlDL para um exemplo.

PP velocidade
Se você realmente deseja escrever código PP rápido, a primeira coisa que você precisa fazer é ter certeza
que seu compilador C tem permissão para fazer as otimizações necessárias.

O que isso significa é que você deve permitir o maior número de variáveis ​​possível para entrar em
registra:

loop (a)% {
$ a () + = $ COMP (foo_member) * $ b ()
%}

se expande para

para (i = 0; i <10000; i ++) {
a [i] + = __privtrans-> foo_member * b [i];
}

é o pior que você pode fazer, já que seu compilador C não tem permissão para assumir que "a"
não sobrescreve "foo_member" que inibe completamente a vetorização. Em vez disso, faça

float foo = $ COMP (foo_member);
loop (a)% {
$ a () + = foo * $ b ();
%}

Esta não é uma restrição causada pelo PP, mas pela semântica ANSI C. Claro, poderíamos copiar
a estrutura em variáveis ​​locais e de volta, mas isso pode causar coisas muito estranhas
as vezes.

Existem muitos outros problemas na organização de loops.

No momento, estamos planejando tornar o PP capaz de fazer coisas de largura fixa, bem como físicas
piddles (onde o loop nas primeiras dimensões seria mais barato, pois há menos
incrementos distintos, o que pode fazer a diferença em máquinas com um pequeno número de
registros).

Use PDL :: Tipsp online usando serviços onworks.net