1145 lines
33 KiB
Rust
1145 lines
33 KiB
Rust
/*
|
|
* MIT License
|
|
*
|
|
* Copyright (c) 2026 YuYuKunKun
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
use pyo3::prelude::*;
|
|
use pyo3::types::PyType;
|
|
use std::collections::HashMap;
|
|
use std::rc::Rc;
|
|
|
|
use crate::algorithm_py::中枢Py;
|
|
use crate::config_py::缠论配置Py;
|
|
use crate::kline_py::{缠论K线Py, K线Py};
|
|
use crate::types_py::{分型结构Py, 相对方向Py, 缺口Py};
|
|
|
|
// ========== 分型 ==========
|
|
|
|
/// 分型 — 由左中右三根缠论K线构成的顶/底分型。
|
|
///
|
|
/// 属性 (只读):
|
|
/// 左: 缠论K线|None / 中: 缠论K线 / 右: 缠论K线|None
|
|
/// 结构: 分型结构 — 上/下/顶/底/散
|
|
/// 时间戳: int / 分型特征值: float / 强度: str
|
|
/// 关系组: (相对方向, 相对方向, 相对方向)|None — 左中、中右、左右的相对方向
|
|
/// 与MACD柱子分型匹配: bool|None — MACD 柱状图是否与分型结构一致
|
|
///
|
|
/// 类方法:
|
|
/// 判断分型(缠K序列, 索引, 配置) -> 分型|None — 在缠K序列中指定位置尝试创建分型
|
|
/// 从缠K序列中获取分型(缠K序列, 配置) -> list[分型] — 扫描全序列提取所有分型
|
|
/// 向序列中添加(分型序列, 新分型) — 维护分型序列的顺序一致性
|
|
#[pyclass(name = "分型", unsendable)]
|
|
#[derive(Clone)]
|
|
pub struct 分型Py {
|
|
pub(crate) inner: Rc<chanlun::structure::fractal_obj::分型>,
|
|
}
|
|
|
|
#[pymethods]
|
|
impl 分型Py {
|
|
#[new]
|
|
fn new(
|
|
左: Option<&Bound<'_, 缠论K线Py>>,
|
|
中: &Bound<'_, 缠论K线Py>,
|
|
右: Option<&Bound<'_, 缠论K线Py>>,
|
|
) -> Self {
|
|
Self {
|
|
inner: Rc::new(chanlun::structure::fractal_obj::分型::new(
|
|
左.map(|k| Rc::clone(&k.borrow().inner)),
|
|
Rc::clone(&中.borrow().inner),
|
|
右.map(|k| Rc::clone(&k.borrow().inner)),
|
|
)),
|
|
}
|
|
}
|
|
|
|
#[getter]
|
|
fn 左(&self) -> Option<缠论K线Py> {
|
|
self.inner
|
|
.左
|
|
.as_ref()
|
|
.map(|k| 缠论K线Py::from_rc(Rc::clone(k)))
|
|
}
|
|
|
|
#[getter]
|
|
fn 中(&self) -> 缠论K线Py {
|
|
缠论K线Py::from_rc(Rc::clone(&self.inner.中))
|
|
}
|
|
|
|
#[getter]
|
|
fn 右(&self) -> Option<缠论K线Py> {
|
|
self.inner
|
|
.右
|
|
.as_ref()
|
|
.map(|k| 缠论K线Py::from_rc(Rc::clone(k)))
|
|
}
|
|
|
|
#[getter]
|
|
fn 结构(&self) -> 分型结构Py {
|
|
分型结构Py {
|
|
inner: self.inner.结构,
|
|
}
|
|
}
|
|
|
|
#[getter]
|
|
fn 时间戳(&self) -> i64 {
|
|
self.inner.时间戳
|
|
}
|
|
|
|
#[getter]
|
|
fn 分型特征值(&self) -> f64 {
|
|
self.inner.分型特征值
|
|
}
|
|
|
|
fn __str__(&self) -> String {
|
|
format!("{}", self.inner)
|
|
}
|
|
|
|
fn __repr__(&self) -> String {
|
|
self.__str__()
|
|
}
|
|
|
|
fn __eq__(&self, other: &Bound<'_, PyAny>) -> bool {
|
|
if let Ok(other) = other.extract::<PyRef<'_, Self>>() {
|
|
return Rc::as_ptr(&self.inner) == Rc::as_ptr(&other.inner);
|
|
}
|
|
false
|
|
}
|
|
|
|
fn __hash__(&self) -> u64 {
|
|
Rc::as_ptr(&self.inner) as u64
|
|
}
|
|
|
|
#[getter]
|
|
fn 关系组(&self) -> Option<(相对方向Py, 相对方向Py, 相对方向Py)> {
|
|
self.inner.关系组().map(|(a, b, c)| {
|
|
(
|
|
相对方向Py { inner: a },
|
|
相对方向Py { inner: b },
|
|
相对方向Py { inner: c },
|
|
)
|
|
})
|
|
}
|
|
|
|
#[getter]
|
|
fn 强度(&self) -> String {
|
|
self.inner.强度().to_string()
|
|
}
|
|
|
|
#[getter]
|
|
fn 与MACD柱子分型匹配(&self) -> bool {
|
|
self.inner.与MACD柱子分型匹配()
|
|
}
|
|
|
|
#[classmethod]
|
|
#[pyo3(signature = (左, 右, 模式 = "中"))]
|
|
fn 判断分型(
|
|
_cls: &Bound<'_, PyType>,
|
|
左: &Bound<'_, Self>,
|
|
右: &Bound<'_, Self>,
|
|
模式: &str,
|
|
) -> bool {
|
|
chanlun::structure::fractal_obj::分型::判断分型(
|
|
&左.borrow().inner,
|
|
&右.borrow().inner,
|
|
模式,
|
|
)
|
|
}
|
|
|
|
#[staticmethod]
|
|
fn 从缠K序列中获取分型(
|
|
K线序列: Vec<Py<缠论K线Py>>,
|
|
中: &Bound<'_, 缠论K线Py>,
|
|
py: Python<'_>,
|
|
) -> Option<Self> {
|
|
let ck_seq: Vec<Rc<chanlun::kline::chan_kline::缠论K线>> = K线序列
|
|
.iter()
|
|
.map(|k| Rc::clone(&k.bind(py).borrow().inner))
|
|
.collect();
|
|
chanlun::structure::fractal_obj::分型::从缠K序列中获取分型(
|
|
&ck_seq,
|
|
&中.borrow().inner,
|
|
)
|
|
.map(|inner| Self {
|
|
inner: Rc::new(inner),
|
|
})
|
|
}
|
|
|
|
#[staticmethod]
|
|
fn 向序列中添加(
|
|
分型序列: &Bound<'_, PyAny>, 当前分型: &Bound<'_, Self>
|
|
) -> PyResult<()> {
|
|
let py = 分型序列.py();
|
|
let inner = Rc::clone(&当前分型.borrow().inner);
|
|
let wrapper = Py::new(
|
|
py,
|
|
Self {
|
|
inner: Rc::clone(&inner),
|
|
},
|
|
)?;
|
|
分型序列.call_method1("append", (wrapper,))?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
// ========== 虚线 ==========
|
|
|
|
/// 虚线 — 笔/线段的通用数据结构，持有一组分型端点（文=起点分型, 武=终点分型）。
|
|
///
|
|
/// 属性 (只读):
|
|
/// 标识: str — "笔" / "线段" / "扩展线段" 等
|
|
/// 序号: int / 级别: int / 有效性: bool / 模式: str
|
|
/// 文: 分型 — 起点分型
|
|
/// 武: 分型 — 终点分型
|
|
/// 方向: 相对方向 — 根据文/武高低判定
|
|
/// 高: float (计算) / 低: float (计算)
|
|
/// 确认K线: 缠论K线|None / 前一缺口: 缺口|None
|
|
/// 前一结束位置: 虚线|None / 短路修正: bool
|
|
/// 基础序列: list[虚线] — 构成该虚线的子级虚线序列
|
|
/// 实_中枢序列: list[中枢] / 虚_中枢序列: list[中枢] / 合_中枢序列: list[中枢]
|
|
/// 笔序列: list[虚线] (计算) — 递归获取所有笔
|
|
///
|
|
/// 方法:
|
|
/// 之前是(其他虚线) -> bool — 判断当前虚线是否紧接在另一虚线之前
|
|
/// 之后是(其他虚线) -> bool — 判断当前虚线是否紧接在另一虚线之后
|
|
/// 获取普K序列(观察员) -> list[K线] — 截取该虚线的原始K线范围
|
|
/// 获取缠K序列(观察员) -> list[缠论K线] — 截取该虚线的缠K范围
|
|
/// 获取数据文本() -> str
|
|
///
|
|
/// 类方法（算法辅助）:
|
|
/// 创建笔(序号, 标识, 文, 武, 级别) / 创建线段(...)
|
|
/// 缠K买卖点模式(缠K) / 买卖点配置匹配 / 买卖点任意匹配 / 买卖点全量匹配 / 买卖点相对匹配
|
|
/// 计算MACD柱子均值 / 武之全量MACD均值 / 武之MACD均值 / 武之MACD极值
|
|
/// 计算K线序列MACD趋向背驰 / 买卖意义 / 计算MACD柱子分段
|
|
/// 密集区域按间隔 / 统计MACD行为
|
|
#[pyclass(name = "虚线", unsendable)]
|
|
#[derive(Clone)]
|
|
pub struct 虚线Py {
|
|
pub(crate) inner: Rc<chanlun::structure::dash_line::虚线>,
|
|
}
|
|
|
|
#[pymethods]
|
|
impl 虚线Py {
|
|
#[new]
|
|
#[pyo3(signature = (序号, 标识, 文, 武, 级别, 有效性 = true))]
|
|
fn new(
|
|
序号: i64,
|
|
标识: String,
|
|
文: &Bound<'_, 分型Py>,
|
|
武: &Bound<'_, 分型Py>,
|
|
级别: i64,
|
|
有效性: bool,
|
|
) -> Self {
|
|
Self {
|
|
inner: Rc::new(chanlun::structure::dash_line::虚线::new(
|
|
序号,
|
|
标识,
|
|
Rc::clone(&文.borrow().inner),
|
|
Rc::clone(&武.borrow().inner),
|
|
级别,
|
|
有效性,
|
|
)),
|
|
}
|
|
}
|
|
|
|
// ---- 基础 getters ----
|
|
|
|
#[getter]
|
|
fn 标识(&self) -> String {
|
|
self.inner.标识.clone()
|
|
}
|
|
|
|
#[getter]
|
|
fn 序号(&self) -> i64 {
|
|
self.inner.序号
|
|
}
|
|
|
|
#[getter]
|
|
fn 级别(&self) -> i64 {
|
|
self.inner.级别
|
|
}
|
|
|
|
#[getter]
|
|
fn 文(&self) -> 分型Py {
|
|
分型Py {
|
|
inner: Rc::clone(&self.inner.文),
|
|
}
|
|
}
|
|
|
|
#[getter]
|
|
fn 武(&self) -> 分型Py {
|
|
分型Py {
|
|
inner: Rc::clone(&self.inner.武),
|
|
}
|
|
}
|
|
|
|
#[getter]
|
|
fn 有效性(&self) -> bool {
|
|
self.inner.有效性
|
|
}
|
|
|
|
#[getter]
|
|
fn 模式(&self) -> String {
|
|
self.inner.模式.clone()
|
|
}
|
|
|
|
#[getter]
|
|
fn _特征序列_显示(&self) -> bool {
|
|
self.inner._特征序列_显示
|
|
}
|
|
|
|
#[getter]
|
|
fn 特征序列(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
|
|
let list = pyo3::types::PyList::empty(py);
|
|
for item in &self.inner.特征序列 {
|
|
match item {
|
|
Some(feat) => list.append(Py::new(
|
|
py,
|
|
线段特征Py {
|
|
inner: Rc::clone(feat),
|
|
},
|
|
)?)?,
|
|
None => {
|
|
list.append(py.None())?;
|
|
}
|
|
}
|
|
}
|
|
Ok(list.into())
|
|
}
|
|
|
|
#[getter]
|
|
fn 短路修正(&self) -> bool {
|
|
self.inner.短路修正
|
|
}
|
|
|
|
#[getter]
|
|
fn 确认K线(&self) -> Option<缠论K线Py> {
|
|
self.inner
|
|
.确认K线
|
|
.as_ref()
|
|
.map(|k| 缠论K线Py::from_rc(Rc::clone(k)))
|
|
}
|
|
|
|
#[getter]
|
|
fn 前一缺口(&self) -> Option<缺口Py> {
|
|
self.inner.前一缺口.map(|q| 缺口Py { inner: q })
|
|
}
|
|
|
|
#[getter]
|
|
fn 前一结束位置(&self) -> Option<Self> {
|
|
self.inner.前一结束位置.as_ref().map(|d| Self {
|
|
inner: Rc::clone(d),
|
|
})
|
|
}
|
|
|
|
// ---- 序列 getters ----
|
|
|
|
#[getter]
|
|
fn 基础序列(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
|
|
let list = pyo3::types::PyList::empty(py);
|
|
for d in &self.inner.基础序列 {
|
|
list.append(Py::new(
|
|
py,
|
|
Self {
|
|
inner: Rc::clone(d),
|
|
},
|
|
)?)?;
|
|
}
|
|
Ok(list.into())
|
|
}
|
|
|
|
#[getter]
|
|
fn 实_中枢序列(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
|
|
let list = pyo3::types::PyList::empty(py);
|
|
for h in &self.inner.实_中枢序列 {
|
|
list.append(中枢Py {
|
|
inner: Rc::clone(h),
|
|
})?;
|
|
}
|
|
Ok(list.into())
|
|
}
|
|
|
|
#[getter]
|
|
fn 虚_中枢序列(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
|
|
let list = pyo3::types::PyList::empty(py);
|
|
for h in &self.inner.虚_中枢序列 {
|
|
list.append(中枢Py {
|
|
inner: Rc::clone(h),
|
|
})?;
|
|
}
|
|
Ok(list.into())
|
|
}
|
|
|
|
#[getter]
|
|
fn 合_中枢序列(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
|
|
let list = pyo3::types::PyList::empty(py);
|
|
for h in &self.inner.合_中枢序列 {
|
|
list.append(中枢Py {
|
|
inner: Rc::clone(h),
|
|
})?;
|
|
}
|
|
Ok(list.into())
|
|
}
|
|
|
|
// ---- 计算属性 ----
|
|
|
|
#[getter]
|
|
fn 笔序列(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
|
|
let list = pyo3::types::PyList::empty(py);
|
|
for d in self.inner.笔序列() {
|
|
list.append(Py::new(
|
|
py,
|
|
Self {
|
|
inner: Rc::clone(d),
|
|
},
|
|
)?)?;
|
|
}
|
|
Ok(list.into())
|
|
}
|
|
|
|
#[getter]
|
|
fn 图表标题(&self) -> String {
|
|
self.inner.图表标题()
|
|
}
|
|
|
|
#[getter]
|
|
fn 方向(&self) -> 相对方向Py {
|
|
相对方向Py {
|
|
inner: self.inner.方向(),
|
|
}
|
|
}
|
|
|
|
#[getter]
|
|
fn 高(&self) -> f64 {
|
|
self.inner.高()
|
|
}
|
|
|
|
#[getter]
|
|
fn 低(&self) -> f64 {
|
|
self.inner.低()
|
|
}
|
|
|
|
fn 之前是(&self, 之前: &Bound<'_, Self>) -> bool {
|
|
self.inner.之前是(&之前.borrow().inner)
|
|
}
|
|
|
|
fn 之后是(&self, 之后: &Bound<'_, Self>) -> bool {
|
|
self.inner.之后是(&之后.borrow().inner)
|
|
}
|
|
|
|
fn 获取普K序列(
|
|
&self,
|
|
观察员: &Bound<'_, crate::business_py::观察者Py>,
|
|
) -> PyResult<Py<PyAny>> {
|
|
let obs_ref = 观察员.borrow();
|
|
let observer_inner = obs_ref.obs();
|
|
let result = self.inner.获取普K序列(&observer_inner.普通K线序列);
|
|
let list = pyo3::types::PyList::empty(观察员.py());
|
|
for k in &result {
|
|
list.append(K线Py {
|
|
inner: Rc::clone(k),
|
|
})?;
|
|
}
|
|
Ok(list.into())
|
|
}
|
|
|
|
fn 获取缠K序列(
|
|
&self,
|
|
观察员: &Bound<'_, crate::business_py::观察者Py>,
|
|
) -> PyResult<Py<PyAny>> {
|
|
let obs_ref = 观察员.borrow();
|
|
let observer_inner = obs_ref.obs();
|
|
let result = self.inner.获取缠K序列(&observer_inner.缠论K线序列);
|
|
let list = pyo3::types::PyList::empty(观察员.py());
|
|
for k in &result {
|
|
list.append(缠论K线Py::from_rc(Rc::clone(k)))?;
|
|
}
|
|
Ok(list.into())
|
|
}
|
|
|
|
#[classmethod]
|
|
fn 获取_武(_cls: &Bound<'_, PyType>, 实线: &Bound<'_, Self>) -> 分型Py {
|
|
分型Py {
|
|
inner: 实线.borrow().inner.获取_武(),
|
|
}
|
|
}
|
|
|
|
fn 获取数据文本(&self) -> String {
|
|
self.inner.获取数据文本()
|
|
}
|
|
|
|
fn __str__(&self) -> String {
|
|
format!("{}", self.inner)
|
|
}
|
|
|
|
fn __repr__(&self) -> String {
|
|
self.__str__()
|
|
}
|
|
|
|
fn __eq__(&self, other: &Bound<'_, PyAny>) -> bool {
|
|
if let Ok(other) = other.extract::<PyRef<'_, Self>>() {
|
|
return Rc::as_ptr(&self.inner) == Rc::as_ptr(&other.inner);
|
|
}
|
|
false
|
|
}
|
|
|
|
fn __hash__(&self) -> u64 {
|
|
Rc::as_ptr(&self.inner) as u64
|
|
}
|
|
|
|
// ---- 静态工厂方法 ----
|
|
|
|
#[classmethod]
|
|
fn 创建笔(
|
|
_cls: &Bound<'_, PyType>,
|
|
文: &Bound<'_, 分型Py>,
|
|
武: &Bound<'_, 分型Py>,
|
|
有效性: bool,
|
|
) -> Self {
|
|
Self {
|
|
inner: Rc::new(chanlun::structure::dash_line::虚线::创建笔(
|
|
Rc::clone(&文.borrow().inner),
|
|
Rc::clone(&武.borrow().inner),
|
|
有效性,
|
|
)),
|
|
}
|
|
}
|
|
|
|
#[classmethod]
|
|
fn 创建线段(_cls: &Bound<'_, PyType>, 虚线序列: Vec<Py<Self>>, py: Python<'_>) -> Self {
|
|
let rc_list: Vec<Rc<chanlun::structure::dash_line::虚线>> = 虚线序列
|
|
.iter()
|
|
.map(|d| Rc::clone(&d.bind(py).borrow().inner))
|
|
.collect();
|
|
Self {
|
|
inner: Rc::new(chanlun::structure::dash_line::虚线::创建线段(
|
|
&rc_list,
|
|
)),
|
|
}
|
|
}
|
|
|
|
// ---- 买卖点模式匹配 ----
|
|
|
|
#[classmethod]
|
|
fn 缠K买卖点模式(
|
|
_cls: &Bound<'_, PyType>,
|
|
模式: &str,
|
|
缠K: &Bound<'_, 缠论K线Py>,
|
|
配置: &Bound<'_, 缠论配置Py>,
|
|
py: Python<'_>,
|
|
) -> PyResult<bool> {
|
|
let config = 配置.borrow().to_rust_config(py)?;
|
|
Ok(chanlun::structure::dash_line::虚线::缠K买卖点模式(
|
|
模式,
|
|
&缠K.borrow().inner,
|
|
&config,
|
|
))
|
|
}
|
|
|
|
#[classmethod]
|
|
fn 买卖点配置匹配(
|
|
_cls: &Bound<'_, PyType>,
|
|
缠K: &Bound<'_, 缠论K线Py>,
|
|
配置: &Bound<'_, 缠论配置Py>,
|
|
py: Python<'_>,
|
|
) -> PyResult<bool> {
|
|
let config = 配置.borrow().to_rust_config(py)?;
|
|
Ok(chanlun::structure::dash_line::虚线::买卖点配置匹配(
|
|
&缠K.borrow().inner,
|
|
&config,
|
|
))
|
|
}
|
|
|
|
#[classmethod]
|
|
fn 买卖点任意匹配(_cls: &Bound<'_, PyType>, 缠K: &Bound<'_, 缠论K线Py>) -> bool {
|
|
chanlun::structure::dash_line::虚线::买卖点任意匹配(&缠K.borrow().inner)
|
|
}
|
|
|
|
#[classmethod]
|
|
fn 买卖点全量匹配(_cls: &Bound<'_, PyType>, 缠K: &Bound<'_, 缠论K线Py>) -> bool {
|
|
chanlun::structure::dash_line::虚线::买卖点全量匹配(&缠K.borrow().inner)
|
|
}
|
|
|
|
#[classmethod]
|
|
fn 买卖点相对匹配(_cls: &Bound<'_, PyType>, 缠K: &Bound<'_, 缠论K线Py>) -> bool {
|
|
chanlun::structure::dash_line::虚线::买卖点相对匹配(&缠K.borrow().inner)
|
|
}
|
|
|
|
// ---- MACD 相关 classmethods ----
|
|
|
|
#[classmethod]
|
|
fn 计算MACD柱子均值(
|
|
_cls: &Bound<'_, PyType>,
|
|
普K序列: Vec<Py<K线Py>>,
|
|
实线: &Bound<'_, Self>,
|
|
py: Python<'_>,
|
|
) -> f64 {
|
|
let rc_list: Vec<Rc<chanlun::kline::bar::K线>> = 普K序列
|
|
.iter()
|
|
.map(|k| k.bind(py).borrow().inner.clone())
|
|
.collect();
|
|
chanlun::structure::dash_line::虚线::计算MACD柱子均值(
|
|
&rc_list,
|
|
&实线.borrow().inner,
|
|
)
|
|
}
|
|
|
|
#[classmethod]
|
|
fn 武之全量MACD均值(
|
|
_cls: &Bound<'_, PyType>,
|
|
普K序列: Vec<Py<K线Py>>,
|
|
实线: &Bound<'_, Self>,
|
|
py: Python<'_>,
|
|
) -> bool {
|
|
let rc_list: Vec<Rc<chanlun::kline::bar::K线>> = 普K序列
|
|
.iter()
|
|
.map(|k| k.bind(py).borrow().inner.clone())
|
|
.collect();
|
|
chanlun::structure::dash_line::虚线::武之全量MACD均值(
|
|
&rc_list,
|
|
&实线.borrow().inner,
|
|
)
|
|
}
|
|
|
|
#[classmethod]
|
|
fn 武之MACD均值(
|
|
_cls: &Bound<'_, PyType>,
|
|
普K序列: Vec<Py<K线Py>>,
|
|
实线: &Bound<'_, Self>,
|
|
py: Python<'_>,
|
|
) -> bool {
|
|
let rc_list: Vec<Rc<chanlun::kline::bar::K线>> = 普K序列
|
|
.iter()
|
|
.map(|k| k.bind(py).borrow().inner.clone())
|
|
.collect();
|
|
chanlun::structure::dash_line::虚线::武之MACD均值(&rc_list, &实线.borrow().inner)
|
|
}
|
|
|
|
#[classmethod]
|
|
fn 武之MACD极值(
|
|
_cls: &Bound<'_, PyType>,
|
|
普K序列: Vec<Py<K线Py>>,
|
|
实线: &Bound<'_, Self>,
|
|
py: Python<'_>,
|
|
) -> bool {
|
|
let rc_list: Vec<Rc<chanlun::kline::bar::K线>> = 普K序列
|
|
.iter()
|
|
.map(|k| k.bind(py).borrow().inner.clone())
|
|
.collect();
|
|
chanlun::structure::dash_line::虚线::武之MACD极值(&rc_list, &实线.borrow().inner)
|
|
}
|
|
|
|
#[classmethod]
|
|
fn 计算MACD柱子均值_阴(
|
|
_cls: &Bound<'_, PyType>,
|
|
普K序列: Vec<Py<K线Py>>,
|
|
实线: &Bound<'_, Self>,
|
|
py: Python<'_>,
|
|
) -> Option<f64> {
|
|
let rc_list: Vec<Rc<chanlun::kline::bar::K线>> = 普K序列
|
|
.iter()
|
|
.map(|k| k.bind(py).borrow().inner.clone())
|
|
.collect();
|
|
chanlun::structure::dash_line::虚线::计算MACD柱子均值_阴(
|
|
&rc_list,
|
|
&实线.borrow().inner,
|
|
)
|
|
}
|
|
|
|
#[classmethod]
|
|
fn 计算MACD柱子均值_阳(
|
|
_cls: &Bound<'_, PyType>,
|
|
普K序列: Vec<Py<K线Py>>,
|
|
实线: &Bound<'_, Self>,
|
|
py: Python<'_>,
|
|
) -> Option<f64> {
|
|
let rc_list: Vec<Rc<chanlun::kline::bar::K线>> = 普K序列
|
|
.iter()
|
|
.map(|k| k.bind(py).borrow().inner.clone())
|
|
.collect();
|
|
chanlun::structure::dash_line::虚线::计算MACD柱子均值_阳(
|
|
&rc_list,
|
|
&实线.borrow().inner,
|
|
)
|
|
}
|
|
|
|
#[classmethod]
|
|
fn 武之MACD均值_阴(
|
|
_cls: &Bound<'_, PyType>,
|
|
普K序列: Vec<Py<K线Py>>,
|
|
实线: &Bound<'_, Self>,
|
|
py: Python<'_>,
|
|
) -> bool {
|
|
let rc_list: Vec<Rc<chanlun::kline::bar::K线>> = 普K序列
|
|
.iter()
|
|
.map(|k| k.bind(py).borrow().inner.clone())
|
|
.collect();
|
|
chanlun::structure::dash_line::虚线::武之MACD均值_阴(&rc_list, &实线.borrow().inner)
|
|
}
|
|
|
|
#[classmethod]
|
|
fn 武之MACD均值_阳(
|
|
_cls: &Bound<'_, PyType>,
|
|
普K序列: Vec<Py<K线Py>>,
|
|
实线: &Bound<'_, Self>,
|
|
py: Python<'_>,
|
|
) -> bool {
|
|
let rc_list: Vec<Rc<chanlun::kline::bar::K线>> = 普K序列
|
|
.iter()
|
|
.map(|k| k.bind(py).borrow().inner.clone())
|
|
.collect();
|
|
chanlun::structure::dash_line::虚线::武之MACD均值_阳(&rc_list, &实线.borrow().inner)
|
|
}
|
|
|
|
#[classmethod]
|
|
fn 计算K线序列MACD趋向背驰(
|
|
_cls: &Bound<'_, PyType>,
|
|
普K序列: Vec<Py<K线Py>>,
|
|
方向: &Bound<'_, 相对方向Py>,
|
|
py: Python<'_>,
|
|
) -> [bool; 3] {
|
|
let rc_list: Vec<Rc<chanlun::kline::bar::K线>> = 普K序列
|
|
.iter()
|
|
.map(|k| k.bind(py).borrow().inner.clone())
|
|
.collect();
|
|
chanlun::structure::dash_line::虚线::计算K线序列MACD趋向背驰(
|
|
&rc_list,
|
|
方向.borrow().inner,
|
|
)
|
|
}
|
|
|
|
#[classmethod]
|
|
fn 计算MACD柱子分段(
|
|
_cls: &Bound<'_, PyType>,
|
|
k线序列: Vec<Py<K线Py>>,
|
|
py: Python<'_>,
|
|
) -> Vec<Vec<f64>> {
|
|
let rc_list: Vec<Rc<chanlun::kline::bar::K线>> = k线序列
|
|
.iter()
|
|
.map(|k| k.bind(py).borrow().inner.clone())
|
|
.collect();
|
|
chanlun::structure::dash_line::虚线::计算MACD柱子分段(&rc_list)
|
|
}
|
|
|
|
#[classmethod]
|
|
fn 密集区域按间隔(
|
|
_cls: &Bound<'_, PyType>,
|
|
交叉标记: Vec<i32>,
|
|
最大间隔: usize,
|
|
最少交叉数: usize,
|
|
) -> Vec<(usize, usize, usize)> {
|
|
chanlun::structure::dash_line::虚线::密集区域按间隔(
|
|
&交叉标记,
|
|
最大间隔,
|
|
最少交叉数,
|
|
)
|
|
}
|
|
|
|
#[classmethod]
|
|
fn 统计MACD行为(
|
|
_cls: &Bound<'_, PyType>,
|
|
普K序列: Vec<Py<K线Py>>,
|
|
最大间隔: usize,
|
|
最少交叉数: usize,
|
|
py: Python<'_>,
|
|
) -> PyResult<Py<PyAny>> {
|
|
let rc_list: Vec<Rc<chanlun::kline::bar::K线>> = 普K序列
|
|
.iter()
|
|
.map(|k| k.bind(py).borrow().inner.clone())
|
|
.collect();
|
|
let result =
|
|
chanlun::structure::dash_line::虚线::统计MACD行为(&rc_list, 最大间隔, 最少交叉数);
|
|
let dict = pyo3::types::PyDict::new(py);
|
|
dict.set_item("DIF上穿0", result.DIF上穿0)?;
|
|
dict.set_item("DIF下穿0", result.DIF下穿0)?;
|
|
dict.set_item("DEA上穿0", result.DEA上穿0)?;
|
|
dict.set_item("DEA下穿0", result.DEA下穿0)?;
|
|
dict.set_item("金叉次数", result.金叉次数)?;
|
|
dict.set_item("死叉次数", result.死叉次数)?;
|
|
let 密集区: Vec<Py<PyAny>> = result
|
|
.密集交叉区域
|
|
.iter()
|
|
.map(|(a, b, c)| {
|
|
let tup = pyo3::types::PyTuple::new(
|
|
py,
|
|
[
|
|
(*a).into_pyobject(py)?.into_any().unbind(),
|
|
(*b).into_pyobject(py)?.into_any().unbind(),
|
|
(*c).into_pyobject(py)?.into_any().unbind(),
|
|
],
|
|
)?;
|
|
Ok(tup.into_any().unbind())
|
|
})
|
|
.collect::<PyResult<Vec<_>>>()?;
|
|
dict.set_item("密集交叉区域", 密集区)?;
|
|
Ok(dict.into())
|
|
}
|
|
|
|
#[classmethod]
|
|
fn 买卖意义(
|
|
_cls: &Bound<'_, PyType>,
|
|
实线: &Bound<'_, Self>,
|
|
观察员: &Bound<'_, crate::business_py::观察者Py>,
|
|
) -> (bool, String) {
|
|
let obs = 观察员.borrow();
|
|
let obs_ref = obs.obs();
|
|
chanlun::structure::dash_line::虚线::买卖意义(&实线.borrow().inner, &*obs_ref)
|
|
}
|
|
}
|
|
|
|
// ========== 线段特征 ==========
|
|
|
|
/// 线段特征 — 特征序列元素构成的集合，支持 list-like 索引访问。
|
|
///
|
|
/// 实现 __getitem__ / __len__ / __iter__，可像 list 一样遍历。
|
|
///
|
|
/// 属性 (只读):
|
|
/// 文: 分型 — 特征序列的起点分型
|
|
/// 武: 分型 — 特征序列的终点分型
|
|
/// 方向: 相对方向 / 高: float / 低: float
|
|
///
|
|
/// 方法:
|
|
/// 添加(虚线) — 向特征序列追加虚线元素
|
|
/// 删除(虚线) — 从特征序列移除虚线元素
|
|
///
|
|
/// 类方法:
|
|
/// 新建(序号, 文, 武, 基础序列?) -> 线段特征
|
|
/// 静态分析(虚线序列, 配置) -> 线段特征|None
|
|
/// 获取分型序列(虚线序列, 配置) -> list[线段特征]
|
|
#[pyclass(name = "线段特征", unsendable)]
|
|
#[derive(Clone)]
|
|
pub struct 线段特征Py {
|
|
pub(crate) inner: Rc<chanlun::structure::segment_feat::线段特征>,
|
|
}
|
|
|
|
#[pymethods]
|
|
impl 线段特征Py {
|
|
#[new]
|
|
fn new(
|
|
标识: String,
|
|
基础序列: Vec<Py<虚线Py>>,
|
|
线段方向: &Bound<'_, 相对方向Py>,
|
|
py: Python<'_>,
|
|
) -> Self {
|
|
let rc_list: Vec<Rc<chanlun::structure::dash_line::虚线>> = 基础序列
|
|
.iter()
|
|
.map(|d| Rc::clone(&d.bind(py).borrow().inner))
|
|
.collect();
|
|
Self {
|
|
inner: Rc::new(chanlun::structure::segment_feat::线段特征::new(
|
|
标识,
|
|
rc_list,
|
|
线段方向.borrow().inner,
|
|
)),
|
|
}
|
|
}
|
|
|
|
// ---- getters ----
|
|
|
|
#[getter]
|
|
fn 序号(&self) -> i64 {
|
|
self.inner.序号
|
|
}
|
|
|
|
#[getter]
|
|
fn 标识(&self) -> String {
|
|
self.inner.标识.clone()
|
|
}
|
|
|
|
#[getter]
|
|
fn 线段方向(&self) -> 相对方向Py {
|
|
相对方向Py {
|
|
inner: self.inner.线段方向,
|
|
}
|
|
}
|
|
|
|
#[getter]
|
|
fn 元素(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
|
|
let list = pyo3::types::PyList::empty(py);
|
|
for d in &self.inner.元素 {
|
|
list.append(Py::new(
|
|
py,
|
|
虚线Py {
|
|
inner: Rc::clone(d),
|
|
},
|
|
)?)?;
|
|
}
|
|
Ok(list.into())
|
|
}
|
|
|
|
fn __str__(&self) -> String {
|
|
format!("{}", self.inner)
|
|
}
|
|
|
|
fn __repr__(&self) -> String {
|
|
self.__str__()
|
|
}
|
|
|
|
fn __len__(&self) -> usize {
|
|
self.inner.元素.len()
|
|
}
|
|
|
|
fn __getitem__(&self, index: isize, py: Python<'_>) -> PyResult<Py<PyAny>> {
|
|
let len = self.inner.元素.len() as isize;
|
|
let idx = if index < 0 { index + len } else { index };
|
|
if idx < 0 || idx >= len {
|
|
return Err(pyo3::exceptions::PyIndexError::new_err(format!(
|
|
"线段特征 index {index} out of range (len={len})"
|
|
)));
|
|
}
|
|
let dash = &self.inner.元素[idx as usize];
|
|
let obj: Py<PyAny> = Py::new(
|
|
py,
|
|
虚线Py {
|
|
inner: Rc::clone(dash),
|
|
},
|
|
)?
|
|
.into();
|
|
Ok(obj)
|
|
}
|
|
|
|
fn __iter__(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
|
|
let list = pyo3::types::PyList::empty(py);
|
|
for d in &self.inner.元素 {
|
|
list.append(Py::new(
|
|
py,
|
|
虚线Py {
|
|
inner: Rc::clone(d),
|
|
},
|
|
)?)?;
|
|
}
|
|
list.call_method0("__iter__").map(|iter| iter.into())
|
|
}
|
|
|
|
fn __eq__(&self, other: &Bound<'_, PyAny>) -> bool {
|
|
if let Ok(other) = other.extract::<PyRef<'_, Self>>() {
|
|
return Rc::as_ptr(&self.inner) == Rc::as_ptr(&other.inner);
|
|
}
|
|
false
|
|
}
|
|
|
|
fn __hash__(&self) -> u64 {
|
|
Rc::as_ptr(&self.inner) as u64
|
|
}
|
|
|
|
// ---- instance methods ----
|
|
|
|
#[getter]
|
|
fn 图表标题(&self) -> String {
|
|
self.inner.图表标题()
|
|
}
|
|
|
|
#[getter]
|
|
fn 文(&self) -> 分型Py {
|
|
分型Py {
|
|
inner: self.inner.文(),
|
|
}
|
|
}
|
|
|
|
#[getter]
|
|
fn 武(&self) -> 分型Py {
|
|
分型Py {
|
|
inner: self.inner.武(),
|
|
}
|
|
}
|
|
|
|
#[getter]
|
|
fn 方向(&self) -> 相对方向Py {
|
|
相对方向Py {
|
|
inner: self.inner.方向(),
|
|
}
|
|
}
|
|
|
|
#[getter]
|
|
fn 高(&self) -> f64 {
|
|
self.inner.高()
|
|
}
|
|
|
|
#[getter]
|
|
fn 低(&self) -> f64 {
|
|
self.inner.低()
|
|
}
|
|
|
|
fn 添加(&mut self, 待添加虚线: &Bound<'_, 虚线Py>) -> PyResult<()> {
|
|
let inner = Rc::make_mut(&mut self.inner);
|
|
inner
|
|
.添加(Rc::clone(&待添加虚线.borrow().inner))
|
|
.map_err(|e| pyo3::exceptions::PyValueError::new_err(e))
|
|
}
|
|
|
|
fn 删除(&mut self, 待删除虚线: &Bound<'_, 虚线Py>) -> PyResult<()> {
|
|
let inner = Rc::make_mut(&mut self.inner);
|
|
inner
|
|
.删除(&Rc::clone(&待删除虚线.borrow().inner))
|
|
.map_err(|e| pyo3::exceptions::PyValueError::new_err(e))
|
|
}
|
|
|
|
// ---- classmethods ----
|
|
|
|
#[classmethod]
|
|
fn 新建(
|
|
_cls: &Bound<'_, PyType>,
|
|
虚线序列: Vec<Py<虚线Py>>,
|
|
线段方向: &Bound<'_, 相对方向Py>,
|
|
py: Python<'_>,
|
|
) -> Self {
|
|
let rc_list: Vec<Rc<chanlun::structure::dash_line::虚线>> = 虚线序列
|
|
.iter()
|
|
.map(|d| Rc::clone(&d.bind(py).borrow().inner))
|
|
.collect();
|
|
Self {
|
|
inner: Rc::new(chanlun::structure::segment_feat::线段特征::新建(
|
|
rc_list,
|
|
线段方向.borrow().inner,
|
|
)),
|
|
}
|
|
}
|
|
|
|
#[classmethod]
|
|
fn 静态分析(
|
|
_cls: &Bound<'_, PyType>,
|
|
虚线序列: Vec<Py<虚线Py>>,
|
|
线段方向: &Bound<'_, 相对方向Py>,
|
|
四象: &str,
|
|
是否忽视: bool,
|
|
py: Python<'_>,
|
|
) -> Vec<Self> {
|
|
let rc_list: Vec<Rc<chanlun::structure::dash_line::虚线>> = 虚线序列
|
|
.iter()
|
|
.map(|d| Rc::clone(&d.bind(py).borrow().inner))
|
|
.collect();
|
|
chanlun::structure::segment_feat::线段特征::静态分析(
|
|
&rc_list,
|
|
线段方向.borrow().inner,
|
|
四象,
|
|
是否忽视,
|
|
)
|
|
.into_iter()
|
|
.map(|inner| Self { inner })
|
|
.collect()
|
|
}
|
|
|
|
#[classmethod]
|
|
fn 获取分型序列(
|
|
_cls: &Bound<'_, PyType>,
|
|
特征序列: Vec<Py<Self>>,
|
|
py: Python<'_>,
|
|
) -> Vec<特征分型Py> {
|
|
let rc_list: Vec<Rc<chanlun::structure::segment_feat::线段特征>> = 特征序列
|
|
.iter()
|
|
.map(|s| Rc::clone(&s.bind(py).borrow().inner))
|
|
.collect();
|
|
chanlun::structure::segment_feat::线段特征::获取分型序列(&rc_list)
|
|
.into_iter()
|
|
.map(|inner| 特征分型Py {
|
|
inner: Rc::new(inner),
|
|
})
|
|
.collect()
|
|
}
|
|
}
|
|
|
|
// ========== 特征分型 ==========
|
|
|
|
/// 特征分型 — 线段特征序列中的分型节点。
|
|
///
|
|
/// 属性 (只读):
|
|
/// 左: 线段特征|None / 中: 线段特征 / 右: 线段特征|None
|
|
/// 结构: 分型结构 — 顶/底分型判定结果
|
|
#[pyclass(name = "特征分型", unsendable)]
|
|
#[derive(Clone)]
|
|
pub struct 特征分型Py {
|
|
pub(crate) inner: Rc<chanlun::structure::feat_fractal::特征分型>,
|
|
}
|
|
|
|
#[pymethods]
|
|
impl 特征分型Py {
|
|
#[new]
|
|
fn new(
|
|
左: &Bound<'_, 线段特征Py>,
|
|
中: &Bound<'_, 线段特征Py>,
|
|
右: &Bound<'_, 线段特征Py>,
|
|
结构: &Bound<'_, 分型结构Py>,
|
|
) -> Self {
|
|
Self {
|
|
inner: Rc::new(chanlun::structure::feat_fractal::特征分型::new(
|
|
Rc::clone(&左.borrow().inner),
|
|
Rc::clone(&中.borrow().inner),
|
|
Rc::clone(&右.borrow().inner),
|
|
结构.borrow().inner,
|
|
)),
|
|
}
|
|
}
|
|
|
|
#[getter]
|
|
fn 左(&self) -> 线段特征Py {
|
|
线段特征Py {
|
|
inner: Rc::clone(&self.inner.左),
|
|
}
|
|
}
|
|
|
|
#[getter]
|
|
fn 中(&self) -> 线段特征Py {
|
|
线段特征Py {
|
|
inner: Rc::clone(&self.inner.中),
|
|
}
|
|
}
|
|
|
|
#[getter]
|
|
fn 右(&self) -> 线段特征Py {
|
|
线段特征Py {
|
|
inner: Rc::clone(&self.inner.右),
|
|
}
|
|
}
|
|
|
|
#[getter]
|
|
fn 结构(&self) -> 分型结构Py {
|
|
分型结构Py {
|
|
inner: self.inner.结构,
|
|
}
|
|
}
|
|
|
|
fn __str__(&self) -> String {
|
|
format!("{}", self.inner)
|
|
}
|
|
|
|
fn __repr__(&self) -> String {
|
|
self.__str__()
|
|
}
|
|
|
|
fn __eq__(&self, other: &Bound<'_, PyAny>) -> bool {
|
|
if let Ok(other) = other.extract::<PyRef<'_, Self>>() {
|
|
return Rc::as_ptr(&self.inner) == Rc::as_ptr(&other.inner);
|
|
}
|
|
false
|
|
}
|
|
|
|
fn __hash__(&self) -> u64 {
|
|
Rc::as_ptr(&self.inner) as u64
|
|
}
|
|
}
|
|
|
|
pub fn register(m: &Bound<'_, PyModule>) -> PyResult<()> {
|
|
m.add_class::<分型Py>()?;
|
|
m.add_class::<虚线Py>()?;
|
|
m.add_class::<线段特征Py>()?;
|
|
m.add_class::<特征分型Py>()?;
|
|
Ok(())
|
|
}
|