PDL::Tipsp - ക്ലൗഡിൽ ഓൺലൈനായി

പട്ടിക:

NAME

PDL::നുറുങ്ങുകൾ - ഉപയോഗപ്രദമായ ആർക്കാനയുടെ ചെറിയ വിവരങ്ങൾ. പ്രോഗ്രാമിംഗ് ടിഡ്ബിറ്റുകളും മറ്റും.

സിനോപ്സിസ്

PDL ഉപയോഗിക്കുക;

# ഇവിടെ എന്ത് സംഭവിച്ചാലും.

വിവരണം

ഈ പേജ് പേൾ ഡാറ്റ ലാംഗ്വേജ് ഉപയോഗിക്കുന്നതിനുള്ള ഉപയോഗപ്രദമായ ഭാഷകളും സഹായകരമായ സൂചനകളും നുറുങ്ങുകളും രേഖപ്പെടുത്തുന്നു
vxNUMX

സഹായിക്കൂ
ഉള്ളിൽ "സഹായം" ഉപയോഗിക്കുക perldl or pdl2 അല്ലെങ്കിൽ കമാൻഡ് ലൈനിൽ നിന്ന് "pdldoc" പ്രോഗ്രാം ഉപയോഗിക്കുക
PerlDL ഡോക്യുമെന്റേഷനിലേക്കുള്ള പ്രവേശനത്തിനായി. പേജുകളുടെ HTML പതിപ്പുകളും ആയിരിക്കണം
നിലവിലുള്ളത് HtmlDocs/PDL PDL വിതരണത്തിന്റെ ഡയറക്ടറി. ഈ ഡയറക്ടറി കണ്ടെത്താൻ,
ഇനിപ്പറയുന്നവ പരീക്ഷിക്കുക

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

സൂചികയിലാക്കൽ പദപ്രയോഗങ്ങൾ
ഇനിപ്പറയുന്ന കോഡ് $a-ൽ ഒരു കൂട്ടം വെക്‌ടറുകളെ നോർമലൈസ് ചെയ്യുന്നു. ഇത് പരിഗണിക്കാതെ പ്രവർത്തിക്കുന്നു
$a യുടെ അളവ്.

$a /= $a->sumover->ഡമ്മി(0);

എന്ത് is യഥാർത്ഥത്തിൽ സംഭവിക്കുന്നത്?
കോഡ് യഥാർത്ഥത്തിൽ എന്താണ് ചെയ്യുന്നതെന്ന് നിങ്ങൾക്ക് കാണണമെങ്കിൽ, കമാൻഡ് പരീക്ഷിക്കുക

PDL::Core::set_debugging(1);

എവിടെയോ. ഇത് PDL-നുള്ള ഡീബഗ് വിവരങ്ങൾ STDOUT-ലേക്ക് വലിയ തോതിൽ പുറത്തുവിടുന്നു. വേണ്ടിയുള്ള പദ്ധതികൾ
ഭാവിയിൽ ഔട്ട്‌പുട്ട് റീഡയറക്‌ട് ചെയ്യുന്നത് സാധ്യമാക്കുന്നതും അത് സാധ്യമാക്കുന്നതും ഉൾപ്പെടുന്നു
കൂടുതൽ കൃത്യതയോടെ സന്ദേശങ്ങൾ തിരഞ്ഞെടുക്കുക.

പല സന്ദേശങ്ങളും "Basic/Core/pdlapi.c" എന്നതിൽ നിന്നാണ് വരുന്നത്, നിങ്ങൾക്ക് ഉറവിടം നോക്കാവുന്നതാണ്
എന്താണ് സംഭവിക്കുന്നത്.

ഈ മെക്കാനിസങ്ങളിൽ പ്രവർത്തിക്കാൻ നിങ്ങൾക്ക് എന്തെങ്കിലും അധിക സമയം ഉണ്ടെങ്കിൽ, pdl-porters മെയിലിംഗിനെ അറിയിക്കുക
പട്ടിക.

മെമ്മറി സേവിംഗ്സ്
നിങ്ങൾ ഒരു വലിയ പിഡിൽ ചില സൂചികകൾ തിരഞ്ഞെടുക്കുന്ന എന്തെങ്കിലും ആവർത്തനമായി പ്രവർത്തിക്കുകയാണെങ്കിൽ,
പോലെ

സമയത്ത്(1) {
$inds = എവിടെ ($a>0);
$a = $a->സൂചിക($inds);
$b = $b->സൂചിക($inds);
func($b,$a);
}

നിങ്ങൾ $b എന്നതിലേക്കല്ല എഴുതുന്നതെങ്കിൽ, ഇത് മാറ്റുന്നത് ഒരുപാട് മെമ്മറി ലാഭിക്കുന്നു

$b = $b->സൂചിക($inds)->sever;

പുതിയ രീതി "വിച്ഛേദിക്കുക" എന്നത് എഴുത്ത്-ബാക്ക് ബന്ധം മറക്കാൻ കാരണമാകുന്നു. അതു പോലെയാണ്
യഥാർത്ഥ പിഡിൽ മാറ്റുകയും അത് തിരികെ നൽകുകയും ചെയ്യുന്നതൊഴിച്ചാൽ പകർത്തുക).

തീർച്ചയായും, മുകളിൽ പറഞ്ഞവ ചെയ്യാനുള്ള ഏറ്റവും നല്ല മാർഗം

$inds = xvals ($a->നീളം);
സമയത്ത്(1) {
$inds0 = എവിടെ ($a>0);
$inds1 = $inds->സൂചിക($inds)->sever;
$a = $a0->സൂചിക($inds1);
$b = $b->സൂചിക($inds1)->sever;
func($b,$a);
}

$a യുടെ എല്ലാ താൽക്കാലിക സന്ദർഭങ്ങളും മെമ്മറിയിൽ സംരക്ഷിക്കില്ല. എന്നതിൽ "mandel.pl" കാണുക
ഒരു ഉദാഹരണത്തിനായി PerlDL വിതരണത്തിന്റെ ഡെമോസ് ഉപഡയറക്‌ടറി.

PP വേഗം
നിങ്ങൾ ശരിക്കും വേഗത്തിൽ പിപി കോഡ് എഴുതാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, നിങ്ങൾ ആദ്യം ചെയ്യേണ്ടത് ഉറപ്പാക്കുക എന്നതാണ്
നിങ്ങളുടെ സി കംപൈലറിന് ആവശ്യമായ ഒപ്റ്റിമൈസേഷനുകൾ ചെയ്യാൻ അനുമതിയുണ്ട്.

ഇത് അർത്ഥമാക്കുന്നത്, കഴിയുന്നത്ര വേരിയബിളുകൾ നിങ്ങൾ അനുവദിക്കണം എന്നതാണ്
രജിസ്റ്റർ ചെയ്യുന്നു:

ലൂപ്പ്(എ) %{
$a() += $COMP(foo_member) * $b()
%}

എന്നതിലേക്ക് വികസിക്കുന്നു

ഇതിനായി (i=0; i<10000; i++) {
a[i] += __privtrans->foo_member * b[i];
}

"എ" എന്ന് അനുമാനിക്കാൻ നിങ്ങളുടെ സി കംപൈലറിന് അനുവാദമില്ലാത്തതിനാൽ നിങ്ങൾക്ക് ചെയ്യാൻ കഴിയുന്ന ഏറ്റവും മോശമായ കാര്യമാണിത്.
വെക്‌ടറൈസേഷനെ പൂർണ്ണമായും തടയുന്ന "foo_member" ക്ലോബ്ബർ ചെയ്യുന്നില്ല. പകരം, ചെയ്യുക

ഫ്ലോട്ട് ഫൂ = $COMP(foo_member);
ലൂപ്പ്(എ) %{
$a() += foo * $b();
%}

ഇത് PP മൂലമുണ്ടാകുന്ന നിയന്ത്രണമല്ല, ANSI C സെമാന്റിക്‌സ് മൂലമാണ്. തീർച്ചയായും, നമുക്ക് പകർത്താം
ലോക്കൽ വേരിയബിളുകളിലേക്കും പുറകിലേക്കും struct എന്നാൽ അത് വളരെ വിചിത്രമായ കാര്യങ്ങൾക്ക് കാരണമാകും
ചിലപ്പോൾ.

ലൂപ്പുകൾ സംഘടിപ്പിക്കുന്നതിൽ മറ്റ് നിരവധി പ്രശ്നങ്ങളുണ്ട്.

ഫിക്‌സഡ് വിഡ്‌ത്ത് കാര്യങ്ങളും ഫിസിക്കൽ ചെയ്യാൻ PP-യെ പ്രാപ്‌തമാക്കാൻ ഞങ്ങൾ നിലവിൽ പദ്ധതിയിടുകയാണ്
പിഡിലുകൾ (ആദ്യ അളവുകളിൽ ലൂപ്പ് ചെയ്യുന്നത് കുറവായതിനാൽ വിലകുറഞ്ഞതായിരിക്കും
വ്യത്യസ്‌തമായ ഇൻക്രിമെന്റുകൾ, ഇത് ചെറിയ സംഖ്യയുള്ള മെഷീനുകളിൽ വ്യത്യാസം വരുത്തിയേക്കാം
രജിസ്റ്ററുകൾ).

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് PDL::Tipsp ഓൺലൈനായി ഉപയോഗിക്കുക