सूत्र और आलसी संयोजक

फॉर्मूला लाइब्रेरी

फिनटेक में, हमें अक्सर यह सत्यापित करने की आवश्यकता होती है कि सरल अंकगणितीय स्थितियां संतुष्ट हैं, उदाहरण के लिए, विनिमय दर अपेक्षित मूल्य से अधिक होगी या नहीं। ये स्थितियां बहुत बार बदलती हैं, और हमें नए चेक जोड़ने और वास्तविक समय में मौजूदा लोगों को ले जाने के लिए किसी तरह की साइकिल का आविष्कार करने की आवश्यकता है। कल्पना करें कि कुछ मुद्रा जोड़े के लिए विनिमय दर दो से एक के अनुपात में पहुंचने पर कई हजार ग्राहकों को सूचनाएं मिलने की उम्मीद है। यह बहुत सरल होगा यदि हम केवल स्थितियों को स्थिर बना सकते हैं:

def notify?(rate) when rate > 2.0, do: true def notify?(_), do: false 

हम ग्राहकों को गतिशील रूप से ऐसे चेक जोड़ने की अनुमति देते हैं। इसलिए, हमें अभी जोड़ी गई स्थितियों की जांच के लिए अधिक या कम विश्वसनीय तंत्र की आवश्यकता है।

हां, Code.eval_string/3 किसी तरह काम करता है, लेकिन यह वास्तव में जाँच से पहले हर लानत समय हालत को संकलित करता है। जाहिर है, यह बिना किसी कारण के संसाधनों की बर्बादी है। यह इस तथ्य से जटिल है कि हम हर सेकंड विभिन्न मुद्रा जोड़े के लिए लगभग 10,000 पाठ्यक्रम प्राप्त करते हैं और संसाधित करते हैं।

इसलिए हम पहले से तैयार किए गए फार्मूले के साथ आए। छोटे formulae पुस्तकालय प्रत्येक दी गई स्थिति के लिए एक मॉड्यूल बनाता है और उपयोगकर्ता द्वारा दर्ज किए गए सूत्र को एक बार में संकलित करता है।

एनबी लाइब्रेरी का उपयोग सावधानी के साथ किया जाना चाहिए, क्योंकि मॉड्यूल नाम परमाणुओं के रूप में संग्रहीत होते हैं और उनकी अंधाधुंध निर्माण के लिए हर चीज जो ग्राहक जांचना चाहता है, वह अधिक या कम लंबे निष्पादन समय के साथ एरलांग आभासी मशीन पर परमाणु डीओएस हमले का कारण बन सकता है। हम 0.01 मान के अधिकतम स्वीकार्य कदम का उपयोग करते हैं, जो सबसे खराब स्थिति में अधिकतम 200 हजार परमाणु देता है।

आलसी संयोजक

लेकिन इस लेख का मुख्य उद्देश्य पूर्वनिर्मित सूत्रों के बारे में बात करना नहीं है। विनिमय दर विश्लेषण के कुछ सीमावर्ती मामलों के लिए, हमें एक लंबी सूची के क्रमपरिवर्तन की गणना करने की आवश्यकता है। अचानक, अमृत मानक पुस्तकालय एक टर्नकी समाधान प्रदान नहीं करता है। खैर, मैंने रूबी ( Array#combination और चचेरे भाई) से जुझारू हस्ताक्षर की नकल करने का फैसला किया। दुर्भाग्य से, लंबी सूचियों के लिए यह इतना आसान नहीं था। सूची में तीस तत्वों के क्षेत्र में संयोजन बंद हो गया, क्रमपरिवर्तन - पहले भी।

खैर, उम्मीद है कि यहाँ पहले से ही; इसलिए मैंने स्ट्रीम का उपयोग करके आलसी कार्यान्वयन खेलना शुरू कर दिया। यह निकला, और यह उतना आसान नहीं है जितना मैंने सोचा था। मैं नीचे दिए गए कोड की तरह कुछ के साथ आया था

 list = ~w[abcde]a combinations = Stream.transform(Stream.with_index(list), :ok, fn {i1, idx1}, :ok -> {Stream.transform(Stream.with_index(list), :ok, fn {_, idx2}, :ok when idx2 <= idx1 -> {[], :ok} {i2, idx2}, :ok -> {Stream.transform(Stream.with_index(list), :ok, fn {_, idx3}, :ok when idx3 <= idx2 -> {[], :ok} {i3, idx3}, :ok -> {Stream.transform(Stream.with_index(list), :ok, fn {_, idx4}, :ok when idx4 <= idx3 -> {[], :ok} {i4, _idx4}, :ok -> {[[i1, i2, i3, i4]], :ok} end), :ok} end), :ok} end), :ok} end) 

यह काम करता है, लेकिन केवल संयोजनों की एक ज्ञात संख्या के लिए। ठीक है, यह आसानी से overcomeable है: ऐसे मामले के लिए हमारे पास मैक्रोज़ हैं, है ना?

ऊपर दिए गए कोड में, तीन अलग-अलग पैटर्न देखे जाते हैं। एक सफल शाखा जिससे हम सूची को गिराते हैं। खाली सूची का त्वरित निष्कासन। और सूचकांक के साथ प्रवाह का परिवर्तन। ऐसा लगता है कि हम ऊपर के लिए एएसटी बनाने की कोशिश कर सकते हैं।

यह दुर्लभ मामला है जब Kernel.SpecialForms.quote/2 का उपयोग किया जाता है। Kernel.SpecialForms.quote/2 शायद केवल चीजों को जटिल करेगा, इसलिए मैंने कम से कम प्रतिरोध का रास्ता अपनाया: हम अच्छे पुराने नग्न एएसटी को मूर्तिकला देंगे।

मैंने इस कोड पर कंसोल में quote do: और, और इस बिंदु पर, परिणाम की जांच की। हां, पैटर्न हैं। अच्छा, चलिए।

तो, आपको एक सामान्य ढांचा बनाकर शुरू करने की आवश्यकता है।

 defmacrop mapper(from, to, fun), do: quote(do: Enum.map(Range.new(unquote(from), unquote(to)), unquote(fun))) @spec combinations(list :: list(), count :: non_neg_integer()) :: {Stream.t(), :ok} defmacro combinations(l, n) do Enum.reduce(n..1, {[mapper(1, n, &var/1)], :ok}, fn i, body -> stream_combination_transform_clause(i, l, body) end) end 

अब हमें टेम्पलेट भागों को देखने के लिए कोड नहीं, बल्कि एएसटी के संदर्भ में सोचना शुरू करना होगा। यह मजेदार है!

कोड को सरल बनाने के लिए सहायक मैक्रोज़ से शुरू करते हैं:

 def var(i), do: {:"i_#{i}", [], Elixir} def idx(i), do: {:"idx_#{i}", [], Elixir} 

एएसटी भीतरी टुकड़ा एक सामान्य दृश्य से फाड़ा:

 def sink_combination_clause(i) when i > 1 do {:->, [], [ [ {:when, [], [ {​{:_, [], Elixir}, idx(i)}, :ok, {:<=, [context: Elixir, import: Kernel], [idx(i), idx(i - 1)]} ]} ], {[], :ok} ]} end 

सभी आंतरिक टुकड़े एक साथ:

 def sink_combination_clauses(1, body) do [{:->, [], [[{var(1), idx(1)}, :ok], body]}] end def sink_combination_clauses(i, body) when i > 1 do Enum.reverse([ {:->, [], [[{var(i), idx(i)}, :ok], body]} | Enum.map(2..i, &sink_combination_clause/1) ]) end 

और अंत में, बाहरी आवरण चारों ओर।

 def stream_combination_transform_clause(i, l, body) do clauses = sink_combination_clauses(i, body) {​{​{:., [], [{:__aliases__, [alias: false], [:Stream]}, :transform]}, [], [ {​{:., [], [{:__aliases__, [alias: false], [:Stream]}, :with_index]}, [], [l]}, :ok, {:fn, [], clauses} ]}, :ok} end 

सभी क्रमपरिवर्तन लगभग पहचान के साथ किए जाते हैं, एकमात्र परिवर्तन आंतरिक कॉल में स्थिति है। यह आसान था, है ना? सभी कोड रिपॉजिटरी में देखे जा सकते हैं।

आवेदन

अच्छा है, तो हम इस सुंदरता का उपयोग कैसे कर सकते हैं? खैर, कुछ इस तरह से:

 l = for c <- ?a..?z, do: <<c>> # letters list with {stream, :ok} <- Formulae.Combinators.Stream.permutations(l, 12), do: stream |> Stream.take_every(26) |> Enum.take(2) #⇒ [["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l"], # ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "l", "w"]] 

अब हम गणना को समानांतर करने के लिए इस धारा से सीधे Flow भी खिला सकते हैं। हां, यह अभी भी धीमा और दुखद होगा, लेकिन, सौभाग्य से, यह कार्य वास्तविक समय में नहीं है, लेकिन एनालिटिक्स के लिए जो रात में चलाया जा सकता है और जो धीरे-धीरे सभी संयोजनों के माध्यम से जाएगा और परिणामों को कहीं लिख देगा।

यदि आपके पास एलिस्टिर में एएसटी के बारे में प्रश्न हैं - पूछें, मैंने उस पर एक कुत्ता खाया।