PDL::APIp - Online in der Cloud

PROGRAMM:

NAME/FUNKTION

PDL::API - Piddles aus Perl- und C/XS-Code machen

BESCHREIBUNG

Ein einfaches Kochbuch, wie man Piddles manuell erstellt. Es deckt sowohl Perl als auch C/XS ab
Niveau. Darüber hinaus werden die PDL-Kernroutinen beschrieben, auf die von anderen zugegriffen werden kann
Module. Diese Routinen definieren im Wesentlichen die PDL-API. Wenn Sie auf Piddles zugreifen müssen von
C/XS müssen Sie wahrscheinlich über diese Funktionen Bescheid wissen.

ZUSAMMENFASSUNG

PDL verwenden;
sub mkmypiddle {
...
}

Erstellen a pinkeln manuell von Perl

Manchmal willst du eine Pudel schaffen manuell aus binären Daten. Das kannst du bei
Perl-Level. Beispiele in der Verteilung umfassen einige der IO-Routinen. Der Code
Ausschnitt unten zeigt die erforderlichen Schritte.

Verwenden Sie Karpfen;
sub mkmypiddle {
meine $klasse = Verschiebung;
my $pdl = $class->new;
$pdl->set_datatype($PDL_B);
mein @dims = (1,3,4);
meine $größe = 1;
für (@dims) { $size *= $_ }
$pdl->setdims([@dims]);
mein $dref = $pdl->get_dataref();

# Daten direkt aus Datei lesen
öffne meine $-Datei, '
my $len = $size*PDL::Core::howbig($pdl->get_datatype);
krächzen "konnte nicht genug Daten lesen" wenn
read( $datei, $$dref, $len) != $len;
$datei schließen;
$pdl->upd_data();

Rückgabe $pdl;
}

Erstellen a pinkeln in C

Im folgenden Beispiel wird ein Piddle auf C-Ebene erstellt. Wir verwenden das Modul "Inline", das
ist heutzutage wirklich der richtige Weg, um Perl und C zu verbinden. Beachten Sie die Verwendung des "PDL_INCLUDE",
"PDL_TYPEMAP", "PDL_AUTO_INCLUDE" und "PDL_BOOT" Funktionen, die importiert wurden aus
"PDL::Core::Dev". Sie werden in Verbindung mit einem Inline Config-Aufruf verwendet, um sicherzustellen, dass
die PDL-Typemap, die PDL-Include-Dateien und die PDL-Core-Routinen werden während . gefunden
Kompilierung und spätere Ausführung zur Laufzeit.

PDL::LiteF verwenden;
PDL::Core::Dev verwenden;

$a = myfloatseq(); # üben Sie unseren C-Piddle-Konstruktor

drucke $a->info,"\n";

# der Grund für diesen Konfigurationsaufruf wird unten erklärt
Inline C verwenden => Config =>
INC => &PDL_INCLUDE, # stellen Sie sicher, dass wir pdlcore.h usw. finden
TYPEMAPS => &PDL_TYPEMAP, # verwende die PDL-Typkarte
AUTO_INCLUDE => &PDL_AUTO_INCLUDE, # globale Deklarationen und enthält
BOOT => &PDL_BOOT; # Bootcode zum Laden der Core-Struktur

Verwenden Sie Inline-C;
Inline->init; # nützlich, wenn Sie in der Lage sein möchten, dieses Skript zu laden

__DATEN__

__C__

statisches pdl* new_pdl(int datatype, PDL_Indx dims[], int ndims)
{
pdl *p = PDL->pdlneu();
PDL -> setdims (p, dims, ndims); /* Dimmen setzen */
p->Datentyp = Datentyp; /* und Datentyp */
PDL -> allocdata (p); /* den Datenblock zuordnen */

Rückkehr p;
}

pdl* myfloatseq()
{
PDL_Indx dims[] = {5,5,5};
pdl *p = new_pdl(PDL_F,dims,3);
PDL_Float *dataf = (PDL_Float *) p->data;
PDL_Index i; /* Dimensionen können 64bit sein */

für (i=0;i<5*5*5;i++)
Datenf[i] = i; /* die Daten müssen initialisiert werden ! */
Rückkehr p;
}

Verpackung Wir koordinieren den Versand besitzen frustrierten in a pinkeln
Manchmal beziehen Sie einen Teil der Daten aus einer anderen Quelle, zum Beispiel einer Bildverarbeitung
Bibliothek usw. Alles, was Sie in diesem Fall tun möchten, ist, Ihre Daten in eine Piddle-Struktur zu packen
das C-Niveau. Beispiele für diesen Ansatz finden Sie in den IO-Modulen (wo FastRaw
und FlexRaw verwenden es für den mmapped-Zugriff) und das Gimp-Perl-Modul (das es verwendet, um Gimp . zu umhüllen)
Pixelregionen in Piddles). Das folgende Skript zeigt ein einfaches Beispiel:

PDL::LiteF verwenden;
PDL::Core::Dev verwenden;
PDL::Graphics::PGPLOT verwenden;

$b = mkpiddle();

drucke $b->info,"\n";

Bild1 $b;

Inline C verwenden => Config =>
INC => &PDL_INCLUDE,
TYPEMAPS => &PDL_TYPEMAP,
AUTO_INCLUDE => &PDL_AUTO_INCLUDE,
BOOT => &PDL_BOOT;

Verwenden Sie Inline-C;
Inline->init;

__DATEN__

__C__

/* einen vom Benutzer bereitgestellten Datenblock in einen Piddle packen
* Sie müssen die Abmessungen (dims,ndims) angeben und
* der Datentyp (Konstanten für die Datentypen werden deklariert
* in pdl.h; zB PDL_B für Bytetyp, etc)
*
* wenn das erstellte Piddle 'npdl' auf dem . zerstört wird
* Perl-seitig wird die Funktion als 'delete_magic' übergeben
* Parameter wird mit dem Zeiger auf die pdl-Struktur aufgerufen
* und das 'delparam'-Argument.
* Dies gibt Ihnen die Möglichkeit, jede Bereinigung durchzuführen
* das ist notwendig. Zum Beispiel müssen Sie möglicherweise
* explizit eine Funktion aufrufen, um die Ressourcen freizugeben
* Ihrem Datenzeiger zugeordnet.
* 'delete_magic' sollte zumindest den Datenzeiger des Piddle auf Null setzen:
*
* void delete_mydata(pdl* pdl, int param)
* {
* pdl->Daten = 0;
*}
* pdl *p = pdl_wrap(mydata, PDL_B, dims, ndims, delete_mydata,0);
*
* pdl_wrap gibt den Zeiger auf das pdl zurück
* das erstellt wurde.
*/
typedef void (*DelMagic)(pdl *, int param);
static void default_magic(pdl *p, int pa) { p->data = 0; }
statisches pdl* pdl_wrap(void *data, int datatype, PDL_Indx dims[],
int ndims, DelMagic delete_magic, int delparam)
{
pdl* npdl = PDL->pdlnew(); /* den leeren Container holen */

PDL->setdims(npdl,dims,ndims); /* Dimmen setzen */
npdl->Datentyp = Datentyp; /* und Datentyp */
npdl->Daten = Daten; /* zeige es auf deine Daten */
/* Stellen Sie sicher, dass sich der Kern nicht in Ihre Daten einmischt */
npdl->state |= PDL_DONTTOUCHDATA | PDL_ALLOCATED;
if (delete_magic != NULL)
PDL->add_deletedata_magic(npdl, delete_magic, delparam);
sonst
PDL->add_deletedata_magic(npdl, default_magic, 0);
npdl zurückgeben;
}

#define Größe 256
/* eine wirklich alberne Funktion, die ein Rampenbild erstellt
* in Wirklichkeit könnte dies eine undurchsichtige Funktion sein
* in einer Bibliothek, die Sie verwenden
*/
statisches PDL_Byte* mkramp(void)
{
PDL_Byte *Daten;
int ich; /* sollte PDL_Indx verwenden, um die 64-Bit-pdl-Indizierung zu unterstützen */

if ((data = malloc(SZ*SZ*sizeof(PDL_Byte))) == NULL)
croak("mkramp: Speicher konnte nicht zugewiesen werden");
für (i=0;i
Daten[i] = i % SZ;

Daten zurückgeben;
}

/* diese Funktion sorgt für die erforderliche Bereinigung */
Statisch void delete_myramp(pdl* p, int param)
{
if (p->Daten)
frei(p->Daten);
p -> Daten = 0;
}

pdl* mkpiddle()
{
PDL_Indx dims[] = {SZ,SZ};
pdl *p;

p = pdl_wrap((void *) mkramp(), PDL_B, dims, 2,
delete_myramp,0); /* der delparam wird willkürlich auf 0 gesetzt */
Rückkehr p;
}

Die blutig Details

Die Core struct -- bekommen at PDL Core Routinen at Laufzeit
PDL verwendet eine ähnliche Technik wie die Tk-Module, um andere Module verwenden zu lassen
seine Kernroutinen. Ein Zeiger auf alle gemeinsam genutzten Kern-PDL-Routinen wird in $PDL::SHARE . gespeichert
Variable. XS-Code sollte diesen Zeiger beim Booten erhalten, damit der Rest der
C/XS-Code kann diesen Zeiger dann für den Zugriff zur Laufzeit verwenden. Dieses anfängliche Laden der
Zeiger wird am einfachsten mit den Funktionen "PDL_AUTO_INCLUDE" und "PDL_BOOT" erreicht, die
werden von "PDL::Core::Dev" definiert und exportiert. Typische Verwendung mit dem Inline-Modul hat
schon gezeigt:

Inline C verwenden => Config =>
INC => &PDL_INCLUDE,
TYPEMAPS => &PDL_TYPEMAP,
AUTO_INCLUDE => &PDL_AUTO_INCLUDE, # Deklarationen
BOOT => &PDL_BOOT; # Code für den XS-Boot-Abschnitt

Der von "PDL_AUTO_INCLUDE" zurückgegebene Code stellt sicher, dass pdlcore.h ist enthalten und erklärt
die statischen Variablen, um den Zeiger auf die "Core"-Struktur zu halten. Es sieht ungefähr so ​​aus
Dies:

PDL_AUTO_INCLUDE drucken;

#enthalten
statische Core* PDL; /* Struktur enthält C-Kernfunktionen */
statisches SV* CoreSV; /* Ruft Zeiger auf Perl-Variable ab, die die Kernstruktur enthält */

Der von "PDL_BOOT" zurückgegebene Code ruft die Variable $PDL::SHARE ab und initialisiert die
Zeiger auf die "Core"-Struktur. Für diejenigen, die sich mit der Perl-API auskennen, ist hier die
Code:

PDL_BOOT drucken;

perl_require_pv ("PDL::Core"); /* sicherstellen, dass PDL::Core geladen ist */
CoreSV = perl_get_sv("PDL::SHARE",FALSE); /* SV*-Wert */
#ifndef aTHX_
#aTHX definieren_
#endif
wenn (CoreSV==NULL)
Perl_croak(aTHX_ "Wir benötigen das PDL::Core-Modul, das nicht gefunden wurde");
PDL = INT2PTR(Kern*,SvIV(KernSV)); /* Kern*-Wert */
if (PDL->Version != PDL_CORE_VERSION)
Perl_croak(aTHX_ "Der Code muss gegen die neu installierte PDL neu kompiliert werden");

Die Struktur "Core" enthält Versionsinformationen, um sicherzustellen, dass die in pdlcore.h
entspricht wirklich dem zur Laufzeit erhaltenen. Der obige Code testet dies

if (PDL->Version != PDL_CORE_VERSION)
....

Weitere Informationen zur Core-Struktur finden Sie unter PDL::Internals.

Mit diesen Vorbereitungen kann Ihr Code nun auf die Kernroutinen zugreifen, wie bereits in gezeigt
einige der obigen Beispiele, zB

pdl *p = PDL->pdlneu();

Standardmäßig wird die C-Variable mit dem Namen "PDL" verwendet, um den Zeiger auf die "Core"-Struktur zu halten. Wenn
das ist (aus welchem ​​Grund auch immer) ein Problem, für das Sie explizit einen Namen angeben können
Variable mit den Routinen "PDL_AUTO_INCLUDE" und "PDL_BOOT":

Inline C verwenden => Config =>
INC => &PDL_INCLUDE,
TYPEMAPS => &PDL_TYPEMAP,
AUTO_INCLUDE => &PDL_AUTO_INCLUDE 'PDL_Corep',
BOOT => &PDL_BOOT 'PDL_Corep';

Stellen Sie sicher, dass Sie für "PDL_AUTO_INCLUDE" und "PDL_BOOT" dieselbe Kennung verwenden und verwenden Sie diese
gleiche Kennung in Ihrem eigenen Code. ZB in Fortsetzung des obigen Beispiels:

pdl *p = PDL_Corep->pdlnew();

Manche ausgewählt Core Routinen erklärt
Die vollständige Definition der "Core"-Struktur finden Sie in der Datei pdlcore.h. In dem
Im Folgenden werden die am häufigsten verwendeten Memberfunktionen dieser Struktur kurz erklärt.

· "pdl *SvPDLV(SV *sv)"

· "pdl *SetSV_PDL(SV *sv, pdl *it)"

· "pdl *pdlnew()"

"pdlnew" gibt ein leeres pdl-Objekt zurück, das eine weitere Initialisierung benötigt, um es umzuwandeln
in eine richtige Pfütze. Beispiel:

pdl *p = PDL->pdlneu();
PDL->setdims(p,dims,ndims);
p->Datentyp = PDL_B;

· "pdl *null()"

· "SV *copy(pdl* p, char* )"

· "void *smalloc(STRLEN nbytes)"

· "int howbig(int pdl_datatype)"

· "void add_deletedata_magic(pdl *p, void (*func)(pdl*, int), int param)"

· "ungültige Zuweisungsdaten (pdl *p)"

· "void make_physical(pdl *p)"

· "void make_physdims(pdl *p)"

· "void make_physvaffine(pdl *p)"

· "void qsort_X(PDL_Xtype *data, PDL_Indx a, PDL_Indx b)" und "void
qsort_ind_X(PDL_Xtype *data, PDL_Indx *ix, PDL_Indx a, PDL_Indx b)"

wobei X einer von B,S,U,L,F,D ist und Xtype einer von Byte, Short, Ushort, Long, Float oder . ist
Doppelt. PDL_Indx ist der C-Integer-Typ, der der entsprechenden Indexierungsgröße entspricht
für die Perl-Konfiguration (ivsize und ivtype). Es kann entweder "lang" oder "lang" sein
long' je nachdem, ob Ihr Perl 32bit oder 64bit aktiviert ist.

· "float NaN_float" und "double NaN_double"

Dies sind Konstanten, um die erforderlichen NaN-Werte zu erzeugen.

· "void pdl_barf(const char* pat,...)" und "void pdl_warn(const char* pat,...)"

Dies sind C-Code-Äquivalente von "barf" und "warn". Sie beinhalten eine spezielle Handhabung von
Fehler- oder Warnmeldungen beim P-Threading (dh Prozessor-Multi-Threading), die
Verschieben Sie die Nachrichten, bis das Pthreading abgeschlossen ist. Wenn das Pthreading abgeschlossen ist,
Bei den verzögerten Meldungen wird perls "barf" oder "warn" aufgerufen. Dies wird benötigt, um zu halten
vom Aufrufen von Perls "barf" oder "warn" während des Pthreadings, was zu Segfaults führen kann.

Beachten Sie, dass "barf" und "warn" neu definiert wurden (mit C-Präprozessor-Makros) in
pdlcore.h auf "PDL->barf" und "PDL->warn". Dies dient dazu, jeden XS- oder PP-Code von fernzuhalten
perl's "barf" oder "warn" direkt aufrufen, was zu segfaults während führen kann
Gewindeschneiden.

Weitere Informationen zum P-Threading finden Sie unter PDL::ParallelCPU.

Verwenden Sie PDL::APIp online mit den onworks.net-Diensten