ಸಮಯ ಸರಣಿ ಮತ್ತು ಹೆಚ್ಚಿನವುಗಳಿಗಾಗಿ 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