PDL::QuickStartp - מקוון בענן

תָכְנִית:

שֵׁם

PDL::QuickStart - מבוא מהיר לתכונות PDL.

תַקצִיר

סיכום קצר של תכונות PDL העיקריות וכיצד להשתמש בהן.

תיאור

מבוא
Perl היא שפת סקריפטים טובה ורב-תכליתית, המתאימה היטב למתחילים ו
מאפשר יצירת אב טיפוס מהיר. אולם עד לאחרונה הוא לא תמך במבני נתונים אשר
אפשרו לו לבצע חיתוך מספרים מהיר.

אולם עם הפיתוח של Perl v5, Perl רכשה את 'Objects'. במילים פשוטות משתמשים
יכולים להגדיר סוגי נתונים מיוחדים משלהם, ולכתוב שגרות מותאמות אישית כדי לתמרן אותם
או בשפות ברמה נמוכה (C ו-Fortran) או בפרל עצמה.

זה נוצל במלואו על ידי מפתחי PerlDL. מודול 'PDL' הוא שלם
הרחבה מונחה עצמים ל-Perl (אם כי אינך צריך לדעת למה מיועד אובייקט
השתמש בו) המאפשר מערכי נתונים גדולים ב-N-ממדיים, כגון תמונות גדולות, ספקטרום, זמן
סדרות וכו' שיש לאחסן יעילות ועשו מניפולציות en המוני. למשל עם PDL
מודול נוכל לכתוב את קוד Perl "$a = $b + $c", כאשר $b ו-$c הם מערכי נתונים גדולים (למשל
2048x2048 תמונות), וקבל את התוצאה בשבריר שנייה בלבד.

משתני PDL (או 'פיידלס' כפי שהם נודעו) תומכים במגוון רחב של
סוגי נתונים בסיסיים - מערכים יכולים להיות בתים, מספרים שלמים קצרים (חתומים או לא חתומים), ארוכים
מספרים שלמים, מצופים או מצופים דיוק כפול. ובגלל האופי מונחה עצמים של
ניתן להפיק מהם סוגי נתונים מותאמים אישית חדשים של PDL.

כמו גם מודולי PDL, שניתן להשתמש בהם על ידי תוכניות Perl רגילות, PerlDL מגיע עם א
שורת הפקודה מעטפת Perl, הנקראת 'perldl', התומכת בעריכת שורת הפקודה. ב
שילוב עם מודולי הגרפיקה השונים של PDL זה מאפשר לנגן נתונים בקלות
עם ודמייה.

עֶזרָה
PDL מכיל תיעוד נרחב, זמין גם בתוך perldl or pdl2 פגזים ו
משורת הפקודה, באמצעות תוכנית "pdldoc". למידע נוסף נסה אחת מהאפשרויות:

pdl> עזרה עזרה
$ pdldoc

גם עותקי HTML של התיעוד צריכים להיות זמינים. כדי למצוא את מיקומם, נסה
הבא:

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

פרל סוגי מידע ו אֵיך PDL משתרע אוֹתָם
מבני הנתונים הבסיסיים של Perl הם משתנים סקלרים, למשל $x, שיכולים להחזיק מספרים
או מחרוזות, רשימות או מערכים של סקלרים, למשל @x, ומערכים/hashs אסוציאטיביים של סקלרים,
למשל %x.

Perl v5 מציגה מבני נתונים ואובייקטים של Perl. משתנה סקלרי פשוט $x עכשיו להיות
סוג נתונים מוגדר על ידי משתמש או אובייקט מלא (הוא למעשה מכיל הפניה (חכם
"מצביע") לזה אבל זה לא רלוונטי לשימוש רגיל ב-perlDL)

הרעיון הבסיסי מאחורי perlDL הוא לאפשר ל-$x להחזיק ספקטרום 1D שלם, או 2D
תמונה, קוביית נתונים תלת מימדיים וכן הלאה עד לקבוצות נתונים גדולות ב-N-ממד. אלה יכולים להיות
מטופל בבת אחת, למשל "$a = $b + 2" עושה פעולת וקטור על כל ערך ב-
ספקטרום/תמונה/וכו'.

אפשר בהחלט לשאול: "למה לא פשוט לאחסן ספקטרום כרשימה פשוטה בסגנון Perl @x עם כל אחד מהם
פיקסל שהוא פריט רשימה?" שתי התשובות העיקריות לכך הן זיכרון ו מְהִירוּת. כי אנחנו
לדעת שהספקטרום שלנו מורכב ממספרים טהורים, אנו יכולים לאחסן אותם בצורה קומפקטית בבלוק אחד
של זיכרון המתאים למערך מספרי בסגנון C. זה תופס הרבה פחות זיכרון מאשר
רשימת Perl המקבילה. אז קל להעביר את גוש הזיכרון הזה לתוספת מהירה
routine, או לכל פונקציית C אחרת העוסקת במערכים. כתוצאה מכך perlDL הוא מאוד
מהיר --- לדוגמה, אפשר להכפיל תמונה של 2048*2048 בדיוק באותו זמן שהיא
יקבל C או FORTRAN (0.1 שניות ב-SPARC שלי). יתרון נוסף בכך הוא שעבור
פעולות פשוטות (למשל "$x += 2") ניתן לתפעל את המערך כולו מבלי לדאוג
הממדיות שלו.

אני מוצא כשמשתמשים ב-perlDL הכי שימושי לחשוב על משתני Perl @x סטנדרטיים בתור
"רשימות" של "דברים" גנריים ומשתני PDL כמו $x כ"מערכים" שניתן להכיל
ברשימות או גיבוב. לעתים קרובות למדי בסקריפטים של perlDL שלי יש לי ש-@x מכיל רשימה של ספקטרים,
או רשימה של תמונות (או אפילו שילוב!). או אולי אפשר לקבל hash (למשל %x) של
תמונות... המגבלה היחידה היא הזיכרון!

משתני perlDL תומכים במגוון סוגי נתונים - מערכים יכולים להיות בתים, מספרים שלמים קצרים
(חתום או לא חתום), מספרים שלמים ארוכים, מצופים או מצופים דיוק כפול.

נוֹהָג
PerlDL נטען לתוך סקריפט Perl שלך באמצעות פקודה זו:

השתמש ב-PDL; # בסקריפטים של Perl: השתמש במודולי perlDL הסטנדרטיים

יש גם הרבה מודולי הרחבה, למשל PDL::Graphics::TriD. רוב אלה (אבל
לא הכל כמו לפעמים זה לא מתאים) פעל לפי מוסכמה סטנדרטית. אם אתה אומר:

השתמש ב-PDL::Graphics::TriD;

אתה מייבא הכל ברשימה סטנדרטית מהמודול. לפעמים אולי תרצה
לא לייבא כלום (למשל אם אתה רוצה להשתמש בתחביר OO כל הזמן ולשמור את מס היבוא).
על אלה אתה אומר:

השתמש ב-PDL::Graphics::TriD qw();

והמרכאות הריקות "qw()" מזוהות כמשמעותן 'כלום'. אתה יכול גם לציין א
רשימה של פונקציות לייבוא ​​בדרך Perl הרגילה.

יש גם מעטפת אינטראקטיבית, "perldl" או "pdl2", ראה perldl או pdl2 לפרטים.

ל לִיצוֹר a חדש PDL משתנה
הנה כמה דרכים ליצור משתנה PDL:

$a = pdl [1..10]; # מערך 1D
$a = pdl (1,2,3,4); # כנ"ל
$a = pdl '[1 2 3 4]'; # כנ"ל
$b = pdl [[1,2,3],[4,5,6]]; # מערך דו מימדי 2x3
$b = pdl '[1 2 3; 4 5 6]'; # כנ"ל
$b = pdl q[1,2,3; 4,5,6]; # כנ"ל
$b = pdl <
[1 2 3]
[4 5 6]
NEWPDL
$c = pdl q[1 -2]; # פידל של 2 אלמנטים המכיל 1 ו-2
$c = pdl q[1 - 2]; # פידל של 2 אלמנטים המכיל 1 ו-2
$b = pdl 42 # סקלרי 0 מימדי
$c = pdl $a; # צור עותק חדש

$d = byte [1..10]; # ראה "המרת סוג"
$e = zeroes(3,2,4); # מערך אפס בגודל 3x2x4

$c = rfits $file; # קרא את קובץ FITS

@x = ( pdl(42), zeroes(3,2,4), rfits($file) ); # היא רשימה של משתני PDL!

השמיים pdl() הפונקציה משמשת לאתחל משתנה PDL מסקלר, רשימה, רשימה
reference, משתנה PDL אחר, או מחרוזת בפורמט תקין.

בנוסף כל פונקציות PDL ממירות אוטומטית סקלרים רגילים של Perl למשתני PDL
בדרך.

(ראה גם את הסעיפים "המרת סוג" ו"קלט/פלט" להלן)

חשבון (ו בוליאני ביטויים)
$a = $b + 2; $a++; $a = $b / $c; # וכו.

$c=sqrt($a); $d = log10($b+100); # וכו

$e = $a>42; # מותנה וקטור

$e = 42*($a>42) + $a*($a<=42); # כיפה עליון

$b = $a->log10 אלא אם כן יש ($a <= 0); # הימנע משגיאת נקודה צפה

$a = $a / ( max($a) - min($a) );

$f = where($a, $a > 10); # שבו מחזיר פידל של אלמנטים עבור
# שהתנאי נכון

הדפס $a; # $a בהקשר מחרוזת מדפיס אותו בפורמט N-ממדי

(ואופרטורים/פונקציות אחרות של Perl)

בעת שימוש בפידל בביטויים מותנים (כלומר "אם", "אלא אם" ו"בזמן" בונים)
מותרים רק שלוליות עם אלמנט אחד בדיוק, למשל

$a = pdl (1,0,0,1);
הדפס "מוגדר" אם $a->מדד(2);

שימו לב שהאופרטורים הבוליאניים מחזירים פידלים מרובים אלמנטים כלליים. לכן, ה
הבא תעלה שגיאה

הדפס "זה בסדר" אם $a > 3;

מכיוון ש"$a > 3" הוא פידל עם 4 אלמנטים. השתמש בכולם או בכולם כדי לבדוק אם כולם או כל אחד מהם
האלמנטים ממלאים את התנאי:

הדפס "חלקם > 3" אם בכלל $a>3;
הדפס "לא יכול לקחת לוגריתם" אלא אם כל $a>0;

יש גם הרבה פונקציות מוגדרות מראש, המתוארות בדפי אדם אחרים. חשבון
PDL::אינדקס.

מַטרִיצָה פונקציות
'x' נחטף כאופרטור הכפל המטריצה. למשל "$c = $ax $b";

perlDL הוא שורה עיקרית ולא עמודה עיקרית אז זה למעשה "c(i,j) = sum_k a(k,j) b(i,k)" -
אבל כאשר מטריצות יודפסו התוצאות ייראו נכונות. רק תזכור שהמדדים הם
הפוך. לְמָשָׁל:

$a = [ $b = [
[ 1 2 3 0] [1 1]
[ 1 -1 2 7] [0 2]
[ 1 0 0 1] [0 2]
] [1 1]
]

נותן $c = [
[ 1 11]
[ 8 10]
[ 2 2]
]

הערה: לְשַׁרבֵּב() עושה את מה שהוא אומר וזו דרך נוחה להפוך וקטורים לשורות
וקטורים של עמודות.

איך ל לכתוב a פשוט פונקציה
sub dotproduct {
שלי ($a,$b) = @_;
return sum($a*$b) ;
}
1;

אם הוכנס לקובץ dotproduct.pdl ייטען אוטומטית אם אתה משתמש ב-PDL::AutoLoader (ראה
להלן).

כמובן, פונקציה זו כבר זמינה כפונקציה הפנימית, ראה PDL::Primitive.

סוּג המרה
ברירת מחדל עבור pdl() הוא כפול. ההמרות הן:

$a = float($b);
$c = long($d); # "long" הוא בדרך כלל int של 4 בתים
$d = byte($a);

גם לְהַכפִּיל(), קצר(), ushort(), indx().

הערה: השגרה indx() היא סוג מיוחד של מספר שלם
הוא הגודל הנכון עבור ערך אינדקס PDL (גודל ממד,
index, או offest) שיכול להיות 32bit (ארוך) או
כמות של 64bit (longlong) תלוי אם ה-perl
בנוי עם תמיכה ב-32bit או 64bit.

השגרות הללו גם ממירות אוטומטית רשימות Perl כדי לאפשר את הקיצור הנוח:

$a = byte [[1..10],[1..10]]; # צור מערך בתים דו-ממדי
$a = float [1..1000]; # צור מערך צף 1D

וכו '

הדפסה
מרחיב אוטומטית מערך בפורמט N-ממדי:

הדפס $a;

$b = "התשובה היא = $a ";

סעיפים
ל-PDL יש מפעילי חיתוך וחיתוך רב-ממדיים חזקים מאוד; לראות את
PDL::פרוסות(3) דף אדם לפרטים; נתאר כאן את החשוב ביותר.

PDL מראה את מורשת ה-Perl/C שלו בכך שמערכים הם אפס היסט. לפיכך יש לתמונה בגודל 100x100
מדדים "0..99,0..99". (המוסכמה היא שה מרכז של פיקסל (0,0) נמצא בקואורדינטה
(0.0,0.0). כל הפונקציות הגרפיות של PDL תואמות להגדרה זו ומסתירות את היחידה
קיזוזים של, למשל, ספריית PGPLOT FORTRAN.

בעקבות הקואורדינטה הרגילה (0,0) מוצגת בפינה השמאלית התחתונה מתי
הצגת תמונה. זה מופיע בפינה השמאלית העליונה בעת שימוש ב""הדפס $a"" וכו'.

חיתוך פשוט משתמש בתוסף תחביר ל-Perl, PDL::NiceSlice, המאפשר לך
ציין טווחי משנה באמצעות שינוי שיטת null ל-PDL:

$b = $a->($x1:$x2,$y1:$y2,($z1)); # קח סעיף משנה

כאן, $a הוא משתנה תלת מימדי, ו-$b מקבל גזרה מישורית המוגדרת על ידי
מגביל $x1, $x2, $y1, $y2, במיקום $z1. הסוגריים סביב $z1 גורמים ל-
אינדקס טריוויאלי שיש להשמיט -- אחרת $b יהיה תלת מימדי עם שליש
מימד הזמנה 1.

אתה יכול לשים פרוסות PDL משני הצדדים של אופרטור ההקצאה מבחינת האלמנט ".=", כמו
לכן:

# הגדר חלק מ-$bigimage לערכים מ-$smallimage
$bigimage->($xa:$xb,$ya:$yb) .= $smallimage;

עוד קצת שונות:

$c = nelem($a); # מספר פיקסלים

$val = at($object, $x,$y,$z...) # ערך פיקסל במיקום, כסקלאר של Perl
$val = $object->at($x,$y,$z...) # שווה ערך (תחביר השיטה בסדר)

$b = xvals($a); # מלא מערך עם ערכי X-coord (גם yvals(), zvals(),
# axisvals($x,$axis) ו-rvals() למרחק רדיאלי
# מהמרכז).

פלט קלט
מודולי "PDL::IO" מיישמים מספר פונקציות שימושיות בפורמט IO. זה יהיה יותר מדי
לתת דוגמאות של כל אחד מהם, אבל אתה יכול למצוא סקירה יפה ב-PDL::IO. הנה דוגמה של
חלק מהפורמטים הנתמכים של IO ב-PDL.

PDL::IO::שונות
שגרות IO של Ascii, FITS ו-FIGARO/NDF.

PDL::IO::FastRaw
שימוש בסוגי הנתונים הגולמיים של המחשב שלך, IO בלתי נייד אך מהיר להחריד
פוּרמָט. תומך גם במיפוי זיכרון כדי לשמר זיכרון כמו גם לקבל יותר מהירות.

PDL::IO::FlexRaw
פורמטים כלליים של נתונים גולמיים. כמו FastRaw, רק טוב יותר.

PDL::IO::דפדפן
דפדפן קללות עבור מערכים.

PDL::IO::Pnm
תמיכה ב-Portaple Bitmap ו-Pixmap.

PDL::IO::תמונה
שימוש במודול הקודם וב-netpbm, מאפשר לכתוב בקלות GIF, jpeg
ומה שלא יהיה עם פקודות פשוטות.

גרפיקה
הפילוסופיה מאחורי perlDL היא לגרום לזה לעבוד עם מגוון גרפיקה קיימת
ספריות שכן אף חבילה אחת לא תספק את כל הצרכים ואת כל האנשים וזה מאפשר
אחד לעבוד עם חבילות שאתה כבר מכיר ואוהב. ברור שיהיו כאלה
חפיפה בפונקציונליות וקצת חוסר עקביות ואחידות. אולם הדבר מאפשר
PDL כדי להתעדכן בתחום המתפתח במהירות - מודולי ה-PDL העדכניים ביותר מספקים ממשקים
לגרפיקה של OpenGL ו-VRML!

PDL::Graphics::PGPLOT
PGPLOT מספקת ספרייה פשוטה לגרפיקת קווים ותצוגת תמונה.

יש ממשק קל לזה במודול הפנימי PDL::Graphics::PGPLOT, אשר
קורא לשגרות במודול ברמה העליונה PGPLOT הזמין בנפרד.

PDL::Graphics::PLplot
PLplot מספקת ספרייה פשוטה ליצירת גרפיקה עם מספר מנהלי התקנים של פלט,
כולל נהג ישיר לפידל.

מודול זה מספק גם פונקציונליות ברמה גבוהה וגם ברמה נמוכה הבנויה על PLplot. ה
פקודות ברמה נמוכה הן די הרבה כריכות ישירות לממשק C של PLplot. קרא עוד
ב-PDL::Graphics::PLplot.

PDL::Graphics::IIS
אסטרונומים רבים אוהבים להשתמש ב-SAOimage ו-Ximtool (או שם נגזרות/שיבוטים). אלה
הם ווידג'טים חינמיים שימושיים לבדיקה והדמיה של תמונות. (הם לא
מסופק עם perlDL אך ניתן להשיג בקלות מהאתרים הרשמיים שלהם מחוץ ל-
נֶטוֹ.)

חבילת PDL::Graphics::IIS מספקת מאפשרת להציג תמונות באלה ("IIS"
הוא שמו של פריט עתיק של חומרת תצוגת תמונה שכלים אלה פרוטוקולים שלו
להתאים ל.)

PDL::Graphics::TriD
ראה PDL::Graphics::TriD, זהו אוסף של שגרות תלת מימד עבור OpenGL ו(בקרוב)
VRML ותבניות תלת-ממד אחרות המאפשרות נקודות תלת-ממד, קווים ומשטחים מ-PDL.

טעינה אוטומטית
ראה PDL::AutoLoader. זה מאפשר לטעון אוטומטית פונקציות לפי דרישה, אולי באופן מסוים
מוכר למשתמשי MatLab.

אפשר גם לכתוב הרחבות PDL כמודולים רגילים של Perl.

PDL פגזים
סקריפט Perl "pdl2" (או "perldl") מספק ממשק שורת פקודה פשוט ל-PDL. אם
מודולי Readlines/ReadKey העדכניים ביותר הותקנו "pdl2" מזהה זאת ומאפשר
אחזור ועריכה של שורת הפקודה. עיין בדף האיש לפרטים.

למשל:

% perldl
מעטפת perlDL v1.354
PDL מגיע עם לחלוטין ללא אחריות. לפרטים, עיין בקובץ
'Copying' בהפצת PDL. זו תוכנה חופשית ואתה
מוזמנים להפיץ אותו מחדש בתנאים מסוימים, ראה
אותו קובץ לפרטים.
ReadLines, NiceSlice, MultiLines מופעלים
קורא PDL/default.perldlrc...
נמצא מסד הנתונים של מסמכים /home/pdl/dev/lib/perl5/site_perl/PDL/pdldoc.db
הקלד 'עזרה' לעזרה מקוונת
הקלד 'הדגמה' להדגמות מקוונות
PDL נטען v2.4.9_003 (תומך בערכים גרועים)
pdl> $x = rfits 'm51.fits'
קורא נתוני IMAGE...
BITPIX = 32 גודל = 147456 פיקסלים
קורא 589824 בתים
BSCALE = && BZERO =

pdl> השתמש ב-PDL::Graphics::PGPLOT;
pdl> תמונה $x
מציג תמונה בגודל 384 x 384 מ-40 עד 761, תוך שימוש ב-84 צבעים (16-99)...

אתה יכול גם להפעיל את זה מאת הבאגים של Perl ("perl -MPDL -d -e 1") אם תרצה.

תכונות מעטפת שונות:

p המעטפת כינוי "p" כדי להיות צורה קצרה נוחה של "הדפס", למשל

pdl> p ones 5,3
[
[1 1 1 1 1]
[1 1 1 1 1]
[1 1 1 1 1]
]

אתחול
הקבצים "~/.perldlrc" ו-"local.perldlrc" (בספרייה הנוכחית) מקורם אם
מצאתי. זה מאפשר למשתמש לקבל קוד PDL גלובלי ומקומי לאתחול.

עֶזרָה
הקלד 'עזרה'! אפשר לחפש בתיעוד PDL, ולחפש תיעוד על כל אחד
פונקציה.

Escape
כל שורה שמתחילה עם התו "#" מטופלת כאל בריחה של מעטפת. הדמות הזאת
ניתן להגדרה על ידי הגדרת המשתנה Perl $PERLDL_ESCAPE. זה יכול, למשל,
להיות מוגדר ב"~/.perldlrc".

להעמיס יותר מדי מפעילי
האופרטורים והפונקציות המובנות של Perl הבאות הועמסו יתר על המידה לעבודה על PDL
משתנים:

+ - * / > < >= <= << >> & | ^ == != <=> ** % ! ~
sin log abs atan2 sqrt cos exp

[ניתן להשתמש בכל הפונקציות האנריות (חטא וכו') עם במקום() - ראה "זיכרון" למטה.]

כיוון עצמים ו perlDL
פעולות PDL זמינות כפונקציות ושיטות. כך ניתן להפיק סוגים חדשים של
אובייקט, כדי לייצג מחלקות נתונים מותאמות אישית.

באמצעות עומס יתר אפשר לגרום לאופרטורים מתמטיים לעשות ככל העולה על רוחכם, ו-PDL
יש כמה טריקים מובנים המאפשרים לפונקציות PDL קיימות לעבוד ללא שינוי, גם אם
ייצוג הנתונים הבסיסי השתנה מאוד! ראה PDL::Objects

זכרון שימוש ו אזכור
התעסקות עם מערכי נתונים עצומים באמת עשויה לדרוש טיפול מסוים. perlDL מספקת רבים
מתקנים שיאפשרו לך לבצע פעולות על מערכים גדולים מבלי ליצור עותקים נוספים
אם כי זה דורש קצת יותר מחשבה וטיפול מהמתכנת.

הערה: בחלק מהמערכות עדיף להגדיר את Perl (במהלך אפשרויות הבנייה).
השתמש בפונקציית "malloc()" של המערכת ולא בפונקציה המובנית של Perl. זה בגלל של פרל
אחד מהם מותאם למהירות ולא לצריכה של זיכרון וירטואלי - זה יכול לגרום
שיפור של פקטור של שניים בכמות אחסון הזיכרון שאתה יכול להשתמש בו. ה-Perl malloc
ב-5.004 ואילך יש מספר אפשרויות זמן קומפילציה שבהן תוכל להשתמש כדי לכוון את
התנהגות.

חשבון פשוט
אם $a היא תמונה גדולה (למשל התופסת 10MB) אז הפקודה

$a = $a + 1;

אוכלת עוד 10MB של זיכרון. הסיבה לכך היא שהביטוי "$a+1" יוצר את a
עותק זמני של $a כדי להחזיק את התוצאה, ואז ל-$a מוקצית הפניה לכך.
אחרי זה, ה-$a המקורי נהרס אז אין קבוע בזבוז זיכרון. אבל הלאה
מכונה קטנה, הגידול בטביעת הזיכרון יכול להיות ניכר. זה
ברור שנעשה בדרך זו אז "$c=$a+1" עובד כמצופה.

גם אם אחד אומר:

$b = $a; # $b ו-$a מצביעים כעת על אותם נתונים
$a = $a + 1;

ואז $b ו-$a בסופו של דבר יהיו שונים, כפי שמצפים בתמימות, בגלל התייחסות חדשה
נוצר ומוקצה לו $a.

עם זאת, אם $a היה חזיר זיכרון ענק (למשל נפח תלת-ממדי), ייתכן שלא ליצור עותק שלו
להיות דבר טוב. אפשר להימנע מתקורה של זיכרון זה בדוגמה שלעיל על ידי אמירה:

$a++;

הפעולות "++,+=,--,-=" וכו' קוראים כולן לגרסה מיוחדת של "במקום" של
תת שגרת חשבון. זה אומר שאין צורך בזיכרון נוסף - החיסרון של זה הוא
שאם "$b=$a" אז גם $b מוגדל. כדי לכפות עותק במפורש:

$b = pdl $a; # עותק אמיתי

או, לחילופין, אולי סגנון טוב יותר:

$b = $a->copy;

פונקציות
רוב הפונקציות, למשל "log()", מחזירות תוצאה שהיא טרנספורמציה שלהן
טַעֲנָה. זה גורם לתרגול תכנות טוב. עם זאת, פעולות רבות יכולות להיות
נעשה "במקום" וזה עשוי להידרש כאשר מערכים גדולים נמצאים בשימוש והזיכרון נמצא
פרימיום. לנסיבות אלו המפעיל במקום() מסופק אשר מונע
העותק הנוסף ומאפשר לשנות את הארגומנט. לְמָשָׁל:

$x = log($array); # מערך $ לא מושפע
log(inplace($bigarray)); # $bigarray השתנה במקום

אזהרות:

1. חלות ההסתייגויות הרגילות לגבי הפניות כפולות.

2. ברור בשימוש עם פונקציות מסוימות שלא ניתן ליישם באתרן (למשל
"convolve()") עלולות להתרחש השפעות בלתי צפויות! אנו מנסים לציין "inplace()"-safe
פונקציות בתיעוד.

3. המרות סוגים, כגון "float()", עלולות לגרום להעתקה נסתרת.

הבטחה פשלות
אם כתבת פונקציה פשוטה ואתה לא רוצה שהיא תתפוצץ לך בפרצוף אם אתה
להעביר לו מספר פשוט ולא משתנה PDL. פשוט קרא לפונקציה topdl() ראשון
כדי שיהיה בטוח. לְמָשָׁל:

sub myfiddle { my $pdl = topdl(shift); $pdl->fiddle_foo(...); ... }

"topdl()" אינו מבצע העתקה אם משתנה pdl מועבר - הוא פשוט נופל דרך -
שזו כמובן ההתנהגות הרצויה. השגרה אינה הכרחית כמובן ברגיל
פונקציות מוגדרות על ידי משתמש שלא אכפת מהן הפנימיות.

השתמש ב-PDL::QuickStartp באינטרנט באמצעות שירותי onworks.net