Struct Division 

pub struct Division { /* private fields */ }

CompressedDivision is a compressed representation of a data points in sliding window. It is used to reduce the gas cost of storing, retriving & cleaning up data points in sliding window.

The structure of the compression is as follows:

======= CompressedSMADivision ======= | | | . latest_value | ^ started_at ^ updated_at ^ ended_at[1] |████████████████ | | ^ integral = sum(value * elapsed_time) til latest update

———————————––> time

It is a lossy compression of the data points in the window, it keeps the integral of the data points until latest update of the division, which is enough to calculate the average of the data points in the window. But the average will become approximate once the window edge is within the integral region (before latest update of the division).

[1] ended_at is not defined in the struct because it can be calculated by started_at + division_size where division_size is defined at the CompressedSMALimiter

Implementations

impl Division

pub fn new( started_at: Timestamp, updated_at: Timestamp, value: Decimal, prev_value: Decimal, ) -> Result<Self, TransmuterMathError>

pub fn unchecked_new( started_at: Timestamp, updated_at: Timestamp, latest_value: Decimal, integral: Decimal, ) -> Self

pub fn update( &self, updated_at: Timestamp, value: Decimal, ) -> Result<Self, TransmuterMathError>

pub fn is_outdated( &self, block_time: Timestamp, window_size: Uint64, division_size: Uint64, ) -> Result<bool, TransmuterMathError>

pub fn elapsed_time( &self, block_time: Timestamp, ) -> Result<Uint64, TransmuterMathError>

pub fn ended_at( &self, division_size: Uint64, ) -> Result<Uint64, TransmuterMathError>

pub fn next_started_at( &self, division_size: Uint64, block_time: Timestamp, ) -> Result<Timestamp, TransmuterMathError>

Find the next started_at time based on the division size.

In the following graphic, each division is division_size long.

| self | | | | ^ block_time ^ next_started_at

pub fn compressed_moving_average( latest_removed_division: Option<Self>, divisions: &[Division], division_size: Uint64, window_size: Uint64, block_time: Timestamp, ) -> Result<Decimal, TransmuterMathError>

This function calculates the arithmatic mean of the divisions in a specified window The window is defined by the window_size and division_size

The calculation is done by accumulating the sum of value * elapsed_time (integral) then divide by the total elapsed time (integral range)

As this is CompressionDivision, not all the data points in the window is stored for gas optimization When the window covers portion of the first division, it needs to readjust the integral based on how far the window start time eats in to the first division proportionally.

Assumptions

• Divisions are sorted by started_at
• Last division’s updated_at is less than block_time
• All divisions are within the window or at least overlap with the window
• All divisions are of the same size

The above assumptions are guaranteed by the CompressedSMALimiter

Trait Implementations

impl Clone for Division

fn clone(&self) -> Division

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Division

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Division

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Division

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl PartialEq for Division

fn eq(&self, other: &Division) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Division

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Division