apple-quant-algorithmic 0.3.0

Apple Quant's algorithmic library.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

use std::ops::Deref;

use crate::{
	instrument::{InstrumentSpec, XSpec},
	price::RelativePrice, volume::DirectionlessVolume,
};

use super::{WholePoints, WholePointsType};

#[cfg(feature = "subpoints-i32")]
pub type SubpointsType = i32;

#[cfg(not(feature = "subpoints-i32"))]
pub type SubpointsType = i64;

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Subpoints(SubpointsType);

impl Subpoints {
	pub const ZERO: Self = Self(0);

	pub const fn new(
		subpoints_type: SubpointsType,
	) -> Self {
		Self(subpoints_type)
	}

	pub fn from_whole_points<XS: XSpec>(
		whole_points: impl Into<WholePoints>,
	) -> Self {
		let whole_points_type = *whole_points.into().whole_points_type();

		let subpoints_type = (whole_points_type *
			XS::TICKS_PER_POINT as WholePointsType) as SubpointsType;

		Self(subpoints_type)
	}

	pub fn as_subpoints_type(
		&self,
	) -> &SubpointsType {
		&self.0
	}

	pub fn into_subpoints_type(
		self,
	) -> SubpointsType {
		self.0
	}

	pub fn as_directionless_volume<IS: InstrumentSpec>(
		&self,
	) -> DirectionlessVolume<IS> {
		self.into()
	}

	pub fn into_directionless_volume<IS: InstrumentSpec>(
		self,
	) -> DirectionlessVolume<IS> {
		self.into()
	}
}

impl Deref for Subpoints {
	type Target = SubpointsType;

	fn deref(
		&self,
	) -> &Self::Target {
		&self.0
	}
}

impl From<SubpointsType> for Subpoints {
	fn from(
		value: SubpointsType,
	) -> Self {
		Self(value)
	}
}

impl From<RelativePrice> for Subpoints {
	fn from(
		value: RelativePrice,
	) -> Self {
		value.into_subpoints()
	}
}