PDL :: MATLABp - Online na Nuvem

PROGRAMA:

NOME

PDL :: MATLAB - Um guia para usuários do MATLAB.

INTRODUÇÃO

Se você é um usuário do MATLAB, esta página é para você. Isso explica as principais diferenças entre
MATLAB e PDL para ajudá-lo a começar o mais rápido possível.

Esta documento is não a tutorial. Para isso, vá para PDL :: QuickStart. Esse documento
complementos o guia de início rápido, pois destaca as principais diferenças entre MATLAB e
PDL.

Perl

A principal diferença entre MATLAB e PDL é Perl.

Perl é uma linguagem de programação de propósito geral com milhares de módulos disponíveis gratuitamente
Na internet. PDL é uma extensão do Perl. Isso dá aos programas PDL acesso a mais recursos
do que a maioria das ferramentas numéricas pode sonhar. Ao mesmo tempo, a maioria das diferenças de sintaxe entre
MATLAB e PDL são o resultado de sua fundação Perl.

Vocês do não para aprende muito Perl para be eficaz com PDL. Mas se você deseja aprender
Perl, há uma excelente documentação disponível on-line (http://perldoc.perl.org>) ou
através do comando "perldoc perl". Também existe um portal para iniciantes
(<http://perl-begin.org>).

O repositório de módulos do Perl é chamado CPAN (http://www.cpan.org>) e tem uma vasta gama de
módulos. Execute "perldoc cpan" para obter mais informações.

TERMINOLOGIA: PIDDLE

MATLAB normalmente se refere a vetores, matrizes e matrizes. Perl já tem matrizes, e o
os termos "vetor" e "matriz" geralmente se referem a coleções unidimensionais e bidimensionais de
dados. Não tendo um bom termo para descrever seu objeto, os desenvolvedores de PDL cunharam o termo
"piolho"para dar um nome ao tipo de dados.

A piolho consiste em uma série de números organizados como um conjunto de dados N-dimensional. Piddles
fornecem armazenamento eficiente e computação rápida de grandes matrizes N-dimensionais. Eles são
altamente otimizado para trabalho numérico.

Para mais informações, veja "Piddles vs Perl Arrays"posteriormente neste documento.

COMANDO JANELA E IDE

Ao contrário do MATLAB, o PDL não vem com um IDE dedicado. No entanto, vem com um
shell interativo e você pode usar um Perl IDE para desenvolver programas PDL.

PDL interativo concha
Para iniciar o shell interativo, abra um terminal e execute "perldl" ou "pdl2". Como no MATLAB,
o shell interativo é a melhor maneira de aprender o idioma. Para sair do shell, digite
"sair", assim como o MATLAB.

Escrevendo PDL programas
Um IDE popular para Perl é chamado Padre (http://padre.perlide.org>). É cruz
plataforma e fácil de usar.

Sempre que você escreve um programa PDL independente (ou seja, fora do shell "perldl" ou "pdl2")
você deve iniciar o programa com "use PDL;". Este comando importa o módulo PDL para
Perl. Aqui está um programa PDL de amostra:

use PDL; # Importar módulo PDL principal.
use PDL :: NiceSlice; # Importar módulo PDL adicional.
use PDL :: AutoLoader; # Importar módulo PDL adicional.

$ b = pdl [2,3,4]; # As instruções terminam em ponto-e-vírgula.
$ A = pdl [[1,2,3], [4,5,6]]; # Matriz bidimensional.

imprimir $ A x $ b-> transpor;

Salve este arquivo como "myprogram.pl" e execute-o com:

perl meuprograma.pl

Novo: Flexível sintaxe
Nas versões atuais do PDL (versão 2.4.7 ou posterior), existe uma sintaxe de matriz flexível que
pode ser extremamente semelhante ao MATLAB:

1) Use um ';' para delimitar linhas:

$ b = pdl q [2,3,4];
$ A = pdl q [1,2,3; 4,5,6];

2) Use espaços para separar os elementos:

$ b = pdl q [2 3 4];
$ A = pdl q [1 2 3; 4 5 6];

Basicamente, contanto que você coloque um "q" na frente do colchete de abertura, o PDL deve "fazer o que
você quer dizer ". Assim, você pode escrever em uma sintaxe que seja mais confortável para você.

MÓDULOS PARA MATLAB USUÁRIOS

Existem dois módulos que os usuários do MATLAB irão querer usar:

PDL :: NiceSlice
Dá ao PDL uma sintaxe para fatias (submatrizes) que é mais curta e mais familiar
Usuários do MATLAB.

% MATLAB
b (1: 5) -> Seleciona os 5 primeiros elementos de b.

# PDL sem NiceSlice
$ b-> slice ("0: 4") -> Seleciona os primeiros 5 elementos de $ b.

# PDL com NiceSlice
$ b (0: 4) -> Seleciona os 5 primeiros elementos de $ b.

PDL :: AutoLoader
Fornece um autoloader estilo MATLAB para PDL. Se uma função desconhecida "foo ()" for chamada,
PDL procura um arquivo chamado "foo.pdl". Se encontrar um, ele o lê.

BASIC CARATERÍSTICAS

Esta seção explica como a sintaxe do PDL difere do MATLAB. A maioria dos usuários do MATLAB vai querer
começa aqui.

Geral "Pegadinhas"
Índices
No PDL, os índices começam em '0' (como C e Java), não 1 (como MATLAB ou FORTRAN). Por
exemplo, se $ b é uma matriz com 5 elementos, os elementos seriam numerados de 0 a
4.

Exibindo um objeto
O MATLAB normalmente exibe o conteúdo do objeto automaticamente. Nos shells PDL que você exibe
objetos explicitamente com o comando "print" ou o atalho "p":

MATLAB:

>> a = 12
a = 12
>> b = 23; % Suprime a saída.
>>

PDL Shell (perldl ou pdl2):

pdl> $ a = 12 # Sem saída.
pdl> print $ a # Objeto de impressão.
12
pdl> p $ a # "p" é uma abreviação de "imprimir" no shell.
12
PDL>

Criar Piddles
Variáveis ​​em PDL
As variáveis ​​sempre começam com o sinal '$'.

MATLAB: valor = 42
PerlDL: $ value = 42

Sintaxe básica
Use o construtor "pdl" para criar um novo piolho.

MATLAB: v = [1,2,3,4]
PerlDL: $ v = pdl [1,2,3,4]

MATLAB: A = [1,2,3; 3,4,5]
PerlDL: $ A = pdl [[1,2,3], [3,4,5]]

Matrizes simples
MATLAB PDL
------ ------
Matriz de uns queridos(5) uns 5,5
Matriz de zeros zeros(5) zeros 5,5
Matriz aleatória rand(5) 5,5 aleatório
Vetor linear 1: 5 sequência 5

Observe que no PDL, os parênteses em uma chamada de função costumam ser opcionais. Isto é
importante ficar atento a possíveis ambigüidades. Por exemplo:

pdl> p zeros 2, 2 + 2

Isso deve ser interpretado como "zeros (2,2) + 2" ou como "zeros 2, (2 + 2)"? Ambos são
declarações válidas:

pdl> p zeros (2,2) + 2
[
[2 2]
[2 2]
]
pdl> p zeros 2, (2 + 2)
[
[0 0]
[0 0]
[0 0]
[0 0]
]

Em vez de tentar memorizar a ordem de precedência do Perl, é melhor usar
parênteses para tornar seu código inequívoco.

Sequências espaçadas linearmente
MATLAB: >> linspace (2,10,5)
resposta = 2 4 6 8 10

PerlDL: pdl> p zeros(5) -> xlinvals (2,10)
[2 4 6 8 10]

Explicação: Comece com um piddle unidimensional de 1 elementos e dê-o igualmente
valores espaçados de 2 a 10.

O MATLAB tem uma única chamada de função para isso. Por outro lado, o método PDL é mais
flexível:

pdl> p zeros (5,5) -> xlinvals (2,10)
[
[2 4 6 8 10]
[2 4 6 8 10]
[2 4 6 8 10]
[2 4 6 8 10]
[2 4 6 8 10]
]
pdl> p zeros (5,5) -> ylinvals (2,10)
[
[2 2 2 2 2]
[4 4 4 4 4]
[6 6 6 6 6]
[8 8 8 8 8]
[10 10 10 10 10]
]
pdl> p zeros (3,3,3) -> zlinvals (2,6)
[
[
[2 2 2]
[2 2 2]
[2 2 2]
]
[
[4 4 4]
[4 4 4]
[4 4 4]
]
[
[6 6 6]
[6 6 6]
[6 6 6]
]
]

Fatias e índices
Extrair um subconjunto de uma coleção de dados é conhecido como slicing. PDL e MATLAB
têm uma sintaxe semelhante para fatiar, mas existem duas diferenças importantes:

1) Os índices PDL começam em 0, como em C e Java. O MATLAB começa os índices em 1.

2) No MATLAB você pensa em "linhas e colunas". No PDL, pense em "x e y".

MATLAB PerlDL
------ ------
>> A pdl> p $ A
UMA = [
1 2 3 [1 2 3]
4 5 6 [4 5 6]
7 8 9 [7 8 9]
]
-------------------------------------------------- -----
(linha = 2, col = 1) (x = 0, y = 1)
>> A (2,1) pdl> p $ A (0,1)
an = [
4 [4]
]
-------------------------------------------------- -----
(linha = 2 a 3, col = 1 a 2) (x = 0 a 1, y = 1 a 2)
>> A (2: 3,1: 2) pdl> p $ A (0: 1,1: 2)
an = [
4 5 [4 5]
7 8 [7 8]
]

Aviso
Quando você escreve um programa PDL autônomo, você deve incluir o PDL :: NiceSlice
módulo. Veja a seção anterior "MÓDULOS PARA MATLAB USUÁRIOS" para mais
informações.

use PDL; # Importar módulo PDL principal.
use PDL :: NiceSlice; # Sintaxe agradável para fatiar.
use PDL :: AutoLoader; # Autoloader semelhante ao MATLAB.

$ A = 4,4 aleatório;
imprimir $ A (0,1);

Matriz Operações
Multiplicação da matriz
MATLAB: A * B
PerlDL: $ A x $ B

Multiplicação elementar
MATLAB: A. * B
PerlDL: $ A * $ B

Transpor
MATLAB: A '
PerlDL: $ A-> transpor

Funções que. agregar dados,
Algumas funções (como "soma", "máximo" e "mínimo") agregam dados para um conjunto de dados N-dimensional.
Este é um lugar onde o MATLAB e o PDL têm uma abordagem diferente:

No MATLAB, todas essas funções funcionam em uma dimensão.
>> A = [1,5,4; 4,2,1]
UMA = 1 5 4
4 2 1
>> max (A)
an = 4 5 4
>> max (A ')
an = 5 4

Se você quiser o máximo para todo o conjunto de dados, você pode usar o A especial (:)
notação que basicamente transforma todo o conjunto de dados em um único
vetor.

>> max (A (:))
an = 5
>> A = uns (2,2,2,2)
>> max (A (:))
an = 1

O PDL oferece duas funções para cada recurso.
soma vs soma
média vs média
máximo vs máximo
min vs mínimo

O longo nome trabalha em uma dimensão, enquanto o baixo nome funciona em todo o
piolho.

pdl> p $ A = pdl [[1,5,4], [4,2,1]]
[
[1 5 4]
[4 2 1]
]
pdl> p $ A-> máximo
[5 4]
pdl> p $ A-> transpor-> máximo
[4 5 4]
pdl> p $ A-> max
5
pdl> p uns (2,2,2) -> máx.
1
pdl> p uns (2,2,2,2) -> máx.
1

Observação Observe que o PDL agrega horizontalmente, enquanto o MATLAB agrega verticalmente. Em outro
palavras:

MATLAB PerlDL
max (A) == $ A-> transpor-> máximo
max (A ') == $ A-> máximo

DICA: No MATLAB você pensa em "linhas e colunas". No PDL, pense em "x e y".

Mais alto dimensional dados, conjuntos
Uma questão relacionada é como o MATLAB e o PDL entendem os conjuntos de dados de dimensão superior. MATLAB era
projetado para vetores 1D e matrizes 2D. Objetos dimensionais superiores ("matrizes ND") foram
adicionado no topo. Em contraste, o PDL foi projetado para piddles N-dimensionais desde o início. Isto
leva a algumas surpresas no MATLAB que não ocorrem no PDL:

O MATLAB vê um vetor como uma matriz 2D.
MATLAB PerlDL
------ ------
>> vetor = [1,2,3,4]; pdl> $ vector = pdl [1,2,3,4]
>> size (vector) pdl> p $ vector-> dims
an = 1 4 4

O MATLAB vê "[1,2,3,4]" como uma matriz 2D (matriz 1x4). PDL o vê como um vetor 1D: A
dimensão única de tamanho 4.

Mas o MATLAB ignora a última dimensão de uma matriz 4x1x1.
MATLAB PerlDL
------ ------
>> A = uns (4,1,1); pdl> $ A = uns 4,1,1
>> size (A) pdl> p $ A-> dims
resposta = 4 1 4 1 1

E o MATLAB trata uma matriz 4x1x1 diferentemente de uma matriz 1x1x4.
MATLAB PerlDL
------ ------
>> A = uns (1,1,4); pdl> $ A = uns 1,1,4
>> size (A) pdl> p $ A-> dims
resposta = 1 1 4 1 1 4

O MATLAB não tem sintaxe direta para matrizes ND.
pdl> $ A = pdl [[[1,2,3], [4,5,6]], [[2,3,4], [5,6,7]]]
pdl> p $ A-> dims
3 2 2

Suporte a recursos.
No MATLAB, vários recursos, como suporte de matriz esparsa, não estão disponíveis para ND
matrizes. No PDL, praticamente qualquer recurso suportado por piddles 1D e 2D, é igualmente
suportado por piddles N-dimensionais. Normalmente não há distinção.

laço Estruturas
Perl tem muitas estruturas de loop, mas mostraremos apenas aquela que é mais familiar
Usuários do MATLAB:

MATLAB PerlDL
------ ------
para i = 1:10 para $ i (1..10) {
disp (i) imprimir $ i
fim}

Observação Nunca use loops for para trabalho numérico. Os for-loops do Perl são mais rápidos do que os do MATLAB,
mas ambos empalidecem diante de uma operação "vetorizada". PDL tem muitas ferramentas que
facilitar a escrita de programas vetorizados. Isso está além do escopo deste guia. Para
saiba mais, consulte: PDL :: Indexing, PDL :: Threading e PDL :: PP.

Da mesma forma, nunca use 1..10 para trabalho numérico, mesmo fora de um loop for. 1..10 é um
Array Perl. Os arrays Perl são projetados para flexibilidade, não velocidade. Usar perguntas ao invés.
Para saber mais, consulte a próxima seção.

Piddles vs Perl Arrays
É importante notar a diferença entre um Piddle e um array Perl. Perl tem um
objeto de matriz de uso geral que pode conter qualquer tipo de elemento:

@perl_array = 1..10;
@perl_array = (12, "Olá");
@perl_array = (1, 2, 3, \ @another_perl_array, seqüência(5));

Arrays Perl permitem que você crie estruturas de dados poderosas (veja Dados estruturas abaixo), mas a
deles e guarante que os mesmos estão não projetado for numérico trabalho . Para isso, use perguntas:

$ pdl = pdl [1, 2, 3, 4];
$ pdl = sequência 10_000_000;
$ pdl = uns 600, 600;

Por exemplo:

$ pontos = pdl 1..10_000_000 # 4.7 segundos
$ pontos = sequência 10_000_000 # milissegundos

DICA: Você pode usar sublinhados em números ("10_000_000" é melhor do que 10000000).

Condicionais
Perl tem muitos condicionais, mas mostraremos apenas aquele que é mais familiar ao MATLAB
Comercial:

MATLAB PerlDL
------ ------
if value> MAX if ($ value> $ MAX) {
disp ("Muito grande") print "Muito grande \ n";
elseif valor <MIN} elsif ($ valor <$ MIN) {
disp ("Muito pequeno") print "Muito pequeno \ n";
else} else {
disp ("Perfeito!") print "Perfeito! \ n";
fim }

Observação Aqui está um "pegadinha":

MATLAB: caso contrário
PerlDL: elsif

Se o seu condicional fornece um erro de sintaxe, verifique se você escreveu o seu "elsif"
corretamente.

TIMTOWDI (Lá Is Mais Do que completa Maneira Para Do Isto)
Uma das diferenças mais interessantes entre PDL e outras ferramentas é a expressividade
da linguagem Perl. TIMTOWDI, ou "Há mais de uma maneira de fazer isso", é o lema de Perl.

Perl foi escrito por um linguista, e uma de suas propriedades definidoras é que as declarações podem
ser formulado de maneiras diferentes para dar à linguagem um toque mais natural. Por exemplo, você
dificilmente dirão a um amigo:

"Enquanto eu não terminar, vou continuar trabalhando."

A linguagem humana é mais flexível do que isso. Em vez disso, é mais provável que você diga:

"Vou continuar trabalhando até terminar."

Devido às suas raízes linguísticas, Perl é a única linguagem de programação com este tipo de
flexibilidade. Por exemplo, Perl tem loopings while e instruções if tradicionais:

while (! terminado ()) {
continue trabalhando();
}

if (! esposa_angry ()) {
kiss_wife ();
}

Mas também oferece a alternativa até e a menos que afirmações:

até (terminado ()) {
continue trabalhando();
}

a menos (esposa_angry ()) {
kiss_wife ();
}

E o Perl permite que você escreva loops e condicionais na forma "pós-fixada":

keep_working () até terminar ();

kiss_wife () a menos que wife_angry ();

Desta forma, Perl muitas vezes permite que você escreva um código mais natural e fácil de entender do que é
possível em linguagens de programação mais restritivas.

Funções
A sintaxe do PDL para declarar funções difere significativamente do MATLAB.

MATLAB PerlDL
------ ------
função retval = foo (x, y) sub foo {
retval = x. ** 2 + x. * y meu ($ x, $ y) = @_;
função final retornar $ x ** 2 + $ x * $ y;
}

Não se deixe intimidar por todas as novas sintaxes. Aqui está uma rápida análise de uma função
declaração em PDL:

1) "abaixo"significa" sub-rotina ".

2) "my"declara que as variáveis ​​são locais para a função.

3) "@_"é uma matriz Perl especial que contém todos os parâmetros da função. Isso pode parecer
como uma maneira estranha de fazer funções, mas permite que você faça funções que levam um
número variável de parâmetros. Por exemplo, a função a seguir aceita qualquer número de
parâmetros e os adiciona juntos:

sub meu {
meu ($ i, $ total) = (0, 0);
para $ i (@_) {
$ total + = $ i;
}
return $ total;
}

4) Você pode atribuir valores a várias variáveis ​​de uma vez usando a sintaxe:

($ a, $ b, $ c) = (1, 2, 3);

Portanto, nos exemplos anteriores:

# Isso declara duas variáveis ​​locais e as inicializa como 0.
meu ($ i, $ total) = (0, 0);

# Isso pega os primeiros dois elementos de @_ e os coloca em $ x e $ y.
meu ($ x, $ y) = @_;

5) O "retorno"declaração fornece o valor de retorno da função, se houver.

ADICIONAL CARATERÍSTICAS

ASCII Envie o IO
Para ler arquivos de dados contendo colunas de números separadas por espaços em branco (como seria lido
usando o MATLAB carregar comando) um usa o PDL rcols em PDL :: IO :: Misc. Para um general
revisão da funcionalidade IO disponível no PDL, consulte a documentação para PDL :: IO, por exemplo,
"help PDL :: IO" no pdl2 shell ou "pdldoc PDL :: IO" na linha de comando do shell.

Dados estruturas
Para criar estruturas de dados complexas, o MATLAB usa "célula matrizes"E"estrutura matrizes".
Os arrays e hashes do Perl oferecem funcionalidade semelhante, mas são mais poderosos e flexíveis.
Esta seção é apenas uma visão geral rápida do que Perl tem a oferecer. Para saber mais sobre isso,
por favor vá ahttp://perldoc.perl.org/perldata.html> ou execute o comando "perldoc
perldata ".

Arrays
Matrizes Perl são semelhantes às matrizes de células do MATLAB, mas mais flexíveis. Por exemplo, em
MATLAB, uma matriz de células ainda é fundamentalmente uma matriz. É feito de filas e filas
deve ter o mesmo comprimento.

MATLAB
------
matriz = {1, 12, 'olá'; rand (3, 2), queridos(3), 'lixo'}
=> OK
matriz = {1, 12, 'olá'; rand (3, 2), queridos(3)}
=> ERRO

Um array Perl é uma estrutura de dados sequencial de propósito geral. Pode conter quaisquer dados
tipo.

PerlDLGenericName
------
@array = ([1, 12, 'olá'], [aleatório (3,2), uns (3,3), 'lixo'])
=> OK
@array = ([1, 12, 'hello'], [random (3,2), uns (3,3)])
=> OK
@array = (5, {'name' => 'Mike'}, [1, 12, 'hello'])
=> OK

Observe que o array Perl começa com o prefixo "@" em vez do "$" usado por
piolhos.

Para aprende sobre Perl matrizes, por favor go para <http://perldoc.perl.org/perldata.html> or
corrida da comando "perldoc perldata ".

Hashes
Hashes Perl são semelhantes aos arrays de estrutura do MATLAB:

MATLAB
------
>> bebida = struct ('type', 'coke', 'size', 'large', 'myarray', {1,2,3})
>> drink.type = 'sprite'
>> drink.price = 12% Adicionar novo campo à estrutura da matriz.

PerlDLGenericName
------
pdl>% bebida = (type => 'coca', tamanho => 'grande', mypiddle => uns (3,3,3))
pdl> $ drink {type} = 'sprite'
pdl> $ drink {price} = 12 # Adicionar novo campo ao hash.

Observe que os hashes Perl começam com o prefixo "%" em vez do "@" para matrizes e
"$" usado por piddles.

Para aprende sobre Perl hashes, por favor go para <http://perldoc.perl.org/perldata.html> or
corrida da comando "perldoc perldata ".

Desempenho
PDL tem recursos de desempenho poderosos, alguns dos quais normalmente não estão disponíveis em
ferramentas de computação numérica. As páginas a seguir irão guiá-lo por esses recursos:

PDL :: Indexação
Nível: Principiante

Este tutorial para iniciantes cobre o recurso padrão de "vetorização" que você já
saber do MATLAB. Use esta página para aprender como evitar for-loops para tornar seu programa
mais eficiente.

PDL :: Threading
Nível: Intermediário

O recurso de "vetorização" do PDL vai além do que a maioria dos softwares numéricos pode fazer. No
neste tutorial, você aprenderá como "roscar" sobre dimensões superiores, permitindo que você
vetorizar seu programa além do que é possível no MATLAB.

Benchmarks
Nível: Intermediário

Perl vem com um módulo de benchmarks fácil de usar para ajudá-lo a descobrir quanto tempo leva
para executar diferentes partes do seu código. É uma ótima ferramenta para ajudá-lo a focar seu
esforços de otimização. Você pode ler sobre isso online
(<http://perldoc.perl.org/Benchmark.html>) ou através do comando "perldoc
Referência ".

PDL :: PP
Nível: Avançado

O pré-processador da PDL é um dos recursos mais poderosos da PDL. Você escreve uma função
definição em marcação especial e o pré-processador gera código C real que pode ser
compilado. Com PDL: PP você obtém a velocidade total do código C nativo sem ter que lidar
com toda a complexidade da linguagem C.

Plotagem
PDL possui recursos completos de plotagem. Ao contrário do MATLAB, o PDL depende mais de terceiros
bibliotecas (pgplot e PLplot) para seus recursos de plotagem 2D. Sua plotagem e gráficos 3D
usa OpenGL para desempenho e portabilidade. PDL tem três módulos principais de plotagem:

PDL :: Graphics :: PGPLOT
Melhores for: Traçando funções 2D e conjuntos de dados.

Esta é uma interface para a venerável biblioteca PGPLOT. PGPLOT tem sido amplamente utilizado em
comunidade acadêmica e científica por muitos anos. Em parte por causa de sua idade,
PGPLOT tem algumas limitações em comparação com pacotes mais novos como PLplot (por exemplo, sem RGB
gráficos). Mas tem muitos recursos que ainda o tornam popular na área científica
comunidades.

PDL :: Graphics :: PLplot
Melhores for: Plotar funções 2D, bem como conjuntos de dados 2D e 3D.

Esta é uma interface para a biblioteca de plotagem PLplot. PLplot é um moderno código aberto
biblioteca para fazer plotagens científicas. Ele suporta gráficos de conjuntos de dados 2D e 3D.
PLplot é melhor suportado para plataformas unix / linux / macosx. Tem um desenvolvedor ativo
comunidade e suporte para plataformas win32 está melhorando.

PDL :: Graphics :: TriD
Melhores for: Traçando funções 3D.

A biblioteca de gráficos 3D PDL nativa usando OpenGL como back-end para gráficos e dados 3D
visualização. Com OpenGL, é fácil manipular os objetos 3D resultantes com
o mouse em tempo real.

Escrevendo GUIs
Por meio do Perl, o PDL tem acesso a todos os principais kits de ferramentas para a criação de uma plataforma cruzada
Interface gráfica do usuário. Uma opção popular é wxPerl (http://wxperl.sourceforge.net>).
Estas são as ligações Perl para wxWidgets, um poderoso kit de ferramentas GUI para escrever cross-
aplicativos de plataforma.

wxWidgets é projetado para fazer seu aplicativo parecer e funcionar como um aplicativo nativo em
cada plataforma. Por exemplo, o Perl IDE Pai é escrito com wxPerl.

simulink
Simulink é um modelador e simulador gráfico de sistema dinâmico. Pode ser comprado
separadamente como um complemento do MATLAB. PDL e Perl não têm um equivalente direto para
Simulink do MATLAB. Se esse recurso for importante para você, dê uma olhada em scilab:

<http://www.scilab.org>

Scilab é outro software de análise numérica. Como o PDL, é gratuito e de código aberto. Isto
não tem recursos exclusivos do PDL, mas é muito semelhante ao MATLAB. Scilab vem com
Xcos (anteriormente Scicos), um modelador de sistema gráfico e simulador semelhante ao Simulink.

DIREITOS AUTORAIS

Direitos autorais 2010 Daniel Carrera (dcarrera@gmail.com) Você pode distribuir e / ou modificar este
documento sob os mesmos termos da licença Perl atual.

Vejo: http://dev.perl.org/licenses/

Agradecimentos
Gostaria de agradecer a David Mertens, Chris Marshall e Sigrid Carrera por seus imensos
ajude a revisar os rascunhos anteriores deste guia. Sem suas horas de trabalho, este
documento não seria remotamente tão útil para os usuários do MATLAB como é hoje.

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