ഇതാണ് കമാൻഡ് PDL ::Dataflowp ഉബുണ്ടു ഓൺലൈൻ, ഫെഡോറ ഓൺലൈൻ, വിൻഡോസ് ഓൺലൈൻ എമുലേറ്റർ അല്ലെങ്കിൽ MAC OS ഓൺലൈൻ എമുലേറ്റർ എന്നിങ്ങനെയുള്ള ഞങ്ങളുടെ ഒന്നിലധികം സൗജന്യ ഓൺലൈൻ വർക്ക്സ്റ്റേഷനുകളിലൊന്ന് ഉപയോഗിച്ച് OnWorks സൗജന്യ ഹോസ്റ്റിംഗ് ദാതാവിൽ പ്രവർത്തിപ്പിക്കാനാകും.
പട്ടിക:
NAME
PDL::Dataflow -- ഡാറ്റാഫ്ലോ ഫിലോസഫിയുടെ വിവരണം
സിനോപ്സിസ്
pdl> $a = പൂജ്യങ്ങൾ(10);
pdl> $b = $a->സ്ലൈസ് ("2:4:2");
pdl> $b ++;
pdl> $a പ്രിന്റ് ചെയ്യുക;
[0 0 1 0 1 0 0 0
മുന്നറിയിപ്പ്
ഡാറ്റാഫ്ലോ വളരെ പരീക്ഷണാത്മകമാണ്. ഇതിന്റെ പല സവിശേഷതകളും 2.0 ന് അപ്രാപ്തമാക്കിയിരിക്കുന്നു, പ്രത്യേകിച്ച്
ഒരു ദിശയിലുള്ള ഡാറ്റാഫ്ലോയ്ക്കുള്ള കുടുംബങ്ങൾ. ഇതിനായി ഒരു ദിശയിലുള്ള ഡാറ്റാഫ്ലോ ഉപയോഗിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ
എന്തെങ്കിലും, ദയവായി ആദ്യം രചയിതാവിനെ ബന്ധപ്പെടുക, അത് എങ്ങനെ പ്രവർത്തനക്ഷമമാക്കാമെന്ന് ഞങ്ങൾ ആലോചിക്കും
വീണ്ടും.
രണ്ട്-ദിശയിലുള്ള ഡാറ്റാഫ്ലോ (ഇത് നടപ്പിലാക്കുന്നു ->കഷണം() മുതലായവ) പൂർണ്ണമായി പ്രവർത്തനക്ഷമമാണ്, എന്നിരുന്നാലും.
ചില പിഡിൽ മൂല്യങ്ങളുടെ ചില ഉപഗണങ്ങൾ നൽകുന്ന ഏതൊരു ഫംഗ്ഷനെ കുറിച്ചും a ഉണ്ടാക്കും
അങ്ങനെ ബന്ധിക്കുന്നു
$a = കുറച്ച് പിഡിൽ
$b = $a->സ്ലൈസ് ("ചില ഭാഗങ്ങൾ");
$b->സെറ്റ്(3,3,10);
$a-ലെ അനുബന്ധ മൂലകവും മാറ്റുന്നു. $b ചിലർക്ക് ഫലപ്രദമായി ഒരു ജാലകമായി മാറിയിരിക്കുന്നു
$a-ന്റെ ഉപഘടകങ്ങൾ. വ്യത്യസ്ത തരം ചെയ്യുന്ന നിങ്ങളുടെ സ്വന്തം ദിനചര്യകളും നിങ്ങൾക്ക് നിർവചിക്കാം
ഉപഗണങ്ങൾ. $b എന്നത് $a-ലേക്കുള്ള ജാലകമാകാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നില്ലെങ്കിൽ, നിങ്ങൾ അത് ചെയ്യണം
$b = $a->സ്ലൈസ്("ചില ഭാഗങ്ങൾ")->പകർപ്പ്;
രണ്ട് പിഡിലുകൾക്കിടയിലുള്ള എല്ലാ ഡാറ്റാഫ്ലോയും പകർത്തുന്നത് ഓഫാക്കുന്നു.
ഒരു ദിശയിലുള്ള ഡാറ്റാഫ്ലോയിലെ ബുദ്ധിമുട്ടുകൾ പോലുള്ള സീക്വൻസുകളുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു
$b = $a + 1;
$b ++;
സാധ്യമായ നിരവധി ഫലങ്ങൾ ഉള്ളിടത്ത് അർത്ഥശാസ്ത്രം അൽപ്പം മങ്ങുന്നു.
വിവരണം
ഡാറ്റാഫ്ലോ PDL2.0-ന് പുതിയതാണ്. ഡാറ്റാഫ്ലോയുടെ പിന്നിലെ അടിസ്ഥാന തത്വശാസ്ത്രം അതാണ്
> $a = pdl 2,3,4;
> $b = $a * 2;
> $b പ്രിന്റ് ചെയ്യുക
[2 3 4]
> $a->സെറ്റ്(0,5);
> പ്രിന്റ് $b;
[10 3 4]
പ്രവർത്തിക്കണം. അത് ഇല്ല. ഇത് ചെയ്യുന്നത് വളരെ ആശയക്കുഴപ്പമുണ്ടാക്കുമെന്ന് കരുതി
ഭാഷയുടെ തുടക്കക്കാരും ഇടയ്ക്കിടെ ഉപയോഗിക്കുന്നവരും. അതിനാൽ, നിങ്ങൾ വ്യക്തമായി ഓണാക്കേണ്ടതുണ്ട്
ഡാറ്റഫ്ലോ, അങ്ങനെ
> $a = pdl 2,3,4;
> $a->doflow();
> $b = $a * 2;
...
അപ്രതീക്ഷിത ഫലം ഉണ്ടാക്കുന്നു. ഈ പ്രമാണങ്ങളുടെ ബാക്കി ഭാഗങ്ങൾ വിവിധ സവിശേഷതകൾ വിശദീകരിക്കുന്നു
ഡാറ്റാഫ്ലോ നടപ്പാക്കലിന്റെ വിശദാംശങ്ങൾ.
മടിയനായ മൂല്യനിർണ്ണയം
മുകളിൽ പറഞ്ഞതുപോലുള്ള ഒന്ന് നിങ്ങൾ കണക്കാക്കുമ്പോൾ
> $a = pdl 2,3,4;
> $a->doflow();
> $b = $a * 2;
ഈ ഘട്ടത്തിൽ ഒന്നും കണക്കാക്കില്ല. $b യുടെ ഉള്ളടക്കങ്ങൾക്കുള്ള മെമ്മറി പോലും
അനുവദിച്ചിട്ടില്ല. ആജ്ഞ മാത്രം
> $b പ്രിന്റ് ചെയ്യുക
യഥാർത്ഥത്തിൽ $b കണക്കാക്കാൻ കാരണമാകും. ഇത് ചെയ്യുമ്പോൾ മനസ്സിൽ പിടിക്കേണ്ടത് പ്രധാനമാണ്
പ്രകടന അളവുകളും ബെഞ്ച്മാർക്കുകളും അതുപോലെ തന്നെ പിശകുകൾ ട്രാക്കുചെയ്യുമ്പോൾ.
ഈ പെരുമാറ്റത്തിന് ഒരു വിശദീകരണമുണ്ട്: ഇത് സൈക്കിളുകൾ ലാഭിച്ചേക്കാം, എന്നാൽ അതിലും പ്രധാനമായി,
ഇനിപ്പറയുന്നവ സങ്കൽപ്പിക്കുക:
> $a = pdl 2,3,4;
> $b = pdl 5,6,7;
> $c = $a + $b;
...
> $a->വലുപ്പം മാറ്റുക(4);
> $b->വലുപ്പം മാറ്റുക(4);
> പ്രിന്റ് $c;
ഇപ്പോൾ, രണ്ട് വലുപ്പം മാറ്റലുകൾക്കിടയിൽ $c മൂല്യനിർണ്ണയം നടത്തിയാൽ, പൊരുത്തപ്പെടാത്ത ഒരു പിശക് അവസ്ഥ
വലിപ്പങ്ങൾ സംഭവിക്കും.
നിലവിലെ പതിപ്പിൽ സംഭവിക്കുന്നത് $a വലുപ്പം മാറ്റുന്നത് $c-ൽ ഒരു ഫ്ലാഗ് ഉയർത്തുന്നു എന്നതാണ്:
"PDL_PARENTDIMSCHANGED" ഉം $b ഉം വീണ്ടും അതേ പതാക ഉയർത്തുന്നു. $c അടുത്തതായി വിലയിരുത്തുമ്പോൾ,
പതാകകൾ പരിശോധിച്ച് വീണ്ടും കണക്കുകൂട്ടൽ ആവശ്യമാണെന്ന് കണ്ടെത്തി.
തീർച്ചയായും, അലസമായ വിലയിരുത്തൽ ചിലപ്പോൾ ഡീബഗ്ഗിംഗ് കൂടുതൽ വേദനാജനകമാക്കും, കാരണം പിശകുകൾ ഉണ്ടാകാം
നിങ്ങൾ പ്രതീക്ഷിക്കാത്ത എവിടെയോ സംഭവിക്കുന്നു. പിശകുകൾക്കുള്ള മികച്ച സ്റ്റാക്ക് ട്രെയ്സ് ആണ്
PDL-ന് വേണ്ടി പ്രവർത്തിക്കുന്നു, അതിനാൽ നിങ്ങൾക്ക് ഒരു സ്വിച്ച് $PDL::traceevals ടോഗിൾ ചെയ്ത് നല്ലത് നേടാനാകും
പിശക് യഥാർത്ഥത്തിൽ എവിടെയായിരുന്നു എന്നതിന്റെ സൂചന.
കുടുംബങ്ങൾ
ഒരു ദിശയിലുള്ള ഡാറ്റാഫ്ലോയുടെ കൂടുതൽ സങ്കീർണ്ണമായ ആശയങ്ങളിൽ ഒന്നാണിത്. പരിഗണിക്കുക
ഇനിപ്പറയുന്ന കോഡ് ($a, $b എന്നിവ ഡാറ്റാഫ്ലോ പ്രവർത്തനക്ഷമമാക്കിയ pdls ആണ്):
$c = $a + $b;
$e = $c + 1;
$d = $c->ഡയഗണൽ();
$d ++;
$f = $c + 1;
$e, $f എന്നിവയിൽ ഇപ്പോൾ എന്താണ് അടങ്ങിയിരിക്കേണ്ടത്? $a മാറ്റുകയും വീണ്ടും കണക്കുകൂട്ടൽ നടത്തുകയും ചെയ്യുമ്പോൾ എന്താണ്
പ്രവർത്തനക്ഷമമാക്കി.
നിങ്ങൾ പ്രതീക്ഷിക്കുന്നത് പോലെ ഡാറ്റാഫ്ലോ പ്രവർത്തിക്കുന്നതിന്, തികച്ചും വിചിത്രമായ ഒരു ആശയം ഉണ്ടായിരിക്കണം
പരിചയപ്പെടുത്തി: കുടുംബങ്ങൾ. നമുക്ക് ഒരു ഡയഗ്രം ഉണ്ടാക്കാം:
ab
\/
c
/|
/ |
ed
ആദ്യത്തെ മൂന്ന് വരികൾക്ക് ശേഷം PDL യഥാർത്ഥത്തിൽ മെമ്മറിയിൽ ഉള്ളത് ഇതാണ്. $d മാറുമ്പോൾ,
$c മാറ്റാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു, പക്ഷേ $e മാറ്റാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നില്ല, കാരണം അത് ഇതിനകം ഗ്രാഫിൽ ഉണ്ട്. അത്
എന്തുകൊണ്ടാണ് നിങ്ങൾ അത് മാറ്റാൻ ആഗ്രഹിക്കുന്നില്ല എന്ന് ഇപ്പോൾ വ്യക്തമല്ലായിരിക്കാം, എന്നാൽ 40 വരി കോഡ് ഉണ്ടെങ്കിൽ
2-ഉം 4-ഉം വരികൾക്കിടയിൽ, നിങ്ങൾ. അതിനാൽ ഞങ്ങൾ $c, $d എന്നിവയുടെ ഒരു പകർപ്പ് ഉണ്ടാക്കേണ്ടതുണ്ട്:
ab
\/
സി' . . . സി
/| |\
/ | | \
ed' . . . df
ഒറിജിനൽ c, d എന്നിവ ഒബ്ജക്റ്റുകളുമായി പൊരുത്തപ്പെടാത്തതിനാൽ ഞങ്ങൾ പ്രൈം ചെയ്തത് ശ്രദ്ധിക്കുക
$c, $d എന്നിവയിൽ. കൂടാതെ, രണ്ട് ഒബ്ജക്റ്റുകൾക്കിടയിലുള്ള ഡോട്ട് ഇട്ട വരികൾ ശ്രദ്ധിക്കുക: $a ആയിരിക്കുമ്പോൾ
മാറ്റുകയും ഈ ഡയഗ്രം വീണ്ടും മൂല്യനിർണ്ണയം നടത്തുകയും ചെയ്യുന്നു, $c ശരിക്കും c'ന്റെ മൂല്യം ലഭിക്കുന്നു
ഡയഗണൽ ഇൻക്രിമെന്റ്.
മുകളിൽ പറഞ്ഞവയെ സാമാന്യവൽക്കരിക്കാൻ, ഒരു പിഡിൽ പരിവർത്തനം ചെയ്യപ്പെടുമ്പോഴെല്ലാം, അതായത് അതിന്റെ യഥാർത്ഥ *മൂല്യം* ആയിരിക്കുമ്പോൾ
നിർബന്ധിച്ച് മാറ്റി (റഫറൻസ് മാത്രമല്ല:
$d = $d + 1
തികച്ചും വ്യത്യസ്തമായ ഫലം പുറപ്പെടുവിക്കും ($c ഉം $d ഉം ഇനി ബന്ധിക്കപ്പെടില്ല
$d .= $d + 1
$d++ എന്നതിന് തുല്യമായ ഫലം ലഭിക്കും), മറ്റെല്ലാ പിഡിലുകളും ചേർന്ന ഒരു "കുടുംബം"
ഒരു ദ്വിമുഖ പരിവർത്തനം വഴി മ്യൂട്ടേറ്റഡ് പിഡിൽ സൃഷ്ടിക്കപ്പെടുകയും അവയെല്ലാം പകർത്തുകയും ചെയ്യുന്നു.
ഒറിജിനൽ pdl-ന്റെ ഉപസെറ്റ് തിരഞ്ഞെടുക്കുന്ന എല്ലാ സ്ലൈസുകളും പരിവർത്തനങ്ങളും രണ്ട് വഴികളാണ്.
മാട്രിക്സ് വിപരീതമായിരിക്കണം. കണക്ക് ഓപ്പറേറ്റർമാരില്ല.
ഉറവിടങ്ങൾ
മുമ്പത്തെ വിഭാഗത്തിൽ നിങ്ങളോട് പറഞ്ഞത് തികച്ചും ശരിയല്ല: വിവരിച്ച പെരുമാറ്റം
*എപ്പോഴും* നിങ്ങൾ ആഗ്രഹിക്കുന്നത് അല്ല. ചിലപ്പോൾ നിങ്ങൾക്ക് ഒരു ഡാറ്റ "ഉറവിടം" ഉണ്ടായിരിക്കാൻ താൽപ്പര്യമുണ്ടാകാം:
$a = pdl 2,3,4; $b = pdl 5,6,7;
$c = $a + $b;
ലൈൻ ($ സി);
ഇപ്പോൾ, $a മാറാൻ പോകുകയാണെന്നും അതിന്റെ കുട്ടികൾ മാറണമെന്ന് നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെന്നും നിങ്ങൾക്കറിയാമെങ്കിൽ
അത്, നിങ്ങൾക്കത് ഒരു ഡാറ്റാ ഉറവിടമായി പ്രഖ്യാപിക്കാൻ കഴിയും (എക്സ്എക്സ്എക്സ്എക്സ് നിലവിലെ പതിപ്പിൽ നടപ്പിലാക്കിയിട്ടില്ല):
$a->വിവര ഉറവിടം(1);
ഇതിനുശേഷം, $a++ അല്ലെങ്കിൽ $a .= എന്തെങ്കിലും ഒരു പുതിയ കുടുംബത്തെ സൃഷ്ടിക്കില്ല, പക്ഷേ $a-യിൽ മാറ്റം വരുത്തുകയും മുറിക്കുകയും ചെയ്യും
അതിന്റെ മുൻ മാതാപിതാക്കളുമായുള്ള ബന്ധം. അതിന്റെ എല്ലാ കുട്ടികളും അതിന്റെ നിലവിലെ മൂല്യം പിന്തുടരും.
അതിനാൽ മുൻ വിഭാഗത്തിലെ $c ഒരു ഉറവിടമായി പ്രഖ്യാപിച്ചിരുന്നെങ്കിൽ, $e, $f എന്നിവ നിലനിൽക്കും
തുല്യമാണ്.
ബാധ്യസ്ഥരാക്കൽ
ഇവന്റുകൾ ബന്ധിപ്പിക്കുന്നതിനുള്ള കഴിവില്ലാതെ ഒരു ഡാറ്റാഫ്ലോ സംവിധാനം വളരെ ഉപയോഗപ്രദമാകില്ല
ഡാറ്റ മാറ്റി. അതിനാൽ, ഞങ്ങൾ അത്തരമൊരു സംവിധാനം നൽകുന്നു:
> $a = pdl 2,3,4
> $b = $a + 1;
> $c = $b * 2;
> $c->ബൈൻഡ് ( ഉപ { പ്രിന്റ് "A ഇപ്പോൾ: $a, C ഇപ്പോൾ: $c\n" } )
> PDL::dowhenidle();
എ ഇപ്പോൾ: [2,3,4], സി ഇപ്പോൾ: [6 8 10]
> $a->സെറ്റ്(0,1);
> $a->സെറ്റ്(1,1);
> PDL::dowhenidle();
എ ഇപ്പോൾ: [1,1,4], സി ഇപ്പോൾ: [4 4 10]
PDL::dowhenidle സമയത്ത് മാത്രം എങ്ങനെയാണ് കോൾബാക്കുകൾ വിളിക്കപ്പെടുന്നത് എന്ന് ശ്രദ്ധിക്കുക. ഇന്റർഫേസ് ചെയ്യാനുള്ള എളുപ്പവഴി
ഇത് പേൾ ഇവന്റ് ലൂപ്പ് മെക്കാനിസങ്ങൾ (Tk പോലുള്ളവ) ആസൂത്രണം ചെയ്യുന്നു.
ഈ സവിശേഷതയ്ക്കായി നിരവധി തരം ഉപയോഗങ്ങളുണ്ട്: ഉദാഹരണത്തിന് സ്വയം അപ്ഡേറ്റ് ചെയ്യുന്ന ഗ്രാഫുകൾ.
ബ്ലാ ബ്ലാ ബ്ലാ XXX കൂടുതൽ വിശദീകരണം
പരിമിതികൾ
ഡാറ്റാഫ്ലോ പേളിന് മുകളിൽ പരിമിതമായ കൂട്ടിച്ചേർക്കലാണ്. കൂടുതൽ ശുദ്ധീകരിക്കാൻ
കൂടാതെ, പേളിന്റെ ഇന്റേണലുകൾ കുറച്ച് ഹാക്ക് ചെയ്യേണ്ടതുണ്ട്. ഒരു യഥാർത്ഥ നടപ്പാക്കൽ ആയിരിക്കും
ഉൾപ്പെടെ എല്ലാറ്റിന്റെയും ഒഴുക്ക് പ്രാപ്തമാക്കുക
ഡാറ്റ
ഡാറ്റ വലിപ്പം
ഡാറ്റാ ടൈപ്പ്
പ്രവർത്തനങ്ങൾ
ഇപ്പോൾ ഞങ്ങൾക്ക് ആദ്യത്തെ രണ്ട് മാത്രമേ ഉള്ളൂ (ഏയ്, രണ്ട് മാസത്തിനുള്ളിൽ 50% മോശമല്ല;)
ഇതും തനിയെ ഉപയോഗപ്രദമാണ്. എന്നിരുന്നാലും, പ്രത്യേകിച്ച് അവസാനത്തേത് അത് മുതൽ അഭികാമ്യമാണ്
സ്ഥലത്തുനിന്നും മറ്റൊരിടത്തേക്ക് ഒഴുകിപ്പോകാനുള്ള സാധ്യത കൂട്ടുകയും പലതും ഉണ്ടാക്കുകയും ചെയ്യും
കാര്യങ്ങൾ കൂടുതൽ വഴക്കമുള്ളതാണ്.
ബാക്കിയുള്ളവ പ്രവർത്തിക്കുന്നതിന്, ഡാറ്റാഫ്ലോയുടെ ഇന്റേണലുകൾ ഒരു ആയി മാറ്റേണ്ടതുണ്ട്
കൂടുതൽ പൊതു ചട്ടക്കൂട്.
കൂടാതെ, കൃത്യസമയത്ത് ഡാറ്റ ഒഴുകാൻ കഴിയുന്നത് നല്ലതായിരിക്കും, വ്യക്തമായ പോലെ (അങ്ങനെ നിങ്ങൾക്ക് കഴിയും
എല്ലാത്തരം സിഗ്നൽ പ്രോസസ്സിംഗ് കാര്യങ്ങളും എളുപ്പത്തിൽ നിർവചിക്കുക).
onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് PDL::Dataflowp ഓൺലൈനായി ഉപയോഗിക്കുക