use crate::chart::{Chart, SeriesData, SeriesOptions};
use crate::data::{OhlcColumns, Timestamp, ValueColumns};
use crate::error::{Error, Result};
use crate::frame::{LineDash, SeriesKind};
use crate::geom::{Css, Rgba};
use crate::pane::PaneOptions;
const BASE_PRICE: f64 = 100.0;
const SIGMA: f64 = 0.01;
const THETA: f64 = 1e-3;
const WICK_SIGMA: f64 = 0.005;
const BASE_VOLUME: f64 = 1000.0;
const VOLUME_SIGMA: f64 = 0.25;
const SQRT_3: f64 = 1.732_050_807_568_877_2;
pub fn random_walk(
seed: u64,
n: usize,
start_time: Timestamp,
interval: i64,
) -> Result<OhlcColumns> {
if interval <= 0 {
return Err(Error::InvalidArgument("interval must be > 0"));
}
if n > 0 {
let last = i64::try_from(n - 1)
.ok()
.and_then(|k| k.checked_mul(interval))
.and_then(|span| start_time.checked_add(span));
if last.is_none() {
return Err(Error::InvalidArgument(
"start_time + (n - 1) * interval overflows i64",
));
}
}
let mut times = alloc(n)?;
let mut opens = alloc(n)?;
let mut highs = alloc(n)?;
let mut lows = alloc(n)?;
let mut closes = alloc(n)?;
let mut volumes = alloc(n)?;
let mut rng = SplitMix64(seed);
let mut time = start_time;
let mut prev_close = BASE_PRICE;
for i in 0..n {
let open = prev_close;
let step = SIGMA * rng.normal() + THETA * (BASE_PRICE - open) / open;
let close = open * (1.0 + step);
let body_hi = open.max(close);
let body_lo = open.min(close);
let high = body_hi * (1.0 + WICK_SIGMA * rng.normal().abs());
let low = body_lo * (1.0 - WICK_SIGMA * rng.normal().abs());
let vol = BASE_VOLUME * (1.0 + VOLUME_SIGMA * rng.normal());
times.push(time);
opens.push(open);
highs.push(high);
lows.push(low);
closes.push(close);
volumes.push(vol);
prev_close = close;
if i + 1 < n {
time = time.saturating_add(interval);
}
}
Ok(OhlcColumns {
time: times,
open: opens,
high: highs,
low: lows,
close: closes,
volume: Some(volumes),
})
}
fn alloc<T>(n: usize) -> Result<Vec<T>> {
let mut v = Vec::new();
v.try_reserve_exact(n).map_err(|_| Error::OutOfMemory)?;
Ok(v)
}
struct SplitMix64(u64);
impl SplitMix64 {
fn next_u64(&mut self) -> u64 {
self.0 = self.0.wrapping_add(0x9E37_79B9_7F4A_7C15);
let mut z = self.0;
z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
z ^ (z >> 31)
}
#[allow(clippy::cast_precision_loss)] fn uniform(&mut self) -> f64 {
(self.next_u64() >> 11) as f64 * (1.0 / (1u64 << 53) as f64)
}
fn normal(&mut self) -> f64 {
let sum = self.uniform() + self.uniform() + self.uniform() + self.uniform();
(sum - 2.0) * SQRT_3
}
}
#[derive(Clone, Copy, Debug, Default)]
pub struct MonoMeasurer;
const MONO_ADVANCE: f32 = 0.6;
static MONO_TABLE: [f32; 128] = [MONO_ADVANCE; 128];
static MONO_SUBSCRIPTS: [f32; 10] = [MONO_ADVANCE; 10];
impl crate::text::TextMeasurer for MonoMeasurer {
fn ascii_advances(&self, _: crate::frame::FontStyleRef) -> &[f32; 128] {
&MONO_TABLE
}
fn subscript_advances(&self, _: crate::frame::FontStyleRef) -> Option<&[f32; 10]> {
Some(&MONO_SUBSCRIPTS)
}
fn measure(&self, text: &str, style: crate::frame::FontStyleRef) -> crate::geom::SizePx {
crate::geom::SizePx {
w: text.chars().count() as f32 * MONO_ADVANCE * style.size,
h: self.line_height(style),
}
}
fn line_height(&self, style: crate::frame::FontStyleRef) -> f32 {
style.size * 1.2
}
}
fn sma(values: &[f64], n: usize) -> Vec<f64> {
let mut sum = 0.0;
values
.iter()
.enumerate()
.map(|(i, v)| {
sum += v;
if i >= n {
sum -= values.get(i - n).copied().unwrap_or(0.0);
}
if i + 1 < n { f64::NAN } else { sum / n as f64 }
})
.collect()
}
fn on_times(data: &OhlcColumns, value: Vec<f64>, color: Option<Vec<u32>>) -> SeriesData {
SeriesData::Value(ValueColumns {
time: data.time.clone(),
value,
color,
})
}
pub fn series_kinds_scene(chart: &mut Chart, start_time: Timestamp) -> Result<()> {
let pane = chart.main_pane();
let data = random_walk(14, 120, start_time, 3_600_000)?;
let fast = sma(&data.close, 5);
let slow = sma(&data.close, 20);
let bars = chart.add_series(pane, SeriesKind::OhlcBar, SeriesOptions::default())?;
chart.set_data(bars, SeriesData::Ohlc(data.clone()))?;
let line = chart.add_series(pane, SeriesKind::Line, SeriesOptions::default())?;
chart.set_data(line, on_times(&data, fast.clone(), None))?;
let step = chart.add_series(
pane,
SeriesKind::Line,
SeriesOptions {
color: Some(Rgba::hex(0x00FF_9800)),
line_width: Css(1.0),
line_style: LineDash::Dashed,
step: true,
..SeriesOptions::default()
},
)?;
chart.set_data(step, on_times(&data, slow.clone(), None))?;
let area_pane = chart.add_pane(PaneOptions {
stretch_factor: 0.5,
});
let area = chart.add_series(area_pane, SeriesKind::Area, SeriesOptions::default())?;
let close: Vec<f64> = data
.close
.iter()
.enumerate()
.map(|(i, &c)| if (60..66).contains(&i) { f64::NAN } else { c })
.collect();
chart.set_data(area, on_times(&data, close, None))?;
let osc_pane = chart.add_pane(PaneOptions {
stretch_factor: 0.5,
});
let osc: Vec<f64> = fast.iter().zip(&slow).map(|(f, s)| f - s).collect();
let change: Vec<f64> = core::iter::once(f64::NAN)
.chain(osc.windows(2).map(|w| w[1] - w[0]))
.collect();
let colors = change
.iter()
.map(|v| if *v >= 0.0 { 0x26A6_9A80 } else { 0xEF53_5080 })
.collect();
let hist = chart.add_series(osc_pane, SeriesKind::Histogram, SeriesOptions::default())?;
chart.set_data(hist, on_times(&data, change, Some(colors)))?;
let baseline = chart.add_series(osc_pane, SeriesKind::Baseline, SeriesOptions::default())?;
chart.set_data(baseline, on_times(&data, osc, None))?;
chart.time_scale().set_bar_spacing(6.0);
Ok(())
}
pub fn merged_axis_scene(chart: &mut Chart, start_time: Timestamp) -> Result<()> {
use crate::chart::{
Marker,
MarkerPosition::{AboveBar, BelowBar},
MarkerShape::{ArrowDown, ArrowUp, Circle, Square},
};
const HOUR: i64 = 3_600_000;
let pane = chart.main_pane();
let data = random_walk(11, 40, start_time, HOUR)?;
let candles = chart.add_series(pane, SeriesKind::Candlestick, SeriesOptions::default())?;
chart.add_series(pane, SeriesKind::Volume, SeriesOptions::volume_of(candles))?;
let line = chart.add_series(
pane,
SeriesKind::Line,
SeriesOptions {
color: Some(Rgba::hex(0x00FF_9800)),
..SeriesOptions::default()
},
)?;
chart.set_data(candles, SeriesData::Ohlc(data.clone()))?;
let (time, value) = (10..30)
.map(|i| {
(
data.time[i] + HOUR / 2,
(data.open[i + 1] + data.close[i]) * 0.5,
)
})
.unzip();
chart.set_data(
line,
SeriesData::Value(ValueColumns {
time,
value,
color: None,
}),
)?;
let (up, down) = (Rgba::hex(0x0026_A69A), Rgba::hex(0x00EF_5350));
let marker = |i: usize, position, shape, color, text: &str| Marker {
time: data.time[i],
position,
shape,
color: Some(color),
text: text.into(),
};
let mut gap = marker(12, AboveBar, Circle, down, "gap");
gap.time += HOUR / 2;
chart.set_markers(
candles,
vec![
marker(35, AboveBar, ArrowDown, down, "Sell"),
marker(3, BelowBar, ArrowUp, up, "Buy"),
marker(3, BelowBar, Circle, up, ""),
marker(8, AboveBar, Square, down, ""),
marker(8, AboveBar, ArrowDown, down, "S"),
gap,
],
)?;
chart.set_markers(
line,
vec![Marker {
time: data.time[20] + HOUR / 2,
position: BelowBar,
shape: Circle,
..Marker::default()
}],
)?;
chart.time_scale().set_bar_spacing(12.0);
Ok(())
}
pub fn percentage_scene(chart: &mut Chart, start_time: Timestamp) -> Result<()> {
use crate::price_scale::{PriceScaleMode, ScaleSide};
let pane = chart.main_pane();
let data = random_walk(11, 60, start_time, 3_600_000)?;
let other = random_walk(15, 60, start_time, 3_600_000)?;
let last = data.close.last().copied().unwrap_or(100.0);
let candles = chart.add_series(pane, SeriesKind::Candlestick, SeriesOptions::default())?;
chart.set_data(candles, SeriesData::Ohlc(data))?;
let area = chart.add_series(
pane,
SeriesKind::Area,
SeriesOptions {
color: Some(Rgba::hex(0x00FF_9800)),
..SeriesOptions::default()
},
)?;
let value = other.close.iter().map(|c| c * 3.0).collect();
chart.set_data(
area,
SeriesData::Value(ValueColumns {
time: other.time,
value,
color: None,
}),
)?;
chart.create_price_line(
candles,
crate::chart::PriceLineOptions {
price: last * 1.02,
color: Some(Rgba::hex(0x009C_27B0)),
title: "target".into(),
..Default::default()
},
)?;
chart.create_price_line(
candles,
crate::chart::PriceLineOptions {
price: last * 0.985,
line_width: crate::geom::Css(2.0),
line_style: crate::frame::LineDash::Solid,
..Default::default()
},
)?;
if let Some(scale) = chart.price_scale(pane, ScaleSide::Right) {
scale.set_mode(PriceScaleMode::Percentage)?;
}
chart.time_scale().set_bar_spacing(12.0);
Ok(())
}
pub fn drawings_scene(chart: &mut Chart, start_time: Timestamp) -> Result<()> {
use crate::drawing::{Anchor, DrawingData, DrawingStyle, Param};
const HOUR: i64 = 3_600_000;
let pane = chart.main_pane();
let data = random_walk(17, 80, start_time, HOUR)?;
let lo = data.low.iter().copied().fold(f64::INFINITY, f64::min);
let hi = data.high.iter().copied().fold(f64::NEG_INFINITY, f64::max);
let candles = chart.add_series(pane, SeriesKind::Candlestick, SeriesOptions::default())?;
chart.set_data(candles, SeriesData::Ohlc(data))?;
let at = |bar: i64, f: f64| Anchor {
time: start_time + bar * HOUR,
price: lo + (hi - lo) * f,
};
let orange = Rgba::hex(0x00FF_9800);
let purple = Rgba::hex(0x009C_27B0);
let styled = |line: Rgba, dash: LineDash, width: f32| DrawingStyle {
line,
line_width: Css(width),
line_dash: dash,
fill: line.with_alpha(40),
text: line,
..DrawingStyle::default()
};
let mut text = DrawingData::new("text", vec![at(3, 0.02)]);
text.set("text", Param::Text("FerroChart".into()));
let drawings = [
DrawingData::new("trend_line", vec![at(2, 0.2), at(18, 0.6)]),
DrawingData {
style: styled(orange, LineDash::Solid, 2.0),
..DrawingData::new("ray", vec![at(5, 0.9), at(12, 0.86)])
},
DrawingData {
style: styled(purple, LineDash::Dashed, 1.0),
..DrawingData::new("extended_line", vec![at(60, 0.1), at(70, 0.16)])
},
DrawingData::new("horizontal_line", vec![at(0, 0.97)]),
DrawingData {
style: styled(orange, LineDash::Dotted, 1.0),
..DrawingData::new("horizontal_ray", vec![at(40, 0.04)])
},
DrawingData::new("vertical_line", vec![at(30, 0.0)]),
DrawingData::new(
"parallel_channel",
vec![at(20, 0.3), at(35, 0.5), at(20, 0.15)],
),
DrawingData {
style: styled(purple, LineDash::Solid, 1.0),
..DrawingData::new("rectangle", vec![at(38, 0.62), at(48, 0.8)])
},
DrawingData {
style: styled(orange, LineDash::Solid, 2.0),
..DrawingData::new("ellipse", vec![at(50, 0.55), at(58, 0.75)])
},
text,
DrawingData::new("price_range", vec![at(62, 0.6), at(66, 0.85)]),
DrawingData::new("date_range", vec![at(68, 0.4), at(76, 0.5)]),
DrawingData::new("fib_retracement", vec![at(40, 0.12), at(52, 0.45)]),
DrawingData {
style: styled(purple, LineDash::Solid, 1.0),
..DrawingData::new("fib_extension", vec![at(2, 0.3), at(8, 0.42), at(12, 0.33)])
},
DrawingData::new("long_position", vec![at(72, 0.7), at(78, 0.85)]),
DrawingData::new("short_position", vec![at(80, 0.3), at(88, 0.2)]),
];
let mut channel = None;
for d in &drawings {
let id = chart.drawings().add(pane, d)?;
if d.kind == "parallel_channel" {
channel = Some(id);
}
}
chart.drawings().select(channel)?;
chart.time_scale().set_bar_spacing(7.5);
chart.time_scale().set_right_offset(14.0);
Ok(())
}
pub fn drawings2_scene(chart: &mut Chart, start_time: Timestamp) -> Result<()> {
use crate::drawing::{Anchor, DrawingData, DrawingStyle, Param};
const HOUR: i64 = 3_600_000;
let pane = chart.main_pane();
let data = random_walk(23, 80, start_time, HOUR)?;
let lo = data.low.iter().copied().fold(f64::INFINITY, f64::min);
let hi = data.high.iter().copied().fold(f64::NEG_INFINITY, f64::max);
let candles = chart.add_series(pane, SeriesKind::Candlestick, SeriesOptions::default())?;
chart.set_data(candles, SeriesData::Ohlc(data))?;
let at = |bar: f64, f: f64| Anchor {
time: start_time + (bar * HOUR as f64) as i64,
price: lo + (hi - lo) * f,
};
let orange = Rgba::hex(0x00FF_9800);
let purple = Rgba::hex(0x009C_27B0);
let teal = Rgba::hex(0x0000_897B);
let styled = |line: Rgba, width: f32| DrawingStyle {
line,
line_width: Css(width),
fill: line.with_alpha(36),
text: line,
..DrawingStyle::default()
};
let with = |d: DrawingData, style: DrawingStyle| DrawingData { style, ..d };
let pts = |v: &[(f64, f64)]| v.iter().map(|&(b, f)| at(b, f)).collect::<Vec<_>>();
let brush: Vec<Anchor> = (0..48)
.map(|j| {
let b = 48.0 + f64::from(j) * 0.25;
at(b, 0.9 + 0.04 * (f64::from(j) * 0.5).sin())
})
.collect();
let mut callout = DrawingData::new("callout", pts(&[(36.0, 0.98), (40.0, 0.86)]));
callout.set("text", Param::Text("Breakout".into()));
let drawings = [
DrawingData::new("pitchfork", pts(&[(2.0, 0.45), (8.0, 0.7), (12.0, 0.5)])),
with(
DrawingData::new(
"schiff_pitchfork",
pts(&[(14.0, 0.8), (20.0, 0.97), (24.0, 0.84)]),
),
styled(orange, 1.0),
),
with(
DrawingData::new(
"modified_schiff_pitchfork",
pts(&[(26.0, 0.1), (31.0, 0.3), (35.0, 0.16)]),
),
styled(purple, 1.0),
),
with(
DrawingData::new("gann_fan", pts(&[(60.0, 0.05), (66.0, 0.2)])),
styled(teal, 1.0),
),
with(
DrawingData::new("fib_time_zones", pts(&[(44.0, 0.0), (46.0, 0.0)])),
styled(purple, 1.0),
),
DrawingData::new(
"xabcd_pattern",
pts(&[
(2.0, 0.05),
(6.0, 0.3),
(9.0, 0.15),
(13.0, 0.26),
(17.0, 0.02),
]),
),
with(
DrawingData::new(
"head_and_shoulders",
pts(&[
(38.0, 0.45),
(41.0, 0.6),
(44.0, 0.48),
(48.0, 0.75),
(52.0, 0.5),
(55.0, 0.62),
(58.0, 0.44),
]),
),
styled(orange, 2.0),
),
DrawingData::new(
"elliott_impulse",
pts(&[
(62.0, 0.45),
(65.0, 0.6),
(67.0, 0.52),
(71.0, 0.82),
(73.0, 0.72),
(77.0, 0.9),
]),
),
with(
DrawingData::new(
"elliott_correction",
pts(&[(79.0, 0.9), (82.0, 0.7), (84.0, 0.8), (88.0, 0.6)]),
),
styled(purple, 1.0),
),
with(
DrawingData::new(
"path",
pts(&[
(18.0, 0.55),
(22.0, 0.62),
(25.0, 0.5),
(30.0, 0.66),
(33.0, 0.58),
]),
),
styled(teal, 2.0),
),
with(DrawingData::new("brush", brush), styled(orange, 3.0)),
DrawingData::new("arrow", pts(&[(86.0, 0.25), (91.0, 0.4)])),
callout,
];
let mut selected = None;
for d in &drawings {
let id = chart.drawings().add(pane, d)?;
if d.kind == "head_and_shoulders" {
selected = Some(id);
}
}
chart.drawings().select(selected)?;
chart.time_scale().set_bar_spacing(7.5);
chart.time_scale().set_right_offset(14.0);
Ok(())
}
pub fn synced_scene(chart: &mut Chart, start_time: Timestamp) -> Result<()> {
use crate::sync::SyncMessage;
const HOUR: i64 = 3_600_000;
let candles = chart.add_series(
chart.main_pane(),
SeriesKind::Candlestick,
SeriesOptions::default(),
)?;
let volume_pane = chart.add_pane(PaneOptions {
stretch_factor: 0.35,
});
chart.add_series(
volume_pane,
SeriesKind::Volume,
SeriesOptions::volume_of(candles),
)?;
chart.set_data(
candles,
SeriesData::Ohlc(random_walk(19, 60, start_time, HOUR)?),
)?;
chart.build_frame(0.0, &MonoMeasurer);
chart.apply_sync(SyncMessage::VisibleRange {
from: start_time + 10 * HOUR,
to: start_time + 70 * HOUR,
});
chart.apply_sync(SyncMessage::Crosshair {
time: Some(start_time + 31 * HOUR + 20 * 60_000),
});
Ok(())
}
pub fn transform_scene(chart: &mut Chart, start_time: Timestamp, kind: SeriesKind) -> Result<()> {
use crate::plugin::SeriesTransform;
use crate::transform::{Kagi, PointFigure, Renko, Reversal};
let (t, spacing): (Box<dyn SeriesTransform>, f64) = match kind {
SeriesKind::Candlestick => (Box::new(Renko::fixed(0.5)?), 8.0),
SeriesKind::Kagi => (Box::new(Kagi::new(Reversal::Fixed(0.8))?), 10.0),
SeriesKind::PointFigure => (Box::new(PointFigure::new(0.5, 3)?), 14.0),
_ => return Err(Error::InvalidArgument("not a transform scene")),
};
let pane = chart.main_pane();
let id = chart.add_transform_series(pane, t, SeriesOptions::default())?;
chart.add_series(pane, SeriesKind::Volume, SeriesOptions::volume_of(id))?;
chart.set_data(
id,
SeriesData::Ohlc(random_walk(21, 3_000, start_time, 60_000)?),
)?;
chart.time_scale().set_bar_spacing(spacing);
Ok(())
}
pub fn points_scene(chart: &mut Chart, start_time: Timestamp) -> Result<()> {
let pane = chart.main_pane();
let bars = random_walk(13, 120, start_time, 60_000)?;
let candles = chart.add_series(pane, SeriesKind::Candlestick, SeriesOptions::default())?;
let dots = |width: f32, color: Option<Rgba>| SeriesOptions {
color,
line_width: Css(width),
price_line_visible: false,
last_value_visible: false,
..SeriesOptions::default()
};
let sar = chart.add_series(
pane,
SeriesKind::Points,
dots(3.0, Some(Rgba::hex(0x0029_62FF))),
)?;
let marks = chart.add_series(
pane,
SeriesKind::Points,
dots(8.0, Some(Rgba::hex(0x00FF_9800))),
)?;
let n = bars.time.len();
let sar_values = (0..n)
.map(|i| match i {
40..=43 => f64::NAN,
_ if (i / 15) % 2 == 0 => bars.low[i] - 0.4,
_ => bars.high[i] + 0.4,
})
.collect();
let mark_values = (0..n)
.map(|i| if i % 10 == 5 { bars.close[i] } else { f64::NAN })
.collect();
let value = |v: Vec<f64>| {
SeriesData::Value(ValueColumns {
time: bars.time.clone(),
value: v,
color: None,
})
};
chart.set_data(sar, value(sar_values))?;
chart.set_data(marks, value(mark_values))?;
chart.set_data(candles, SeriesData::Ohlc(bars))?;
chart.time_scale().set_bar_spacing(6.0);
Ok(())
}
pub fn band_scene(chart: &mut Chart, start_time: Timestamp) -> Result<()> {
use crate::chart::BandOptions;
let main = chart.main_pane();
let bars = random_walk(17, 200, start_time, 60_000)?;
let n = bars.time.len();
let line = |chart: &mut Chart, pane, color: u32| {
chart.add_series(
pane,
SeriesKind::Line,
SeriesOptions {
color: Some(Rgba::hex(color)),
line_width: Css(1.0),
price_line_visible: false,
last_value_visible: false,
..SeriesOptions::default()
},
)
};
let values = |v: Vec<f64>| {
SeriesData::Value(ValueColumns {
time: bars.time.clone(),
value: v,
color: None,
})
};
let upper = line(chart, main, 0x0029_62FF)?;
let lower = line(chart, main, 0x0029_62FF)?;
let wave = |i: usize, period: f64| (i as f64 / period).sin();
chart.set_data(
upper,
values((0..n).map(|i| bars.close[i] + 1.5 + wave(i, 9.0)).collect()),
)?;
chart.set_data(
lower,
values((0..n).map(|i| bars.close[i] - 1.5 - wave(i, 7.0)).collect()),
)?;
chart.add_band(upper, lower, BandOptions::default())?;
let candles = chart.add_series(main, SeriesKind::Candlestick, SeriesOptions::default())?;
chart.set_data(candles, SeriesData::Ohlc(bars.clone()))?;
let pane = chart.add_pane(PaneOptions::default());
let a = line(chart, pane, 0x0026_A69A)?;
let b = line(chart, pane, 0x00EF_5350)?;
let gap = |i: usize, v: f64| if (120..124).contains(&i) { f64::NAN } else { v };
chart.set_data(
a,
values((0..n).map(|i| gap(i, 2.0 * wave(i, 11.0))).collect()),
)?;
chart.set_data(
b,
values(
(0..n)
.map(|i| gap(i, 1.5 * (i as f64 / 17.0).cos()))
.collect(),
),
)?;
chart.add_band(
a,
b,
BandOptions {
fill: Some(Rgba::hex(0x0026_A69A).with_alpha(0x55)),
fill_crossed: Some(Rgba::hex(0x00EF_5350).with_alpha(0x55)),
},
)?;
chart.time_scale().set_bar_spacing(4.0);
Ok(())
}