වේලා → කාල ශ්‍රේණි සහ තවත් දේ සඳහා ස්මාර්ට් හැඹිලිය

ෆින්ටෙක්හි, අපට බොහෝ විට විශාල මුදල් විනිමය අනුපාත දත්ත සැකසීමට සිදුවේ. අපි විවිධ මූලාශ්‍රවලින් දත්ත ලබා ගන්නා අතර, ඒ සෑම කෙනෙකුටම හෙට, හෙට අනිද්දා, ඊළඟ මාසය සහ ඉදිරි වසර තුන සඳහා විනිමය අනුපාත පිටකිරීමේ ආකාරය පිළිබඳ තමන්ගේම අදහසක් ඇත. යමෙකුට අනුපාත අනාවැකි කිව හැකි නම් පමණි හරි, එය ව්‍යාපාරය වසා දමා මෝඩ ලෙස මුදල් එහාට මෙහාට වෙනස් කිරීමට කාලයයි. සමහර මූලාශ්‍ර වඩාත් විශ්වාසදායකය, සමහරක් සම්පූර්ණ කසළ සපයනු ලැබේ, පාහේ නිවැරදි අගයන් දුර්ලභ ඇතුළත් කිරීම් සමඟ, නමුත් විදේශීය ජෝඩු සඳහා. අපගේ කාර්යය වන්නේ තත්පරයකට මෙම දස දහස් ගණනක අගයන් හරහා ගොස් පාරිභෝගිකයින්ට පෙන්විය යුතු දේ හරියටම තීරණය කිරීමයි. දිවා ආහාරයේදී ෆ්ලැමින්ගෝ මෙන් අපි ටොන් ගණනක අපිරිසිදු හා රොන්මඩ වලින් එක් නිවැරදි අගයක් පෙරා ගත යුතුය.

ෆ්ලෙමින්ගෝ වල විශේෂ කැපී පෙනෙන ලක්ෂණයක් වන්නේ ඔවුන්ගේ විශාල පහළට වක්‍ර වූ හොට වන අතර, ඔවුන් ජලයෙන් හෝ මඩෙන් ආහාර පෙරීමයි.
 - විකී

ඒ අනුව පුස්තකාලය බිහි විය Vela, නිශ්චිත කාල පරාසයන් තුළ බහු අගයන් සඳහා රාජ්‍ය හැඹිලියක් ගබඩා කරයි. තොප්පිය යටතේ, එය පියාසර කිරීමේදී නරක සහ යල් පැන ගිය දත්ත පෙරහන් කරයි, සහ නවතම දේ සඳහා ප්‍රවේශය ද සපයයි N එක් එක් යතුර සඳහා වලංගු අගයන් (මුදල් යුගල, අපගේ නඩුවේ).

අපි කියමු අපි මුදල් යුගල තුනක් සඳහා ගාස්තු එකතු කරමු. සරලම නිර්වචනය Vela වත්මන් තත්වය ගබඩා කිරීම සඳහා එය මේ වගේ දෙයක් පෙනෙනු ඇත:

defmodule Pairs do
  use Vela,
    eurusd: [sorter: &Kernel.<=/2],
    eurgbp: [limit: 3, errors: 1],
    eurcad: [validator: Pairs]

  @behaviour Vela.Validator

  @impl Vela.Validator
  def valid?(:eurcad, rate), do: rate > 0
end

අගයන් යාවත්කාලීන කිරීම

Vela.put/3 කාර්යය පහත දැක්වෙන අනුපිළිවෙලින් සිදු කරනු ඇත:

• හේතු වනු ඇත validator අගය මත, එකක් අර්ථ දක්වා තිබේ නම් (පරිච්ඡේදය බලන්න වලංගුකරණය පහත);
• වලංගු කිරීම සාර්ථක වූවා නම් හොඳ අගයන් පේළියට හෝ සේවා පේළියට අගය එකතු කරනු ඇත :__errors__ එසේ නොමැති නම්;
• නම් වර්ග කිරීමට හේතු වනු ඇත sorter ලබා දී ඇති යතුරක් සඳහා අර්ථ දක්වා ඇත, නැතහොත් ලැයිස්තුවේ හිසෙහි අගය තබයි (LIFO, පරිච්ඡේදය බලන්න වර්ග කිරීම පහත);
• පරාමිතිය අනුව පේළිය කපා හරිනු ඇත :limit නිර්මාණය මත සම්මත;
• යාවත්කාලීන කළ ව්‍යුහය ආපසු ලබා දෙනු ඇත Vela.

iex|1 > pairs = %Pairs{}
iex|2 > Vela.put(pairs, :eurcad, 1.0)
#⇒ %Pairs{..., eurcad: [1.0], ...}
iex|3 > Vela.put(pairs, :eurcad, -1.0)
#⇒ %Pairs{__errors__: [eurcad: -1.0], ...}
iex|4 > pairs |> Vela.put(:eurusd, 2.0) |> Vela.put(:eurusd, 1.0)
#⇒ %Pairs{... eurusd: [1.0, 2.0]}

එසේම Vela ක්රියාත්මක කරයි Access, එබැවින් ඔබට වටිනාකම් යාවත්කාලීන කිරීම සඳහා අවි ගබඩාවේ සිට ව්‍යුහයන් ගැඹුරින් යාවත්කාලීන කිරීම සඳහා ඕනෑම සම්මත ශ්‍රිතයක් භාවිතා කළ හැක. Kernel: Kernel.get_in/2, Kernel.put_in/3, Kernel.update_in/3, Kernel.pop_in/2, සහ Kernel.get_and_update_in/3.

වලංගුකරණය

වලංගුකාරකයක් ලෙස අර්ථ දැක්විය හැක:

• එක් තර්කයක් සහිත බාහිර ශ්‍රිතය (&MyMod.my_fun/1), එය වලංගු කිරීම සඳහා පමණක් අගය ලැබෙනු ඇත;
• තර්ක දෙකක් සහිත බාහිර ශ්‍රිතය, &MyMod.my_fun/2, ඇයට යුගලයක් ලැබෙනු ඇත serie, value වලංගු කිරීම සඳහා;
• මොඩියුලය ක්රියාත්මක කිරීම Vela.Validator;
• වින්යාස පරාමිතිය threshold, සහ - විකල්ප වශයෙන් - compare_by, පරිච්ඡේදය බලන්න සංසන්දනය පහත.

වලංගු කිරීම සාර්ථක නම්, අගය අනුරූප යතුර යටතේ ලැයිස්තුවට එකතු වේ; එසේ නොමැති නම්, ටියුපල් {serie, value} වෙත යයි :__errors_.

සංසන්දනය

මෙම පේළි වල ගබඩා කර ඇති අගයන් ඕනෑම දෙයක් විය හැකිය. ඉගැන්වීමට Vela ඒවා සංසන්දනය කිරීම සඳහා, එය මාරු කිරීම අවශ්ය වේ compare_by ශ්‍රේණියේ නිර්වචනයේ පරාමිතිය (අගයන් සම්මතය සමඟ සැසඳිය නොහැකි නම් මිස Kernel.</2); මෙම පරාමිතිය වර්ගය විය යුතුය (Vela.value() -> number()). පෙරනිමියෙන් එය සරලයි & &1.

එසේම, ඔබට පේළි අර්ථ දැක්වීමට පරාමිතියක් ලබා දිය හැකිය comparator ඩෙල්ටා අගයන් ගණනය කිරීමට (min/max); උදාහරණයක් ලෙස, සම්ප්රේෂණය කිරීමෙන් Date.diff/2 සංසන්දනය කරන්නෙකු ලෙස, ඔබට දින සඳහා නිවැරදි ඩෙල්ටා ලබා ගත හැකිය.

වැඩ කිරීමට තවත් පහසු ක්රමයක් වන්නේ පරාමිතියක් සම්මත කිරීමයි threshold, නව අගයේ උපරිම අවසර ලත් අනුපාතය නිර්වචනය කරයි {min, max} පරතරය. එය ප්‍රතිශතයක් ලෙස දක්වා ඇති බැවින්, චෙක්පත භාවිතා නොවේ comparatorනමුත් තවමත් භාවිතා කරයි compare_by. උදාහරණයක් ලෙස, දින වේලාවන් සඳහා එළිපත්ත අගයක් නියම කිරීමට, ඔබ නියම කළ යුතුය compare_by: &DateTime.to_unix/1 (පූර්ණ අගයක් ලබා ගැනීමට) සහ threshold: 1, නව අගයන්ට ඉඩ ලබා දෙන්නේ ඒවා තිබේ නම් පමණි ±band වත්මන් අගයන්ගෙන් පරතරය.

අවසාන වශයෙන්, ඔබට භාවිතා කළ හැකිය Vela.equal?/2 හැඹිලි දෙකක් සංසන්දනය කිරීමට. අගයන් ශ්‍රිතයක් නිර්වචනය කරන්නේ නම් equal?/2 හෝ compare/2, එවිට මෙම කාර්යයන් සැසඳීම සඳහා භාවිතා කරනු ඇත, එසේ නොමැතිනම් අපි මෝඩ ලෙස භාවිතා කරමු ==/2.

අගයන් ලබා ගැනීම

වත්මන් තත්වය සැකසීම සාමාන්‍යයෙන් ආරම්භ වන්නේ ඇමතීමෙන් Vela.purge/1, යල් පැන ගිය අගයන් ඉවත් කරයි (නම් validator බැඳිලා timestamps) එවිට ඔබට ඇමතිය හැක Vela.slice/1නැවත පැමිණෙනු ඇත keyword යතුරු ලෙස පේළි නම් සහ පළමු, සැබෑ අගයන් සමඟ.

ඔබට ද භාවිතා කළ හැකිය get_in/2/pop_in/2 එක් එක් පේළියේ අගයන් වෙත පහළ මට්ටමේ ප්රවේශය සඳහා.

අයදුම්පත

Vela වැනි ක්‍රියාවලි තත්වයක කාල ශ්‍රේණි හැඹිලියක් ලෙස අතිශයින්ම ප්‍රයෝජනවත් විය හැක GenServer/Agent. අපට කිසි විටෙක පරණ පාඨමාලා අගයන් භාවිතා නොකිරීමට අවශ්‍ය වන අතර, මෙය සිදු කිරීම සඳහා අපි ක්‍රියාවලිය රාජ්‍ය සැකසුම සමඟ තබා ගනිමු Vela, පහත දැක්වෙන වලංගුකාරකය සමඟ.

@impl Vela.Validator
def valid?(_key, %Rate{} = rate),
  do: Rate.age(rate) < @death_age

и Vela.purge/1 අපට දත්ත අවශ්‍ය සෑම අවස්ථාවකම සියලු පරණ අගයන් නිහඬව ඉවත් කරයි. සැබෑ අගයන් වෙත ප්‍රවේශ වීමට අපි සරලව අමතන්නෙමු Vela.slice/1, සහ පාඨමාලාවේ කුඩා ඉතිහාසයක් අවශ්‍ය වූ විට (සම්පූර්ණ ශ්‍රේණියම), අපි එය හුදෙක් - දැනටමත් වර්ග කර ඇති - වලංගු අගයන් සමඟ ආපසු ලබා දෙන්නෙමු.

• GitHub
• Hexdocs

ප්‍රීතිමත් කාල මාලාවක් හැඹිලිගත කිරීම!

මූලාශ්රය: www.habr.com