കഴിഞ്ഞ വേനൽക്കാലത്ത് ഞാൻ പങ്കെടുത്തു Google സമ്മർ കോഡ് - ഗൂഗിളിൽ നിന്നുള്ള വിദ്യാർത്ഥികൾക്കുള്ള ഒരു പ്രോഗ്രാം. എല്ലാ വർഷവും, സംഘാടകർ നിരവധി ഓപ്പൺ സോഴ്സ് പ്രോജക്ടുകൾ തിരഞ്ഞെടുക്കുന്നു, അത്തരം അറിയപ്പെടുന്ന ഓർഗനൈസേഷനുകളിൽ നിന്ന് ഉൾപ്പെടെ Boost.org и ലിനക്സ് ഫ .ണ്ടേഷൻ. ഈ പ്രോജക്ടുകളിൽ പ്രവർത്തിക്കാൻ ലോകമെമ്പാടുമുള്ള വിദ്യാർത്ഥികളെ Google ക്ഷണിക്കുന്നു. 

ഗൂഗിൾ സമ്മർ ഓഫ് കോഡ് 2019-ൽ ഒരു പങ്കാളി എന്ന നിലയിൽ ഞാൻ ലൈബ്രറിയിൽ ഒരു പ്രൊജക്റ്റ് ചെയ്തു അൽഗാ സംഘടനയുമായി Haskell.org, ഹാസ്കെൽ ഭാഷ വികസിപ്പിക്കുന്നത് - ഏറ്റവും പ്രശസ്തമായ ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ ഒന്ന്. ആൽഗ പ്രതിനിധീകരിക്കുന്ന ഒരു ലൈബ്രറിയാണ് സുരക്ഷിതമായി ടൈപ്പ് ചെയ്യുക ഹാസ്കെല്ലിലെ ഗ്രാഫുകളുടെ പ്രാതിനിധ്യം. ഇത് ഉപയോഗിക്കുന്നു, ഉദാഹരണത്തിന്, ഇൻ സെമാന്റിക് - കോഡ് അടിസ്ഥാനമാക്കി സെമാൻ്റിക് ട്രീകളും കോളുകളും ഡിപൻഡൻസി ഗ്രാഫുകളും നിർമ്മിക്കുന്ന ഒരു ഗിത്തബ് ലൈബ്രറി അവ താരതമ്യം ചെയ്യാം. ബൈപാർട്ടൈറ്റ് ഗ്രാഫുകൾക്കും ആ പ്രാതിനിധ്യത്തിനായി അൽഗോരിതങ്ങൾക്കും ഒരു ടൈപ്പ്-സേഫ് പ്രാതിനിധ്യം ചേർക്കുക എന്നതായിരുന്നു എൻ്റെ പ്രോജക്റ്റ്. 

ഈ പോസ്റ്റിൽ ഞാൻ ഹസ്കെല്ലിലെ ബൈപാർട്ടൈനസിനായി ഒരു ഗ്രാഫ് പരിശോധിക്കുന്നതിനുള്ള ഒരു അൽഗോരിതം നടപ്പിലാക്കുന്നതിനെക്കുറിച്ച് സംസാരിക്കും. അൽഗോരിതം ഏറ്റവും അടിസ്ഥാനപരമായ ഒന്നാണെങ്കിലും, അത് ഒരു ഫങ്ഷണൽ ശൈലിയിൽ മനോഹരമായി നടപ്പിലാക്കാൻ എനിക്ക് നിരവധി ആവർത്തനങ്ങൾ എടുക്കുകയും വളരെയധികം ജോലികൾ ആവശ്യമായി വരികയും ചെയ്തു. തൽഫലമായി, മോണാഡ് ട്രാൻസ്ഫോർമറുകൾ ഉപയോഗിച്ച് ഒരു നടപ്പാക്കലിൽ ഞാൻ സ്ഥിരതാമസമാക്കി. 

എന്നെക്കുറിച്ച്

എൻ്റെ പേര് വാസിലി അൽഫെറോവ്, ഞാൻ സെൻ്റ് പീറ്റേഴ്‌സ്ബർഗ് എച്ച്എസ്ഇയിലെ നാലാം വർഷ വിദ്യാർത്ഥിയാണ്. നേരത്തെ ബ്ലോഗിൽ എഴുതിയിരുന്നു പാരാമീറ്റർ ചെയ്ത അൽഗോരിതങ്ങളെക്കുറിച്ചുള്ള എൻ്റെ പ്രോജക്റ്റിനെക്കുറിച്ച് и സൂരിഹാക്കിലേക്കുള്ള യാത്രയെക്കുറിച്ച്. ഇപ്പോൾ ഞാൻ ഇൻ്റേൺഷിപ്പിലാണ് ബെർഗൻ സർവകലാശാല നോർവേയിൽ, അവിടെ ഞാൻ പ്രശ്നത്തിലേക്കുള്ള സമീപനങ്ങളിൽ പ്രവർത്തിക്കുന്നു ലിസ്റ്റ് കളറിംഗ്. പാരാമീറ്ററൈസ്ഡ് അൽഗോരിതങ്ങളും ഫങ്ഷണൽ പ്രോഗ്രാമിംഗും എൻ്റെ താൽപ്പര്യങ്ങളിൽ ഉൾപ്പെടുന്നു.

അൽഗോരിതം നടപ്പിലാക്കുന്നതിനെക്കുറിച്ച്

മുൻവാചകം

പ്രോഗ്രാമിൽ പങ്കെടുക്കുന്ന വിദ്യാർത്ഥികളെ ബ്ലോഗ് ചെയ്യാൻ ശക്തമായി പ്രോത്സാഹിപ്പിക്കുന്നു. അവർ എനിക്ക് ബ്ലോഗിന് ഒരു പ്ലാറ്റ്ഫോം നൽകി ഹസ്കെലിൻ്റെ വേനൽക്കാലം. ഈ ലേഖനം ഒരു വിവർത്തനമാണ് ലേഖനങ്ങൾ, ഞാൻ അവിടെ ജൂലൈയിൽ ഇംഗ്ലീഷിൽ എഴുതിയത്, ഒരു ചെറിയ ആമുഖത്തോടെ. 

സംശയാസ്‌പദമായ കോഡുള്ള പുൾ അഭ്യർത്ഥന കണ്ടെത്താനാകും ഇവിടെ.

എൻ്റെ ജോലിയുടെ ഫലങ്ങളെക്കുറിച്ച് നിങ്ങൾക്ക് വായിക്കാം (ഇംഗ്ലീഷിൽ) ഇവിടെ.

ഈ പോസ്റ്റ് ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗിലെ അടിസ്ഥാന ആശയങ്ങൾ വായനക്കാരനെ പരിചയപ്പെടുത്താൻ ഉദ്ദേശിച്ചുള്ളതാണ്, എന്നിരുന്നാലും സമയം വരുമ്പോൾ ഉപയോഗിച്ച എല്ലാ പദങ്ങളും ഞാൻ ഓർക്കാൻ ശ്രമിക്കും.

ദ്വികക്ഷിത്വത്തിനായി ഗ്രാഫുകൾ പരിശോധിക്കുന്നു 

ബൈപാർട്ടൈനസിനായി ഒരു ഗ്രാഫ് പരിശോധിക്കുന്നതിനുള്ള ഒരു അൽഗോരിതം സാധാരണയായി അൽഗരിതങ്ങളെക്കുറിച്ചുള്ള ഒരു കോഴ്സിൽ ഏറ്റവും ലളിതമായ ഗ്രാഫ് അൽഗോരിതങ്ങളിലൊന്നായി നൽകും. അദ്ദേഹത്തിൻ്റെ ആശയം നേരായതാണ്: ആദ്യം ഞങ്ങൾ എങ്ങനെയെങ്കിലും ഇടത് അല്ലെങ്കിൽ വലത് പങ്കിടലിൽ ലംബങ്ങൾ ഇടുന്നു, കൂടാതെ ഒരു വൈരുദ്ധ്യമുള്ള അഗ്രം കണ്ടെത്തുമ്പോൾ, ഗ്രാഫ് ദ്വികക്ഷിയല്ലെന്ന് ഞങ്ങൾ ഉറപ്പിച്ചു പറയുന്നു.

കുറച്ചുകൂടി വിശദമായി: ആദ്യം നമ്മൾ ഇടത് ഷെയറിൽ കുറച്ച് വെർട്ടെക്സ് ഇടുക. വ്യക്തമായും, ഈ ശീർഷത്തിൻ്റെ എല്ലാ അയൽക്കാരും വലത് ലോബിൽ കിടക്കണം. കൂടാതെ, ഈ ശീർഷത്തിൻ്റെ അയൽവാസികളുടെ എല്ലാ അയൽക്കാരും ഇടത് ലോബിൽ കിടക്കണം, മുതലായവ. ഞങ്ങൾ ആരംഭിച്ച ശീർഷകത്തിൻ്റെ കണക്റ്റുചെയ്‌ത ഘടകത്തിൽ ഞങ്ങൾ അയൽക്കാരെ നിയോഗിച്ചിട്ടില്ലാത്ത വെർട്ടീസുകൾ ഉള്ളിടത്തോളം കാലം ഞങ്ങൾ വെർട്ടിസുകളിലേക്ക് ഷെയറുകൾ അസൈൻ ചെയ്യുന്നത് തുടരും. അതിനുശേഷം, ബന്ധിപ്പിച്ച എല്ലാ ഘടകങ്ങൾക്കുമായി ഞങ്ങൾ ഈ പ്രവർത്തനം ആവർത്തിക്കുന്നു.

ഒരേ പാർട്ടീഷനിൽ വീഴുന്ന ലംബങ്ങൾക്കിടയിൽ ഒരു എഡ്ജ് ഉണ്ടെങ്കിൽ, ഗ്രാഫിൽ ഒരു വിചിത്ര ചക്രം കണ്ടെത്തുന്നത് ബുദ്ധിമുട്ടുള്ള കാര്യമല്ല, ഇത് ഒരു ബൈപാർട്ടൈറ്റ് ഗ്രാഫിൽ പരക്കെ അറിയപ്പെടുന്ന (തീർച്ചയായും) അസാധ്യമാണ്. അല്ലെങ്കിൽ, നമുക്ക് ശരിയായ ഒരു പാർട്ടീഷൻ ഉണ്ട്, അതായത് ഗ്രാഫ് ബൈപാർട്ടൈറ്റ് ആണ്.

സാധാരണയായി, ഈ അൽഗോരിതം ഉപയോഗിച്ചാണ് നടപ്പിലാക്കുന്നത് വീതി ആദ്യ തിരയൽ അഥവാ ആഴത്തിലുള്ള ആദ്യ തിരയൽ. നിർബന്ധിത ഭാഷകളിൽ, ആഴത്തിലുള്ള ആദ്യ തിരയൽ സാധാരണയായി ഉപയോഗിക്കാറുണ്ട്, കാരണം ഇത് അൽപ്പം ലളിതവും അധിക ഡാറ്റാ ഘടനകൾ ആവശ്യമില്ല. കൂടുതൽ പരമ്പരാഗതമായതിനാൽ ഡെപ്ത് ഫസ്റ്റ് സെർച്ചും ഞാൻ തിരഞ്ഞെടുത്തു.

അങ്ങനെ, ഞങ്ങൾ ഇനിപ്പറയുന്ന സ്കീമിൽ എത്തി. ആഴത്തിലുള്ള ആദ്യ തിരയൽ ഉപയോഗിച്ച് ഞങ്ങൾ ഗ്രാഫിൻ്റെ ശീർഷകങ്ങളിലൂടെ സഞ്ചരിക്കുകയും അവയ്ക്ക് ഷെയറുകൾ നൽകുകയും ചെയ്യുന്നു, ഞങ്ങൾ അരികിലൂടെ നീങ്ങുമ്പോൾ ഷെയറിൻ്റെ എണ്ണം മാറ്റുന്നു. ഇതിനകം ഒരു ഷെയർ അസൈൻ ചെയ്‌തിരിക്കുന്ന ഒരു വെർട്ടെക്‌സിലേക്ക് ഒരു ഷെയർ അസൈൻ ചെയ്യാൻ ശ്രമിക്കുകയാണെങ്കിൽ, ഗ്രാഫ് ബൈപാർട്ടൈറ്റ് അല്ലെന്ന് നമുക്ക് സുരക്ഷിതമായി പറയാൻ കഴിയും. എല്ലാ വെർട്ടീസുകൾക്കും ഒരു ഷെയർ നൽകുകയും എല്ലാ അരികുകളും നോക്കുകയും ചെയ്ത നിമിഷം, ഞങ്ങൾക്ക് ഒരു നല്ല പാർട്ടീഷൻ ഉണ്ട്.

കണക്കുകൂട്ടലുകളുടെ ശുദ്ധി

എല്ലാ കണക്കുകൂട്ടലുകളും ഉണ്ടെന്ന് ഹസ്കെലിൽ ഞങ്ങൾ അനുമാനിക്കുന്നു ശുദ്ധമായ. എന്നിരുന്നാലും, ഇത് യഥാർത്ഥത്തിൽ അങ്ങനെയാണെങ്കിൽ, സ്ക്രീനിൽ ഒന്നും പ്രിൻ്റ് ചെയ്യാൻ ഞങ്ങൾക്ക് ഒരു മാർഗവുമില്ല. എല്ലാം, വൃത്തിയാക്കുക കണക്കുകൾ വളരെ അലസമായതിനാൽ ഒന്നുമില്ല ശുദ്ധമായ എന്തെങ്കിലും കണക്കാക്കാനുള്ള കാരണങ്ങൾ. പ്രോഗ്രാമിൽ സംഭവിക്കുന്ന എല്ലാ കണക്കുകൂട്ടലുകളും എങ്ങനെയെങ്കിലും നിർബന്ധിതമാണ് "അശുദ്ധം" മൊണാഡ് IO.

കണക്കുകൂട്ടലുകളെ പ്രതിനിധീകരിക്കുന്നതിനുള്ള ഒരു മാർഗമാണ് മൊണാഡുകൾ ഇഫക്റ്റുകൾ ഹാസ്കെലിൽ. അവ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് വിശദീകരിക്കുന്നത് ഈ പോസ്റ്റിൻ്റെ പരിധിക്കപ്പുറമാണ്. നല്ലതും വ്യക്തവുമായ ഒരു വിവരണം ഇംഗ്ലീഷിൽ വായിക്കാം ഇവിടെ.

IO പോലുള്ള ചില മൊണാഡുകൾ കംപൈലർ മാജിക്കിലൂടെ നടപ്പിലാക്കുമ്പോൾ, മറ്റുള്ളവയെല്ലാം സോഫ്റ്റ്‌വെയറിൽ നടപ്പിലാക്കിയിട്ടുണ്ടെന്നും അവയിലെ എല്ലാ കണക്കുകൂട്ടലുകളും ശുദ്ധമാണെന്നും ഞാൻ ഇവിടെ സൂചിപ്പിക്കാൻ ആഗ്രഹിക്കുന്നു.

ധാരാളം ഇഫക്റ്റുകൾ ഉണ്ട്, ഓരോന്നിനും അതിൻ്റേതായ മോണാഡ് ഉണ്ട്. ഇത് വളരെ ശക്തവും മനോഹരവുമായ ഒരു സിദ്ധാന്തമാണ്: എല്ലാ മൊണാഡുകളും ഒരേ ഇൻ്റർഫേസ് നടപ്പിലാക്കുന്നു. ഇനിപ്പറയുന്ന മൂന്ന് മൊണാഡുകളെക്കുറിച്ച് ഞങ്ങൾ സംസാരിക്കും:

• ഒന്നുകിൽ ea എന്നത് ടൈപ്പ് a യുടെ മൂല്യം നൽകുന്നതോ e തരത്തിൻ്റെ ഒരു അപവാദം നൽകുന്നതോ ആയ ഒരു കണക്കുകൂട്ടലാണ്. ഈ മൊണാഡിൻ്റെ പെരുമാറ്റം നിർബന്ധിത ഭാഷകളിലെ ഒഴിവാക്കലുകൾ കൈകാര്യം ചെയ്യുന്നതുമായി വളരെ സാമ്യമുള്ളതാണ്: പിശകുകൾ പിടിക്കപ്പെടുകയോ കൈമാറുകയോ ചെയ്യാം. പ്രധാന വ്യത്യാസം, ഹാസ്കെലിലെ സ്റ്റാൻഡേർഡ് ലൈബ്രറിയിൽ മൊണാഡ് പൂർണ്ണമായും യുക്തിസഹമായി നടപ്പിലാക്കുന്നു, അതേസമയം നിർബന്ധിത ഭാഷകൾ സാധാരണയായി ഓപ്പറേറ്റിംഗ് സിസ്റ്റം മെക്കാനിസങ്ങൾ ഉപയോഗിക്കുന്നു.
• സ്റ്റേറ്റ് sa എന്നത് ടൈപ്പ് എയുടെ മൂല്യം നൽകുന്ന ഒരു കണക്കുകൂട്ടലാണ്, കൂടാതെ s-ൻ്റെ മാറ്റാവുന്ന അവസ്ഥയിലേക്ക് ആക്‌സസ് ഉണ്ട്.
• ഒരുപക്ഷേ എ. നത്തിംഗ് റിട്ടേൺ ചെയ്യുന്നതിലൂടെ എപ്പോൾ വേണമെങ്കിലും തടസ്സപ്പെടാവുന്ന ഒരു കണക്കുകൂട്ടൽ മെയ്ബി മോണാഡ് പ്രകടിപ്പിക്കുന്നു. എന്നിരുന്നാലും, ഒരുപക്ഷേ തരത്തിനായുള്ള MonadPlus ക്ലാസ് നടപ്പിലാക്കുന്നതിനെക്കുറിച്ച് ഞങ്ങൾ സംസാരിക്കും, അത് വിപരീത ഫലം പ്രകടിപ്പിക്കുന്നു: ഒരു നിർദ്ദിഷ്ട മൂല്യം തിരികെ നൽകിക്കൊണ്ട് എപ്പോൾ വേണമെങ്കിലും തടസ്സപ്പെടുത്താവുന്ന ഒരു കണക്കുകൂട്ടലാണ് ഇത്.

അൽഗോരിതം നടപ്പിലാക്കൽ

ഞങ്ങൾക്ക് രണ്ട് ഡാറ്റ തരങ്ങളുണ്ട്, ഗ്രാഫ് എ, ബിഗ്രാഫ് എബി, അവയിൽ ആദ്യത്തേത് ടൈപ്പ് എ മൂല്യങ്ങളുള്ള ലംബങ്ങളുള്ള ഗ്രാഫുകളെ പ്രതിനിധീകരിക്കുന്നു, രണ്ടാമത്തേത് ടൈപ്പ് എ, വലത് മൂല്യങ്ങൾ ഉപയോഗിച്ച് ലേബൽ ചെയ്ത ഇടത് വശത്തുള്ള വെർട്ടിസുകളുള്ള ബൈപാർട്ടൈറ്റ് ഗ്രാഫുകളെ പ്രതിനിധീകരിക്കുന്നു. - തരം ബി മൂല്യങ്ങൾ ഉപയോഗിച്ച് ലേബൽ ചെയ്തിരിക്കുന്ന സൈഡ് വെർട്ടിസുകൾ.

ഇവ ആൽഗ ലൈബ്രറിയിൽ നിന്നുള്ള തരങ്ങളല്ല. ഡയറക്‌ട് ചെയ്യാത്ത ബൈപാർട്ടൈറ്റ് ഗ്രാഫുകൾക്ക് ആൽഗയ്ക്ക് ഒരു പ്രാതിനിധ്യം ഇല്ല. വ്യക്തതയ്ക്കായി ഞാൻ ഇത്തരത്തിലുള്ള തരങ്ങൾ ഉണ്ടാക്കി.

ഇനിപ്പറയുന്ന ഒപ്പുകളുള്ള സഹായ പ്രവർത്തനങ്ങളും ഞങ്ങൾക്ക് ആവശ്യമാണ്:

-- Список соседей данной вершины.
neighbours :: Ord a => a -> Graph a -> [a]

-- Построить двудольный граф по графу и функции, для каждой вершины
-- выдающей её долю и пометку в новой доле, игнорируя конфликтные рёбра.
toBipartiteWith :: (Ord a, Ord b, Ord c) => (a -> Either b c)
                                         -> Graph a
                                         -> Bigraph b c

-- Список вершин в графе
vertexList :: Ord a => Graph a -> [a]
Сигнатура функции, которую мы будем писать, выглядит так:

type OddCycle a = [a]
detectParts :: Ord a => Graph a -> Either (OddCycle a) (Bigraph a a)

ഡെപ്ത്-ആദ്യത്തെ തിരച്ചിലിനിടെ ഞങ്ങൾ വൈരുദ്ധ്യമുള്ള ഒരു എഡ്ജ് കണ്ടെത്തിയാൽ, വിചിത്രമായ സൈക്കിൾ റിക്കർഷൻ സ്റ്റാക്കിന് മുകളിലാണെന്ന് കാണാൻ എളുപ്പമാണ്. അങ്ങനെ, അത് പുനഃസ്ഥാപിക്കുന്നതിന്, റിക്കർഷൻ സ്റ്റാക്ക് മുതൽ അവസാനത്തെ ശീർഷത്തിൻ്റെ ആദ്യ സംഭവം വരെയുള്ള എല്ലാ കാര്യങ്ങളും ഞങ്ങൾ മുറിച്ചു മാറ്റേണ്ടതുണ്ട്.

ഓരോ ശീർഷകത്തിനും ഷെയർ നമ്പറുകളുടെ ഒരു അനുബന്ധ ശ്രേണി നിലനിർത്തിക്കൊണ്ട് ഞങ്ങൾ ആഴത്തിലുള്ള ആദ്യ തിരയൽ നടപ്പിലാക്കുന്നു. ഞങ്ങൾ തിരഞ്ഞെടുത്ത മൊണാഡിൻ്റെ ഫങ്‌റ്റർ ക്ലാസ് നടപ്പിലാക്കുന്നതിലൂടെ ആവർത്തന സ്റ്റാക്ക് സ്വയമേവ പരിപാലിക്കപ്പെടും: ആവർത്തന ഫംഗ്‌ഷനിൽ നിന്ന് മടങ്ങിയെത്തിയ ഫലത്തിലേക്ക് പാതയിൽ നിന്നുള്ള എല്ലാ വെർട്ടീസുകളും ഇട്ടാൽ മതിയാകും.

ഒന്നുകിൽ മൊണാഡ് ഉപയോഗിക്കുക എന്നതായിരുന്നു എൻ്റെ ആദ്യ ആശയം, അത് നമുക്ക് ആവശ്യമുള്ള ഇഫക്റ്റുകൾ കൃത്യമായി നടപ്പിലാക്കുന്നതായി തോന്നുന്നു. ഞാൻ എഴുതിയ ആദ്യ നടപ്പാക്കൽ ഈ ഓപ്ഷനുമായി വളരെ അടുത്തായിരുന്നു. വാസ്തവത്തിൽ, എനിക്ക് ഒരു ഘട്ടത്തിൽ അഞ്ച് വ്യത്യസ്ത നിർവ്വഹണങ്ങൾ ഉണ്ടായിരുന്നു, ഒടുവിൽ മറ്റൊന്നിൽ സ്ഥിരതാമസമാക്കി.

ആദ്യം, നമ്മൾ ഷെയർ ഐഡൻ്റിഫയറുകളുടെ ഒരു അനുബന്ധ ശ്രേണി നിലനിർത്തേണ്ടതുണ്ട് - ഇത് സ്റ്റേറ്റിനെ കുറിച്ചുള്ള കാര്യമാണ്. രണ്ടാമതായി, ഒരു വൈരുദ്ധ്യം കണ്ടെത്തുമ്പോൾ നമുക്ക് നിർത്താൻ കഴിയണം. ഇത് ഒന്നുകിൽ മൊണാഡ് ആകാം, അല്ലെങ്കിൽ ഒരുപക്ഷേ എന്നതിന് MonadPlus ആകാം. കണക്കുകൂട്ടൽ നിർത്തിയില്ലെങ്കിൽ ഒന്നുകിൽ ഒരു മൂല്യം തിരികെ നൽകാമെന്നതാണ് പ്രധാന വ്യത്യാസം, ഈ സാഹചര്യത്തിൽ ഇതിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ മാത്രമേ നൽകൂ. വിജയത്തിനായി ഞങ്ങൾക്ക് ഒരു പ്രത്യേക മൂല്യം ആവശ്യമില്ലാത്തതിനാൽ (ഇത് ഇതിനകം സംസ്ഥാനത്ത് സംഭരിച്ചിരിക്കുന്നു), ഞങ്ങൾ ഒരുപക്ഷേ തിരഞ്ഞെടുക്കുന്നു. രണ്ട് മൊണാഡുകളുടെ ഫലങ്ങൾ സംയോജിപ്പിക്കേണ്ട നിമിഷത്തിൽ, അവ പുറത്തുവരുന്നു മൊണാഡ് ട്രാൻസ്ഫോർമറുകൾ, ഈ ഇഫക്റ്റുകൾ കൃത്യമായി സംയോജിപ്പിക്കുന്നത്.

എന്തുകൊണ്ടാണ് ഞാൻ അത്തരമൊരു സങ്കീർണ്ണ തരം തിരഞ്ഞെടുത്തത്? രണ്ട് കാരണങ്ങൾ. ഒന്നാമതായി, നടപ്പാക്കൽ അനിവാര്യതയുമായി വളരെ സാമ്യമുള്ളതായി മാറുന്നു. രണ്ടാമതായി, വിചിത്രമായ ലൂപ്പ് പുനഃസ്ഥാപിക്കുന്നതിന് ആവർത്തനത്തിൽ നിന്ന് തിരികെ വരുമ്പോൾ വൈരുദ്ധ്യമുണ്ടായാൽ റിട്ടേൺ മൂല്യം കൈകാര്യം ചെയ്യേണ്ടതുണ്ട്, ഇത് ഒരുപക്ഷേ മൊണാഡിൽ ചെയ്യാൻ വളരെ എളുപ്പമാണ്.

അങ്ങനെ നമുക്ക് ഈ നടപ്പാക്കൽ ലഭിക്കുന്നു.

{-# LANGUAGE ExplicitForAll #-}
{-# LANGUAGE ScopedTypeVariables #-}

data Part = LeftPart | RightPart

otherPart :: Part -> Part
otherPart LeftPart  = RightPart
otherPart RightPart = LeftPart

type PartMap a = Map.Map a Part
type OddCycle a = [a]

toEither :: Ord a => PartMap a -> a -> Either a a
toEither m v = case fromJust (v `Map.lookup` m) of
                    LeftPart  -> Left  v
                    RightPart -> Right v

type PartMonad a = MaybeT (State (PartMap a)) [a]

detectParts :: forall a. Ord a => Graph a -> Either (OddCycle a) (Bigraph a a)
detectParts g = case runState (runMaybeT dfs) Map.empty of
                     (Just c, _)  -> Left  $ oddCycle c
                     (Nothing, m) -> Right $ toBipartiteWith (toEither m) g
    where
        inVertex :: Part -> a -> PartMonad a
        inVertex p v = ((:) v) <$> do modify $ Map.insert v p
                                      let q = otherPart p
                                      msum [ onEdge q u | u <- neigbours v g ]

        {-# INLINE onEdge #-}
        onEdge :: Part -> a -> PartMonad a
        onEdge p v = do m <- get
                        case v `Map.lookup` m of
                             Nothing -> inVertex p v
                             Just q  -> do guard (q /= p)
                                           return [v]

        processVertex :: a -> PartMonad a
        processVertex v = do m <- get
                             guard (v `Map.notMember` m)
                             inVertex LeftPart v

        dfs :: PartMonad a
        dfs = msum [ processVertex v | v <- vertexList g ]

        oddCycle :: [a] -> [a]
        oddCycle c = tail (dropWhile ((/=) last c) c)

എവിടെ ബ്ലോക്ക് ആണ് അൽഗോരിതത്തിൻ്റെ കാതൽ. അതിനുള്ളിൽ എന്താണ് സംഭവിക്കുന്നതെന്ന് വിശദീകരിക്കാൻ ഞാൻ ശ്രമിക്കും.

• നമ്മൾ ആദ്യമായി ശീർഷകം സന്ദർശിക്കുന്ന ആഴത്തിലുള്ള ആദ്യ തിരയലിൻ്റെ ഭാഗമാണ് inVertex. ഇവിടെ നമ്മൾ വെർട്ടെക്സിലേക്ക് ഒരു ഷെയർ നമ്പർ നൽകുകയും എല്ലാ അയൽക്കാർക്കും onEdge പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്നു. ഞങ്ങൾ കോൾ സ്റ്റാക്ക് പുനഃസ്ഥാപിക്കുന്നതും ഇവിടെയാണ്: msum ഒരു മൂല്യം തിരികെ നൽകിയാൽ, ഞങ്ങൾ അവിടെ വെർട്ടെക്സ് v അമർത്തുന്നു.
• നമ്മൾ എഡ്ജ് സന്ദർശിക്കുന്ന ഭാഗമാണ് onEdge. ഓരോ അരികിലും ഇത് രണ്ടുതവണ വിളിക്കുന്നു. മറുവശത്തുള്ള ശീർഷകം സന്ദർശിച്ചിട്ടുണ്ടോ എന്ന് ഞങ്ങൾ ഇവിടെ പരിശോധിക്കുന്നു, ഇല്ലെങ്കിൽ അത് സന്ദർശിക്കുക. സന്ദർശിച്ചാൽ, എഡ്ജ് വൈരുദ്ധ്യമാണോ എന്ന് ഞങ്ങൾ പരിശോധിക്കുന്നു. അങ്ങനെയാണെങ്കിൽ, ഞങ്ങൾ മൂല്യം തിരികെ നൽകുന്നു - റിക്കർഷൻ സ്റ്റാക്കിൻ്റെ ഏറ്റവും മുകൾഭാഗം, അവിടെ മറ്റെല്ലാ ലംബങ്ങളും തിരികെ വരുമ്പോൾ സ്ഥാപിക്കും.
• processVertex ഓരോ ശീർഷകവും സന്ദർശിച്ചിട്ടുണ്ടോ എന്ന് പരിശോധിക്കുകയും ഇല്ലെങ്കിൽ അതിൽ inVertex പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്നു.
• dfs എല്ലാ വെർട്ടീസുകളിലും processVertex പ്രവർത്തിപ്പിക്കുന്നു.

അത്രയേയുള്ളൂ.

INLINE എന്ന വാക്കിൻ്റെ ചരിത്രം

INLINE എന്ന വാക്ക് അൽഗോരിതത്തിൻ്റെ ആദ്യ പ്രയോഗത്തിൽ ഉണ്ടായിരുന്നില്ല; അത് പിന്നീട് പ്രത്യക്ഷപ്പെട്ടു. ഒരു മികച്ച നടപ്പിലാക്കൽ കണ്ടെത്താൻ ഞാൻ ശ്രമിച്ചപ്പോൾ, ചില ഗ്രാഫുകളിൽ നോൺ-INLINE പതിപ്പ് വളരെ മന്ദഗതിയിലാണെന്ന് ഞാൻ കണ്ടെത്തി. അർത്ഥപരമായി ഫംഗ്‌ഷനുകൾ ഒരേപോലെ പ്രവർത്തിക്കണം എന്നതിനാൽ, ഇത് എന്നെ വളരെയധികം ആശ്ചര്യപ്പെടുത്തി. അപരിചിതൻ പോലും, GHC യുടെ മറ്റൊരു പതിപ്പുള്ള മറ്റൊരു മെഷീനിൽ ശ്രദ്ധേയമായ വ്യത്യാസമില്ല.

GHC കോർ ഔട്ട്‌പുട്ട് വായിച്ച് ഒരാഴ്ച ചെലവഴിച്ചതിന് ശേഷം, വ്യക്തമായ INLINE-ൻ്റെ ഒരു വരി ഉപയോഗിച്ച് എനിക്ക് പ്രശ്നം പരിഹരിക്കാൻ കഴിഞ്ഞു. GHC 8.4.4 നും GHC 8.6.5 നും ഇടയിലുള്ള ചില ഘട്ടങ്ങളിൽ ഒപ്റ്റിമൈസർ സ്വന്തമായി ഇത് ചെയ്യുന്നത് നിർത്തി.

ഹാസ്‌കെൽ പ്രോഗ്രാമിംഗിൽ ഇത്തരമൊരു അഴുക്ക് നേരിടേണ്ടിവരുമെന്ന് ഞാൻ പ്രതീക്ഷിച്ചിരുന്നില്ല. എന്നിരുന്നാലും, ഇന്നും, ഒപ്റ്റിമൈസറുകൾ ചിലപ്പോൾ തെറ്റുകൾ വരുത്തുന്നു, അവർക്ക് സൂചനകൾ നൽകുന്നത് ഞങ്ങളുടെ ജോലിയാണ്. ഉദാഹരണത്തിന്, ഫംഗ്ഷൻ ഇൻലൈൻ ചെയ്യണമെന്ന് ഞങ്ങൾക്കറിയാം, കാരണം അത് നിർബന്ധിത പതിപ്പിൽ ഇൻലൈൻ ചെയ്തിരിക്കുന്നു, ഇത് കംപൈലറിന് ഒരു സൂചന നൽകാനുള്ള കാരണമാണ്.

പിന്നീട് എന്ത് സംഭവിച്ചു?

തുടർന്ന് ഞാൻ മറ്റ് മൊണാഡുകളുമായി ഹോപ്‌ക്രോഫ്റ്റ്-കാർപ്പ് അൽഗോരിതം നടപ്പിലാക്കി, അത് പ്രോഗ്രാമിൻ്റെ അവസാനമായിരുന്നു.

ഗൂഗിൾ സമ്മർ ഓഫ് കോഡിന് നന്ദി, ഫങ്ഷണൽ പ്രോഗ്രാമിംഗിൽ എനിക്ക് പ്രായോഗിക അനുഭവം ലഭിച്ചു, ഇത് അടുത്ത വേനൽക്കാലത്ത് ജെയ്ൻ സ്ട്രീറ്റിൽ ഇൻ്റേൺഷിപ്പ് നേടാൻ എന്നെ സഹായിച്ചു (ഹബറിൻ്റെ അറിവുള്ള പ്രേക്ഷകർക്കിടയിൽ പോലും ഈ സ്ഥലം എത്രത്തോളം അറിയപ്പെടുന്നതാണെന്ന് എനിക്ക് ഉറപ്പില്ല, പക്ഷേ ഇത് ഒന്നാണ് വേനൽക്കാലത്ത് നിങ്ങൾക്ക് ഫങ്ഷണൽ പ്രോഗ്രാമിംഗിൽ ഏർപ്പെടാൻ കഴിയുന്ന ചുരുക്കം ചിലരിൽ), മാത്രമല്ല ഈ മാതൃക പ്രായോഗികമായി പ്രയോഗിക്കുന്നതിൻ്റെ അത്ഭുതകരമായ ലോകത്തിലേക്ക് എന്നെ പരിചയപ്പെടുത്തുകയും ചെയ്തു, പരമ്പരാഗത ഭാഷകളിലെ എൻ്റെ അനുഭവത്തിൽ നിന്ന് വളരെ വ്യത്യസ്തമാണ്.

അവലംബം: www.habr.com