PDL::Scilabp - En ligne dans le Cloud

PROGRAMME:

Nom

PDL::Scilab - Un guide pour les utilisateurs de Scilab.

INTRODUCTION

Si vous êtes un utilisateur de Scilab, cette page est pour vous. Il explique les principales différences entre
Scilab et PDL pour vous aider à démarrer le plus rapidement possible.

Le présent document is pas a tutoriel. Pour cela, rendez-vous sur PDL::QuickStart. Ce document
compléments le guide de démarrage rapide, car il met en évidence les principales différences entre Scilab et
PDL.

Perl

La principale différence entre Scilab et PDL est Perl.

Perl est un langage de programmation à usage général avec des milliers de modules disponibles gratuitement
sur le Web. PDL est une extension de Perl. Cela donne aux programmes PDL l'accès à plus de fonctionnalités
que la plupart des outils numériques peuvent rêver. En même temps, la plupart des différences de syntaxe entre
Scilab et PDL sont le résultat de sa fondation Perl.

Vous do pas avons à en apprendre beaucoup Perl à be efficaces avec PDL. Mais si tu veux apprendre
Perl, il existe une excellente documentation disponible en ligne (http://perldoc.perl.org>) ou
via la commande "perldoc perl". Il y a aussi un portail pour débutants
(<http://perl-begin.org>).

Le référentiel de modules de Perl s'appelle CPAN (http://www.cpan.org>) et il a une vaste gamme de
modules. Exécutez "perldoc cpan" pour plus d'informations.

TERMINOLOGIE: FAIRE PIPI

Scilab fait généralement référence à des vecteurs, des matrices et des tableaux. Perl a déjà des tableaux, et le
les termes « vecteur » et « matrice » se réfèrent généralement à des collections unidimensionnelles et bidimensionnelles de
Les données. N'ayant pas de bon terme pour décrire leur objet, les développeurs PDL ont inventé le terme
"faire pipi" pour donner un nom à leur type de données.

A faire pipi consiste en une série de nombres organisés en un ensemble de données à N dimensions. Piddles
fournir un stockage efficace et un calcul rapide de grandes matrices à N dimensions. Elles sont
hautement optimisé pour le travail numérique.

Pour plus d'informations, voir "Piddles vs Perl Arrays" plus loin dans ce document.

COMMAND FENÊTRE ET IDE

PDL n'est pas fourni avec un IDE dédié. Il est cependant livré avec un shell interactif et
vous pouvez utiliser un IDE Perl pour développer des programmes PDL.

PDL Interactif coquille
Pour démarrer le shell interactif, ouvrez un terminal et exécutez "perldl" ou "pdl2". Comme dans Scilab,
le shell interactif est le meilleur moyen d'apprendre la langue. Pour quitter le shell, tapez
"exit", tout comme Scilab.

Écriture PDL tout proche.
Un IDE populaire pour Perl s'appelle Padre (http://padre.perlide.org>). c'est croix
plate-forme et facile à utiliser.

Chaque fois que vous écrivez un programme PDL autonome (c'est-à-dire en dehors des shells "perldl" ou "pdl2")
vous devez démarrer le programme avec "use PDL;". Cette commande importe le module PDL dans
Perl. Voici un exemple de programme PDL :

utiliser PDL ; # Importer le module PDL principal.
utiliser PDL::NiceSlice; # Importez un module PDL supplémentaire.

$b = pdl [2,3,4]; # Les instructions se terminent par un point-virgule.
$A = pdl [ [1,2,3],[4,5,6] ] ; # Piddle en 2 dimensions.

print $A x $b->transposer ;

Enregistrez ce fichier sous le nom "myprogram.pl" et exécutez-le avec :

perl monprogramme.pl

Nouveau: Flexible syntaxe
Dans les versions très récentes de PDL (version 2.4.7 ou ultérieure), il existe une syntaxe matricielle flexible
qui peut ressembler extrêmement à Scilab :

1) Utilisez un ';' pour délimiter les lignes :

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

2) Utilisez des espaces pour séparer les éléments :

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

Fondamentalement, tant que vous mettez un "q" devant le crochet ouvrant, PDL devrait "faire quoi
tu veux dire". Ainsi, vous pouvez écrire dans une syntaxe plus confortable pour vous.

A MODULE POUR LES CANADIENS SCILAB UTILISATEURS

Voici un module que les utilisateurs de Scilab voudront utiliser :

PDL :: NiceSlice
Donne à PDL une syntaxe pour les tranches (sous-matrices) qui est plus courte et plus familière à
Utilisateurs de Scilab.

//Scilab
b(1:5) --> Sélectionne les 5 premiers éléments de b.

# PDL sans NiceSlice
$b->slice("0:4") --> Sélectionne les 5 premiers éléments de $b.

# PDL avec NiceSlice
$b(0:4) --> Sélectionne les 5 premiers éléments de $b.

BASIQUE Fonctionnalités

Cette section explique en quoi la syntaxe de PDL diffère de Scilab. La plupart des utilisateurs de Scilab voudront
commencer ici.

Général "des trucs"
Indices
En PDL, les indices commencent à '0' (comme C et Java), pas 1 (comme Scilab). Par exemple, si
$b est un tableau avec 5 éléments, les éléments seraient numérotés de 0 à 4.

Affichage d'un objet
Scilab affiche normalement le contenu des objets automatiquement. En PDL vous affichez des objets
explicitement avec la commande "print" ou le raccourci "p":

Scilab :

--> a = 12
a = 12.
--> b = 23 ; // Supprime la sortie.
->

PerlDL :

pdl> $a = 12 # Aucune sortie.
pdl> print $a # Affiche l'objet.
12
pdl> p $a # "p" est un raccourci pour "print" dans le shell.
12

La création Piddles
Variables en PDL
Les variables commencent toujours par le signe '$'.

Scilab : valeur = 42
PerlDL : $valeur = 42

Syntaxe de base
Utilisez le constructeur "pdl" pour créer un nouveau faire pipi.

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

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

Matrices simples
Scilab PDL
------ ------
Matrice des uns(5,5) des 5,5
Matrice de zéros zéros(5,5) zéros 5,5
Matrice aléatoire rand(5,5) aléatoire 5,5
Vecteur linéaire 1:5 séquence 5

Notez qu'en PDL, les parenthèses dans un appel de fonction sont souvent facultatives. Il est
important de garder un œil sur d'éventuelles ambiguïtés. Par exemple:

pdl> p zéros 2, 2 + 2

Cela doit-il être interprété comme « zéros(2,2) + 2 » ou comme « zéros 2, (2+2) » ? Les deux sont
déclarations valides :

pdl> p zéros(2,2) + 2
[
[2 2]
[2 2]
]
pdl> p zéros 2, (2+2)
[
[0 0]
[0 0]
[0 0]
[0 0]
]

Plutôt que d'essayer de mémoriser l'ordre de priorité de Perl, il est préférable d'utiliser
parenthèses pour rendre votre code sans ambiguïté.

Séquences espacées linéairement
Scilab : --> linspace(2,10,5)
répond = 2. 4. 6. 8. 10.

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

Explication: Commencez avec un piddle 1 dimension de 5 éléments et donnez-lui également
valeurs espacées de 2 à 10.

Scilab a un seul appel de fonction pour cela. Par contre, la méthode de PDL est plus
souple:

pdl> p zéros(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 zéros(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 zéros(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]
]
]

Tranchage et index
L'extraction d'un sous-ensemble d'une collection de données est appelée tranchage. Le shell PDL et
Scilab a une syntaxe similaire pour le découpage, mais il existe deux différences importantes :

1) Les indices PDL commencent à 0, comme en C et Java. Scilab démarre les indices à 1.

2) Dans Scilab, vous pensez "lignes et colonnes". En PDL, pensez "x et y".

Scilab PerlDL
------ ------
--> Un pdl> p $A
UNE = [
1. 2. 3. [1 2 3]
4. 5. 6. [4 5 6]
7. 8. 9. [7 8 9]
]
-------------------------------------------------------
(ligne = 2, col = 1) (x = 0, y = 1)
--> A(2,1) pdl> p $A(0,1)
répond = [
4. [4]
]
-------------------------------------------------------
(ligne = 2 à 3, col = 1 à 2) (x = 0 à 1, y = 1 à 2)
--> A(2:3,1:2) pdl> p $A(0:1,1:2)
répond = [
4. 5. [4 5]
7. 8. [7 8]
]

Avertissement
Lorsque vous écrivez un programme PDL autonome, vous devez inclure le PDL::NiceSlice
module. Voir la section précédente "MODULES POUR LES CANADIENS SCILAB UTILISATEURS" pour plus
</br>L’Information.

utiliser PDL ; # Importer le module PDL principal.
utiliser PDL::NiceSlice; # Belle syntaxe pour le découpage.

$A = aléatoire 4,4 ;
imprimer $A(0,1) ;

Matrice Opérations
Multiplication matricielle
Scilab : A * B
PerlDL : $A x $B

Multiplication par élément
Scilab : A .* B
PerlDL : $A * $B

Transposer
Scilab : A'
PerlDL : $A->transposer

Les fonctions qui agrégat données,
Certaines fonctions (comme "somme", "max" et "min") agrègent les données pour un ensemble de données à N dimensions.
Scilab et PDL vous offrent tous deux la possibilité d'appliquer ces fonctions à l'ensemble des données ou
à une seule dimension.

Scilab Dans Scilab, ces fonctions fonctionnent par défaut sur l'ensemble des données et un
le paramètre facultatif "r" ou "c" les fait agir sur des lignes ou des colonnes.

--> A = [ 1,5,4 ; 4,2,1 ]
A = 1.
4. 2. 1.
--> max(A)
répond = 5
--> max(A, "r")
répond = 4. 5. 4.
--> max(A, "c")
répond = 5.
4.

PDL PDL propose deux fonctions pour chaque fonctionnalité.

somme vs sumover
moyenne vs moyenne
max contre maximum
minimum contre minimum

Le manuel de formation Long prénom fonctionne sur une dimension, tandis que le court prénom fonctionne sur l'ensemble
faire pipi.

pdl> p $A = pdl [ [1,5,4] , [4,2,1] ]
[
[1 5 4]
[4 2 1]
]
pdl> p $A->maximum
[5 4]
pdl> p $A->transposer->maximum
[4 5 4]
pdl> p $A->max
5

Meilleure performance du béton dimensions données, ensembles
Un problème connexe est de savoir comment Scilab et PDL comprennent les ensembles de données de dimension supérieure. Scilab était
conçu pour les vecteurs 1D et les matrices 2D avec des objets de dimension supérieure ajoutés sur le dessus. Dans
En revanche, PDL a été conçu dès le départ pour les piddles à N dimensions. Cela conduit à quelques
surprises dans Scilab qui ne se produisent pas dans PDL :

Scilab voit un vecteur comme une matrice 2D.
Scilab PerlDL
------ ------
--> vecteur = [1,2,3,4]; pdl> $vecteur = pdl [1,2,3,4]
--> taille(vecteur) pdl> p $vecteur->dims
répond = 1 4 4

Scilab voit "[1,2,3,4]" comme une matrice 2D (matrice 1x4). PDL le voit comme un vecteur 1D : A
dimension unique de la taille 4.

Mais Scilab ignore la dernière dimension d'une matrice 4x1x1.
Scilab PerlDL
------ ------
--> A = uns(4,1,1) ; pdl> $A = uns 4,1,1
--> taille(A) pdl> p $A->dims
répond = 4 1 4 1 1

Et Scilab traite une matrice 4x1x1 différemment d'une matrice 1x1x4.
Scilab PerlDL
------ ------
--> A = uns(1,1,4) ; pdl> $A = uns 1,1,4
--> taille(A) pdl> p $A->dims
répond = 1 1 4 1 1 4

Scilab n'a pas de syntaxe directe pour les tableaux ND.
pdl> $A = pdl [ [[1,2,3],[4,5,6]], [[2,3,4],[5,6,7]] ]
pdl> p $A->dims
3 2 2

Prise en charge des fonctionnalités.
Dans Scilab, plusieurs fonctionnalités ne sont pas disponibles pour les baies ND. En PDL, à peu près n'importe quel
fonctionnalité prise en charge par les piddles 1D et 2D, est également prise en charge par N-dimensionnel
piques. Il n'y a généralement pas de distinction :

Scilab PerlDL
------ ------
--> A = uns(3,3,3); pdl> $A = uns(3,3,3);
--> A' pdl> transpose $A
=> ERREUR => OK

boucle Structure
Perl a de nombreuses structures de boucles, mais nous ne montrerons que celle qui est la plus familière à
Utilisateurs de Scilab :

Scilab PerlDL
------ ------
pour i = 1:10 pour $i (1..10) {
disp(i) affiche $i
finir }

Note N'utilisez jamais de boucles for pour le travail numérique. Les boucles for de Perl sont plus rapides que celles de Scilab,
mais ils pâlissent tous les deux face à une opération « vectorisée ». PDL dispose de nombreux outils qui
faciliter l'écriture de programmes vectorisés. Celles-ci dépassent le cadre de ce guide. À
pour en savoir plus, consultez : PDL::Indexing, PDL::Threading et PDL::PP.

De même, n'utilisez jamais 1..10 pour le travail numérique, même en dehors d'une boucle for. 1..10 est un
tableau Perl. Les tableaux Perl sont conçus pour la flexibilité, pas pour la vitesse. Utilisation piddles à la place.
Pour en savoir plus, consultez la section suivante.

Piddles vs Perl Arrays
Il est important de noter la différence entre un Faire pipi et un tableau Perl. Perl a un
objet tableau à usage général pouvant contenir n'importe quel type d'élément :

@perl_tableau = 1..10 ;
@perl_array = ( 12, "Bonjour" );
@perl_array = ( 1, 2, 3, \@un autre_perl_array, séquence(5) );

Les tableaux Perl vous permettent de créer de puissantes structures de données (voir Date structures au dessous de), mais
l'ont sommes-nous pas un pour numérique travail. Pour cela, utilisez piddles:

$pdl = pdl [ 1, 2, 3, 4 ] ;
$pdl = séquence 10_000_000 ;
$pdl = uns 600, 600 ;

Par exemple :

$points = pdl 1..10_000_000 # 4.7 secondes
$points = séquence 10_000_000 # millisecondes

ASTUCE: Vous pouvez utiliser des traits de soulignement dans les nombres ("10_000_000" se lit mieux que 10000000).

Conditionnel
Perl a de nombreux conditionnels, mais nous ne montrerons que celui qui est le plus familier à Scilab
utilisateurs:

Scilab PerlDL
------ ------
si valeur > MAX si (valeur $ > $ MAX) {
disp("Trop large") print "Trop large\n" ;
elseif valeur < MIN } elsif ($valeur < $MIN) {
disp("Trop petit") print "Trop petit\n" ;
autre } autre {
disp("Parfait !") print "Parfait !\n" ;
finir }

Note Voici un "gotcha":

Scilab : elseif
PerlDL : elsif

Si votre conditionnel donne une erreur de syntaxe, vérifiez que vous avez bien écrit vos "elsif"
correctement.

TIMTOWDI (Là Is Plus Que UN Façon À Do Ce)
L'une des différences les plus intéressantes entre PDL et d'autres outils est l'expressivité
du langage Perl. TIMTOWDI, ou "Il y a plus d'une façon de le faire", est la devise de Perl.

Perl a été écrit par un linguiste, et l'une de ses propriétés déterminantes est que les instructions peuvent
être formulées de différentes manières pour donner à la langue une impression plus naturelle. Par exemple, vous
sont peu susceptibles de dire à un ami :

"Tant que je n'ai pas fini, je vais continuer à travailler."

Le langage humain est plus flexible que cela. Au lieu de cela, vous êtes plus susceptible de dire :

"Je continuerai à travailler jusqu'à ce que j'aie fini."

En raison de ses racines linguistiques, Perl est le seul langage de programmation avec ce genre de
la flexibilité. Par exemple, Perl a des boucles while et des instructions if traditionnelles :

tandis que ( ! fini() ) {
continue de travailler();
}

si ( ! femme_en colère() ) {
baiser_femme();
}

Mais il offre aussi l'alternative jusqu'au et à moins que déclarations:

jusqu'à ce que ( fini () ) {
continue de travailler();
}

à moins que ( femme_en colère ( ) ) {
baiser_femme();
}

Et Perl vous permet d'écrire des boucles et des conditions sous forme "postfix":

keep_working() jusqu'à la fin ();

kiss_wife() sauf si wife_angry();

De cette façon, Perl vous permet souvent d'écrire du code plus naturel et plus facile à comprendre qu'il ne l'est
possible dans des langages de programmation plus restrictifs.

Les fonctions
La syntaxe de PDL pour déclarer des fonctions diffère considérablement de celle de Scilab.

Scilab PerlDL
------ ------
fonction retval = foo(x,y) sous foo {
retval = x.**2 + x.*y ma ($x, $y) = @_;
fonction de fin renvoie $x**2 + $x*$y ;
}

Ne soyez pas intimidé par toute la nouvelle syntaxe. Voici un aperçu rapide d'une fonction
déclaration en PDL :

1) "dessous" signifie " sous-programme ".

2) "my" déclare les variables locales à la fonction.

3) "@_" est un tableau Perl spécial qui contient tous les paramètres de la fonction. Cela peut sembler
comme une étrange façon de faire des fonctions, mais cela vous permet de faire des fonctions qui prennent un
nombre variable de paramètres. Par exemple, la fonction suivante prend n'importe quel nombre de
paramètres et les additionne :

sous mysum {
mon ($i, $total) = (0, 0);
pour $i (@_) {
$total += $i ;
}
retourner $total ;
}

4) Vous pouvez affecter des valeurs à plusieurs variables à la fois en utilisant la syntaxe :

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

Ainsi, dans les exemples précédents :

# Ceci déclare deux variables locales et les initialise à 0.
mon ($i, $total) = (0, 0);

# Ceci prend les deux premiers éléments de @_ et les place dans $x et $y.
mon ($x, $y) = @_;

5) Le "retournerL'instruction " donne la valeur de retour de la fonction, le cas échéant.

COMPLÉMENTAIRES Fonctionnalités

Date structures
Pour créer des structures de données complexes, Scilab utilise "listes" et "structures". Les tableaux de Perl et
les hachages offrent des fonctionnalités similaires. Cette section n'est qu'un aperçu rapide de ce que Perl a
offrir. Pour en savoir plus à ce sujet, rendez-vous surhttp://perldoc.perl.org/perldata.html>
ou exécutez la commande "perldoc perldata".

Arrays
Les tableaux Perl sont similaires aux listes de Scilab. Ils sont tous deux une structure de données séquentielle
qui peut contenir n'importe quel type de données.

scilab
------
list( 1, 12, "bonjour", zeros(3,3) , list( 1, 2) );

PerlDLComment
------
@array = ( 1, 12, "bonjour" , zéros(3,3), [ 1, 2 ] )

Notez que le tableau Perl commence par le préfixe "@" au lieu du "$" utilisé par
piques.

À en apprendre à propos Perl tableaux, veuillez cliquer go à <http://perldoc.perl.org/perldata.html> or
courir le commander "perldoc perldata".

Des hachis
Les hachages Perl sont similaires aux tableaux de structure de Scilab :

scilab
------
--> drink = struct('type', 'coca', 'size', 'large', 'myarray', ones(3,3,3))
--> drink.type = 'sprite'
--> drink.price = 12 // Ajout d'un nouveau champ au tableau de structure.

PerlDLComment
------
pdl> %drink = ( type => 'coca' , size => 'large', mypiddle => ones(3,3,3) )
pdl> $drink{type} = 'sprite'
pdl> $drink{price} = 12 # Ajoute un nouveau champ au hachage.

Notez que les hachages Perl commencent par le préfixe "%" au lieu du "@" pour les tableaux et
"$" utilisé par les piddles.

À en apprendre à propos Perl hachages, veuillez cliquer go à <http://perldoc.perl.org/perldata.html> or
courir le commander "perldoc perldata".

Arts de la scène
PDL possède de puissantes fonctionnalités de performances, dont certaines ne sont normalement pas disponibles dans
outils de calcul numérique. Les pages suivantes vous guideront à travers ces fonctionnalités :

PDL::Indexation
Niveau: Débutant

Ce tutoriel pour débutant couvre la fonctionnalité standard de "vectorisation" que vous avez déjà
savoir de Scilab. Utilisez cette page pour apprendre comment éviter les boucles for pour faire votre programme
plus efficace.

PDL::Filetage
Niveau: Intermédiaire

La fonctionnalité de "vectorisation" de PDL va au-delà de ce que la plupart des logiciels numériques peuvent faire. Dans
ce tutoriel, vous apprendrez à "enfiler" sur des dimensions plus élevées, vous permettant de
vectorisez votre programme plus loin que ce qui est possible dans Scilab.

Repères
Niveau: Intermédiaire

Perl est livré avec un module de benchmarks facile à utiliser pour vous aider à trouver combien de temps cela prend
pour exécuter différentes parties de votre code. C'est un excellent outil pour vous aider à concentrer votre
efforts d'optimisation. Vous pouvez lire à ce sujet en ligne
(<http://perldoc.perl.org/Benchmark.html>) ou par la commande "perldoc
Référence".

PDL :: PP
Niveau: Avancée

Le préprocesseur de PDL est l'une des fonctionnalités les plus puissantes de PDL. tu écris une fonction
définition dans un balisage spécial et le préprocesseur génère un vrai code C qui peut être
compilé. Avec PDL:PP, vous obtenez toute la vitesse du code C natif sans avoir à traiter
avec toute la complexité du langage C.

Traçage
PDL a des capacités de traçage complètes. Contrairement à Scilab, PDL s'appuie davantage sur des tiers
bibliothèques (pgplot et PLplot) pour ses fonctionnalités de traçage 2D. Son tracé et ses graphiques 3D
utilise OpenGL pour les performances et la portabilité. PDL a trois modules de traçage principaux :

PDL::Graphiques::PGPLOT
Mieux pour: Tracer des fonctions et des ensembles de données 2D.

Il s'agit d'une interface avec la vénérable bibliothèque PGPLOT. PGPLOT a été largement utilisé dans
les communautés académiques et scientifiques depuis de nombreuses années. En partie à cause de son âge,
PGPLOT a certaines limitations par rapport aux packages plus récents tels que PLplot (par exemple, pas de RVB
graphique). Mais il possède de nombreuses fonctionnalités qui le rendent toujours populaire dans le domaine scientifique.
communauté.

PDL::Graphiques::PLplot
Mieux pour: Tracer des fonctions 2D ainsi que des jeux de données 2D et 3D.

Il s'agit d'une interface vers la bibliothèque de traçage PLplot. PLplot est un open source moderne
bibliothèque pour faire des parcelles scientifiques. Il prend en charge les tracés des ensembles de données 2D et 3D.
PLplot est mieux pris en charge pour les plates-formes unix/linux/macosx. Il a un développeur actif
la communauté et la prise en charge des plateformes win32 s'améliorent.

PDL::Graphiques::TriD
Mieux pour: Tracer des fonctions 3D.

La bibliothèque graphique 3D PDL native utilisant OpenGL comme backend pour les tracés et les données 3D
visualisation. Avec OpenGL, il est facile de manipuler les objets 3D résultants avec
la souris en temps réel.

Écriture Interfaces graphiques
Grâce à Perl, PDL a accès à toutes les principales boîtes à outils pour créer une plate-forme croisée
interface utilisateur graphique. Une option populaire est wxPerl (http://wxperl.sourceforge.net>).
Ce sont les liaisons Perl pour wxWidgets, une puissante boîte à outils GUI pour l'écriture croisée
applications de la plate-forme.

wxWidgets est conçu pour que votre application ressemble à une application native dans
chaque plate-forme. Par exemple, l'IDE Perl Père est écrit avec wxPerl.

Xcos / Scicos
Xcos (anciennement Scicos) est un modélisateur et un simulateur de système dynamique graphique. C'est une partie
de la distribution Scilab standard. PDL et Perl n'ont pas d'équivalent direct à
Xcos de Scilab. Si cette fonctionnalité est importante pour vous, vous devriez probablement conserver une copie de
Scilab est là pour ça.

DROIT D'AUTEUR

Droit d'auteur 2010 Daniel Carrera ([email protected]). Vous pouvez distribuer et/ou modifier ce
document sous les mêmes conditions que la licence Perl actuelle.

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

Utiliser PDL::Scilabp en ligne en utilisant les services onworks.net