Vela → ჭკვიანი ქეში დროის სერიებისთვის და სხვა

ფინტექში ხშირად გვიწევს ვალუტის კურსის მონაცემების საკმაოდ დიდი მოცულობის დამუშავება. ჩვენ ვიღებთ მონაცემებს სხვადასხვა წყაროდან და თითოეულ მათგანს აქვს საკუთარი წარმოდგენა იმის შესახებ, თუ როგორ უნდა მოხდეს გაცვლითი კურსის ექსტრაპოლაცია ხვალინდელი დღის, ზეგ, მომდევნო თვის და თუნდაც შემდეგი სამი წლისთვის. თუ ვინმეს შეეძლო განაკვეთების პროგნოზირება სწორად, დრო იქნებოდა დახუროთ ბიზნესი და სულელურად შეცვალოთ ფული წინ და უკან. ზოგიერთი წყარო უფრო საიმედოა, ზოგი აწვდის სრულ ნაგავს, თითქმის სწორი მნიშვნელობების იშვიათი ჩანართებით, მაგრამ ეგზოტიკური წყვილებისთვის. ჩვენი ამოცანაა გადავხედოთ ამ ათიათასობით მნიშვნელობას წამში და განვსაზღვროთ ზუსტად რა ვაჩვენოთ მომხმარებელს. ჩვენ უნდა გავფილტროთ ერთი სწორი მნიშვნელობა ტონა ჭუჭყისა და სილასგან, ისევე როგორც ფლამინგოებს აკეთებენ ლანჩზე.

ფლამინგოების განსაკუთრებული გამორჩეული თვისებაა მათი მასიური ქვევით მოხრილი წვერი, რომლითაც ისინი ფილტრავენ საკვებს წყლისა და ტალახისგან.
 - ვიკიპედია

ასე დაიბადა ბიბლიოთეკა 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
• ჰექსდოქსი

ბედნიერი დროის სერიების ქეშირება!

წყარო: www.habr.com