gavindiaz/chanlun.rs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

修复 “cargo clippy -- -D warnings” 产生的错误

Browse Source
This commit is contained in:
YuWuKunCheng
2026-05-30 13:25:57 +08:00
parent 22109d8b30
commit af3ebf13c8
13 changed files with 162 additions and 189 deletions
Download Patch File Download Diff File Expand all files Collapse all files
chanlun-py/Cargo.toml
+2 -2
View File
@@ -1,6 +1,6 @@
[package]
name = "chanlun-py"
version = "26.5.101"
version = "26.5.102"
edition = "2021"
description = "缠论技术分析库 — Rust 高性能 Python 绑定"
authors = ["YuYuKunKun"]
@@ -12,7 +12,7 @@ crate-type = ["cdylib"]
name = "chanlun"
[dependencies]
chanlun = "26.5.5" # { path = "../chanlun" }
chanlun = { path = "../chanlun" }
pyo3 = { version = "0.28", features = ["experimental-inspect"] }
serde_json = "1"
chrono = "0.4"
chanlun-py/pyproject.toml
+1 -1
View File
@@ -4,7 +4,7 @@ build-backend = "maturin"
[project]
name = "chanlun"
version = "2605.101"
version = "2605.102"
description = "缠论技术分析库 — Rust 高性能实现"
readme = { file = "README.md", content-type = "text/markdown" }
license = { file = "LICENSE", content-type = "text/plain" }
chanlun/src/algorithm/bi.rs
+15 -24
View File
@@ -78,16 +78,18 @@ impl 笔 {
- 高_k.标的K线.read().unwrap().序号)
.unsigned_abs() as usize;
// 向上笔
if 筆.方向().是否向上() && 低_k.低.get() < 筆.低() {
if 原始数量 >= 配置.笔弱化_原始数量 as usize {
return 配置.笔内元素数量 as usize;
}
if 筆.方向().是否向上()
&& 低_k.低.get() < 筆.低()
&& 原始数量 >= 配置.笔弱化_原始数量 as usize
{
return 配置.笔内元素数量 as usize;
}
// 向下笔
if 筆.方向().是否向下() && 低_k.低.get() > 筆.高() {
if 原始数量 >= 配置.笔弱化_原始数量 as usize {
return 配置.笔内元素数量 as usize;
}
if 筆.方向().是否向下()
&& 低_k.低.get() > 筆.高()
&& 原始数量 >= 配置.笔弱化_原始数量 as usize
{
return 配置.笔内元素数量 as usize;
}
}
}
@@ -960,22 +962,11 @@ impl 笔 {
for i in 3..基础序列.len() - 1 {
let k = &基础序列[i];
if *k.分型.read().unwrap() == Some(分型结构::顶) && 筆.方向() == 相对方向::向上
{
let 左 = Arc::clone(&基础序列[i - 1]);
let 中 = Arc::clone(k);
let 右 = Arc::clone(&基础序列[i + 1]);
let 武 = 分型::new(Some(左), 中, Some(右));
let 当前笔 = 虚线::创建笔(Arc::clone(&文), Arc::new(武), true);
当前笔
.序号
.store(筆.序号.load(Ordering::Relaxed), Ordering::Relaxed);
if Self::自检(&当前笔, 观察员) {
笔序列.push(当前笔);
}
} else if *k.分型.read().unwrap() == Some(分型结构::底)
&& 筆.方向() == 相对方向::向下
{
let 匹配顶 =
*k.分型.read().unwrap() == Some(分型结构::顶) && 筆.方向() == 相对方向::向上;
let 匹配底 =
*k.分型.read().unwrap() == Some(分型结构::底) && 筆.方向() == 相对方向::向下;
if 匹配顶 || 匹配底 {
let 左 = Arc::clone(&基础序列[i - 1]);
let 中 = Arc::clone(k);
let 右 = Arc::clone(&基础序列[i + 1]);
chanlun/src/algorithm/divergence.rs
+4 -4
View File
@@ -39,13 +39,13 @@ impl 背驰分析 {
) -> bool {
let 进入MACD = Self::_获取MACD面积(
K线序列,
&*进入段.文.中.标的K线.read().unwrap(),
&*进入段.武.read().unwrap().中.标的K线.read().unwrap(),
&进入段.文.中.标的K线.read().unwrap(),
&进入段.武.read().unwrap().中.标的K线.read().unwrap(),
);
let 离开MACD = Self::_获取MACD面积(
K线序列,
&*离开段.文.中.标的K线.read().unwrap(),
&*离开段.武.read().unwrap().中.标的K线.read().unwrap(),
&离开段.文.中.标的K线.read().unwrap(),
&离开段.武.read().unwrap().中.标的K线.read().unwrap(),
);
// 计算面积（绝对值求和）
chanlun/src/algorithm/hub.rs
+6 -6
View File
@@ -415,7 +415,7 @@ impl 中枢 {
中枢序列: &mut Vec<Arc<中枢>>,
待弹出: &Arc<中枢>,
) -> Option<Arc<中枢>> {
if 中枢序列.last().map(|x| Arc::as_ptr(x)) == Some(Arc::as_ptr(待弹出)) {
if 中枢序列.last().map(Arc::as_ptr) == Some(Arc::as_ptr(待弹出)) {
中枢序列.pop()
} else {
None
@@ -430,7 +430,7 @@ impl 中枢 {
中枢序列: &mut Vec<Arc<中枢>>,
跳过首部: bool,
标识: &str,
层级: i64,
_层级: i64,
) {
if 虚线序列.len() < 3 {
return;
@@ -472,7 +472,7 @@ impl 中枢 {
));
Self::向中枢序列尾部添加(中枢序列, 新中枢);
// Python: return 中枢递归分析(虚线序列, 中枢序列, ...)
Self::分析(虚线序列, 中枢序列, 跳过首部, 标识, 层级);
Self::分析(虚线序列, 中枢序列, 跳过首部, 标识, _层级);
return;
}
}
@@ -487,7 +487,7 @@ impl 中枢 {
if needs_pop {
let 当前中枢 = Arc::clone(&中枢序列[当前中枢_idx]);
Self::从中枢序列尾部弹出(中枢序列, &当前中枢);
Self::分析(虚线序列, 中枢序列, 跳过首部, 标识, 层级);
Self::分析(虚线序列, 中枢序列, 跳过首部, 标识, _层级);
return;
}
@@ -508,8 +508,8 @@ impl 中枢 {
let mut 中枢低 = 中枢序列[当前中枢_idx].低();
let mut 候选序列: Vec<Arc<虚线>> = Vec::new();
for i in 起始索引..虚线序列.len() {
let 当前虚线 = Arc::clone(&虚线序列[i]);
for 当前虚线_ref in &虚线序列[起始索引..] {
let 当前虚线 = Arc::clone(当前虚线_ref);
// 检查是否超出中枢范围（缺口）
if crate::types::相对方向::分析(中枢高, 中枢低, 当前虚线.高(), 当前虚线.低()).是否缺口()
chanlun/src/algorithm/segment.rs
+67 -83
View File
@@ -38,6 +38,14 @@ use std::sync::Arc;
/// 线段 — 从笔生成线段的算法集合（静态方法命名空间）
pub struct 线段;
type 分割结果 = (
Vec<Arc<虚线>>,
Vec<Arc<虚线>>,
Vec<Arc<虚线>>,
Option<Arc<虚线>>,
);
type 中枢序列组 = (Vec<Arc<中枢>>, Vec<Arc<中枢>>, Vec<Arc<中枢>>);
impl 线段 {
// ================================================================
// 基础操作
@@ -53,8 +61,7 @@ impl 线段 {
let 段 = Self::取段(段_rc);
if !段.基础序列.read().unwrap().is_empty() {
if !分型::判断分型(
&*段
.基础序列
&段.基础序列
.read()
.unwrap()
.last()
@@ -182,11 +189,9 @@ impl 线段 {
if !序列.iter().any(|x| Arc::as_ptr(x) == Arc::as_ptr(元素)) {
break;
}
if !基础序列.is_empty() {
if !基础序列.last().unwrap().之后是(元素) {
eprintln!("线段._验证序列 数据不连续");
break;
}
if !基础序列.is_empty() && !基础序列.last().unwrap().之后是(元素) {
eprintln!("线段._验证序列 数据不连续");
break;
}
基础序列.push(Arc::clone(元素));
}
@@ -204,10 +209,8 @@ impl 线段 {
if !序列.iter().any(|x| Arc::as_ptr(x) == Arc::as_ptr(元素)) {
break;
}
if !基础序列.is_empty() {
if !基础序列.last().unwrap().之后是(元素) {
break;
}
if !基础序列.is_empty() && !基础序列.last().unwrap().之后是(元素) {
break;
}
基础序列.push(Arc::clone(元素));
}
@@ -301,7 +304,7 @@ impl 线段 {
/// 特征分型终结 — 检查特征序列是否形成正常分型终结
pub fn 特征分型终结(段: &虚线) -> bool {
let 特征序列 = 线段特征::静态分析(
&*段.基础序列.read().unwrap(),
&段.基础序列.read().unwrap(),
段.方向(),
&Self::四象(段),
false,
@@ -347,11 +350,9 @@ impl 线段 {
return;
}
for 特征 in &序列 {
if let Some(ref f) = 特征 {
if f.方向() == 段.方向() {
panic!("特征序列方向不匹配[{}]", 行号);
}
for f in 序列.iter().flatten() {
if f.方向() == 段.方向() {
panic!("特征序列方向不匹配[{}]", 行号);
}
}
@@ -472,15 +473,7 @@ impl 线段 {
// ================================================================
/// 分割序列 — 将线段的基础序列分为前、后、第三买卖线、贯穿伤
pub fn 分割序列(
段: &虚线,
所属中枢: Option<&中枢>,
) -> (
Vec<Arc<虚线>>,
Vec<Arc<虚线>>,
Vec<Arc<虚线>>,
Option<Arc<虚线>>,
) {
pub fn 分割序列(段: &虚线, 所属中枢: Option<&中枢>) -> 分割结果 {
if 段.模式.read().unwrap().as_str() != "文武" {
return (
段.基础序列.read().unwrap().clone(),
@@ -517,9 +510,9 @@ impl 线段 {
let mut 状态 = None;
if let Some(ref 中枢) = 所属中枢 {
if let Some(中枢) = 所属中枢 {
*中枢.本级_第三买卖线.write().unwrap() = None;
let 尾部 = if let Some(ref 后笔) = 后.last() {
let 尾部 = if let Some(后笔) = 后.last() {
后笔.武.read().unwrap().clone()
} else {
段.武.read().unwrap().clone()
@@ -572,7 +565,7 @@ impl 线段 {
if !第三买卖线.is_empty() {
第三买卖线.reverse();
if let Some(ref 中枢) = 所属中枢 {
if let Some(中枢) = 所属中枢 {
*中枢.本级_第三买卖线.write().unwrap() = Some(Arc::clone(&第三买卖线[0]));
}
}
@@ -626,13 +619,11 @@ impl 线段 {
}) == Some(true)
{
Some(Arc::clone(最近特征.元素.last().unwrap()))
} else if let Some(b) = 笔::以武会友(
&*段2.基础序列.read().unwrap(),
&*最近特征.元素.last().unwrap().武.read().unwrap(),
) {
Some(b)
} else {
None
笔::以武会友(
&段2.基础序列.read().unwrap(),
&最近特征.元素.last().unwrap().武.read().unwrap(),
)
};
if 特征后一笔.is_none() {
@@ -686,14 +677,11 @@ impl 线段 {
}
/// 获取内部中枢序列 — 内部实现
fn 获取内部中枢序列_内部(
段: &虚线,
_配置: &缠论配置,
) -> (Vec<Arc<中枢>>, Vec<Arc<中枢>>, Vec<Arc<中枢>>) {
fn 获取内部中枢序列_内部(段: &虚线, _配置: &缠论配置) -> 中枢序列组 {
if 段.模式.read().unwrap().as_str() != "文武" {
中枢::分析(
&*段.基础序列.read().unwrap(),
&mut *段.合_中枢序列.write().unwrap(),
&段.基础序列.read().unwrap(),
&mut 段.合_中枢序列.write().unwrap(),
true,
&format!(
"{}_{}_合_",
@@ -714,7 +702,7 @@ impl 线段 {
中枢::分析(
&前,
&mut *段.实_中枢序列.write().unwrap(),
&mut 段.实_中枢序列.write().unwrap(),
true,
&format!(
"{}_{}_实_",
@@ -725,7 +713,7 @@ impl 线段 {
);
中枢::分析(
&后,
&mut *段.虚_中枢序列.write().unwrap(),
&mut 段.虚_中枢序列.write().unwrap(),
true,
&format!(
"{}_{}_虚_",
@@ -735,8 +723,8 @@ impl 线段 {
0,
);
中枢::分析(
&*段.基础序列.read().unwrap(),
&mut *段.合_中枢序列.write().unwrap(),
&段.基础序列.read().unwrap(),
&mut 段.合_中枢序列.write().unwrap(),
true,
&format!(
"{}_{}_合_",
@@ -755,9 +743,8 @@ impl 线段 {
/// 获取内部中枢序列
pub fn 获取内部中枢序列(
段_rc: &Arc<虚线>,
配置: &缠论配置,
) -> (Vec<Arc<中枢>>, Vec<Arc<中枢>>, Vec<Arc<中枢>>) {
段_rc: &Arc<虚线>, 配置: &缠论配置
) -> 中枢序列组 {
let 段 = Self::取段(段_rc);
Self::获取内部中枢序列_内部(段, 配置)
}
@@ -942,7 +929,7 @@ impl 线段 {
*cur.基础序列.write().unwrap() = 当前线段基础序列;
}
let idx = 线段序列.len() - 1;
Self::刷新(&mut 线段序列[idx], 配置);
Self::刷新(&线段序列[idx], 配置);
true
}
@@ -1038,7 +1025,7 @@ impl 线段 {
}
}
if let Some(_) = 开始序号_opt {
if 开始序号_opt.is_some() {
let idx = 线段序列.len() - 1;
let seg_rc = Arc::clone(&线段序列[idx]);
for 临时虚线 in &待添加元素 {
@@ -1047,7 +1034,7 @@ impl 线段 {
线段序列[idx] = seg_rc;
}
let idx = 线段序列.len() - 1;
Self::刷新(&mut 线段序列[idx], 配置);
Self::刷新(&线段序列[idx], 配置);
let 当前线段 = Arc::clone(&线段序列[idx]);
if 当前线段.特征序列.read().unwrap().len() >= 3
@@ -1310,8 +1297,8 @@ impl 线段 {
}
// ---- 3. 确保当前线段有效 ----
let mut 当前线段_rc = Arc::clone(线段序列.last().unwrap());
Self::序列重置(&mut 当前线段_rc, 笔序列);
let 当前线段_rc = Arc::clone(线段序列.last().unwrap());
Self::序列重置(&当前线段_rc, 笔序列);
let seg_idx = 线段序列.len() - 1;
线段序列[seg_idx] = 当前线段_rc;
@@ -1347,7 +1334,7 @@ impl 线段 {
// Refresh current segment
let idx = 线段序列.len() - 1;
Self::刷新(&mut 线段序列[idx], 配置);
Self::刷新(&线段序列[idx], 配置);
// ---- 5. 调用一次全局修正 ----
Self::_缺口突破(线段序列, 配置, 当前层级);
@@ -1375,20 +1362,20 @@ impl 线段 {
let mut 需要递归 = false;
for i in 起始索引..笔序列.len() {
let 当前虚线 = Arc::clone(&笔序列[i]);
for 当前虚线_ref in &笔序列[起始索引..] {
let 当前虚线 = Arc::clone(当前虚线_ref);
let 当前线段 = Arc::clone(线段序列.last().unwrap());
let 四象 = Self::四象(&当前线段);
// 向当前线段添加笔
let mut 线段_rc = Arc::clone(线段序列.last().unwrap());
Self::添加虚线(&mut 线段_rc, Arc::clone(&当前虚线));
let 线段_rc = Arc::clone(线段序列.last().unwrap());
Self::添加虚线(&线段_rc, Arc::clone(&当前虚线));
let seg_idx = 线段序列.len() - 1;
线段序列[seg_idx] = 线段_rc;
// 刷新
let idx = 线段序列.len() - 1;
Self::刷新(&mut 线段序列[idx], 配置);
Self::刷新(&线段序列[idx], 配置);
// 依次尝试四种修正
if Self::_缺口突破(线段序列, 配置, 当前层级) {
@@ -1444,14 +1431,14 @@ impl 线段 {
break;
}
// 向新段添加当前虚线
let mut 新段_rc = Arc::clone(线段序列.last().unwrap());
Self::添加虚线(&mut 新段_rc, Arc::clone(&当前虚线));
let 新段_rc = Arc::clone(线段序列.last().unwrap());
Self::添加虚线(&新段_rc, Arc::clone(&当前虚线));
let seg_idx = 线段序列.len() - 1;
线段序列[seg_idx] = 新段_rc;
}
let idx = 线段序列.len() - 1;
Self::刷新(&mut 线段序列[idx], 配置);
Self::刷新(&线段序列[idx], 配置);
}
if 需要递归 {
@@ -1572,8 +1559,8 @@ impl 线段 {
}
// 验证当前线段
let mut 当前线段_rc = Arc::clone(线段序列.last().unwrap());
Self::验证序列(&mut 当前线段_rc, 虚线序列);
let 当前线段_rc = Arc::clone(线段序列.last().unwrap());
Self::验证序列(&当前线段_rc, 虚线序列);
let seg_idx = 线段序列.len() - 1;
线段序列[seg_idx] = 当前线段_rc;
@@ -1597,7 +1584,7 @@ impl 线段 {
*cur.基础序列.write().unwrap() = 前三个;
}
let seg_idx = 线段序列.len() - 1;
Self::武终(&mut 线段序列[seg_idx], 0);
Self::武终(&线段序列[seg_idx], 0);
} else {
let 当前 = Arc::clone(线段序列.last().unwrap());
Self::_弹出扩展线段(线段序列, &当前, line!());
@@ -1608,7 +1595,7 @@ impl 线段 {
// 武终
let idx = 线段序列.len() - 1;
Self::武终(&mut 线段序列[idx], 0);
Self::武终(&线段序列[idx], 0);
let 当前线段 = Arc::clone(线段序列.last().unwrap());
if 当前线段
@@ -1647,18 +1634,18 @@ impl 线段 {
let 相对关系 = 相对方向::分析(左.高(), 左.低(), 右.高(), 右.低());
if 相对关系.是否缺口() {
let mut 段_rc = Arc::clone(线段序列.last().unwrap());
Self::添加虚线(&mut 段_rc, Arc::clone(左));
let 段_rc = Arc::clone(线段序列.last().unwrap());
Self::添加虚线(&段_rc, Arc::clone(左));
let seg_idx = 线段序列.len() - 1;
线段序列[seg_idx] = 段_rc;
let mut 段_rc = Arc::clone(线段序列.last().unwrap());
Self::添加虚线(&mut 段_rc, Arc::clone(中));
let 段_rc = Arc::clone(线段序列.last().unwrap());
Self::添加虚线(&段_rc, Arc::clone(中));
let seg_idx = 线段序列.len() - 1;
线段序列[seg_idx] = 段_rc;
let seg_idx = 线段序列.len() - 1;
Self::武终(&mut 线段序列[seg_idx], 0);
Self::武终(&线段序列[seg_idx], 0);
continue;
}
@@ -1730,8 +1717,8 @@ impl 线段 {
{
let k线序列 = K线::截取rc(
&观察员.普通K线序列,
&*阳[阳.len() - 3].文.中.标的K线.read().unwrap(),
&*阳[阳.len() - 1]
&阳[阳.len() - 3].文.中.标的K线.read().unwrap(),
&阳[阳.len() - 1]
.武
.read()
.unwrap()
@@ -1851,15 +1838,13 @@ impl 线段 {
for 筆 in &阳 {
if 笔序列.len() >= 3 {
let 筆停顿 = 笔::获取所有停顿位置(筆, 观察员);
let mut 停顿列表: Vec<Arc<虚线>> =
筆停顿.into_iter().map(|b| Arc::new(b)).collect();
let mut 停顿列表: Vec<Arc<虚线>> = 筆停顿.into_iter().map(Arc::new).collect();
停顿列表.push(Arc::clone(筆));
for 停顿 in &停顿列表 {
笔序列.push(Arc::clone(停顿));
线段序列.clear();
let 笔序列_slice: Vec<Arc<虚线>> =
笔序列.iter().map(|b| Arc::clone(b)).collect();
let 笔序列_slice: Vec<Arc<虚线>> = 笔序列.iter().map(Arc::clone).collect();
Self::分析(
&笔序列_slice,
&mut 线段序列,
@@ -1881,13 +1866,12 @@ impl 线段 {
if !重复 {
if let Some(最后线段) = 线段序列.last() {
if 最后线段.基础序列.read().unwrap().len() % 2 == 1 {
let 新段 =
虚线::创建线段(&*最后线段.基础序列.read().unwrap());
let 新段 = 虚线::创建线段(&最后线段.基础序列.read().unwrap());
新段
.序号
.store(段.序号.load(Ordering::Relaxed), Ordering::Relaxed);
let mut 新段_rc = Arc::new(新段);
Self::刷新(&mut 新段_rc, &观察员.配置);
let 新段_rc = Arc::new(新段);
Self::刷新(&新段_rc, &观察员.配置);
let 新段_inner =
Arc::try_unwrap(新段_rc).unwrap_or_else(|rc| (*rc).clone());
if 新段_inner.方向() == 段.方向() {
@@ -1919,8 +1903,8 @@ impl 线段 {
let mut 结果 = Vec::new();
for 段 in 停顿位置 {
let mut 段_rc = Arc::new(段);
Self::获取内部中枢序列(&mut 段_rc, &观察员.配置);
let 段_rc = Arc::new(段);
Self::获取内部中枢序列(&段_rc, &观察员.配置);
if Self::判断线段内部是否背驰(&段_rc, 观察员) {
结果.push(Arc::clone(&段_rc.武.read().unwrap().中));
}
chanlun/src/indicators/kdj.rs
+1
View File
@@ -77,6 +77,7 @@ impl Default for 随机指标 {
impl 随机指标 {
/// 首次计算 KDJ（无历史数据时）
#[allow(clippy::too_many_arguments)]
pub fn 首次计算(
初始最高价: f64,
初始最低价: f64,
chanlun/src/kline/bar.rs
+1
View File
@@ -141,6 +141,7 @@ impl K线 {
}
/// 创建普通K线
#[allow(clippy::too_many_arguments)]
pub fn 创建普K(
标识: &str,
时间戳: i64,
chanlun/src/kline/chan_kline.rs
+41 -49
View File
@@ -199,19 +199,16 @@ impl 缠论K线 {
if k线.时间戳.load(Ordering::Relaxed) <= k.时间戳.load(Ordering::Relaxed)
&& k.时间戳.load(Ordering::Relaxed)
<= k线.时间戳.load(Ordering::Relaxed) + k线.周期
&& (k线.分型特征值.get() - k.分型特征值.get()).abs() < f64::EPSILON
{
if (k线.分型特征值.get() - k.分型特征值.get()).abs() < f64::EPSILON
{
return k.时间戳.load(Ordering::Relaxed);
}
return k.时间戳.load(Ordering::Relaxed);
}
} else if k.时间戳.load(Ordering::Relaxed) <= k线.时间戳.load(Ordering::Relaxed)
&& k线.时间戳.load(Ordering::Relaxed)
<= k.时间戳.load(Ordering::Relaxed) + k.周期
&& (k线.分型特征值.get() - k.分型特征值.get()).abs() < f64::EPSILON
{
if (k线.分型特征值.get() - k.分型特征值.get()).abs() < f64::EPSILON {
return k.时间戳.load(Ordering::Relaxed);
}
return k.时间戳.load(Ordering::Relaxed);
}
}
}
@@ -219,6 +216,7 @@ impl 缠论K线 {
}
/// 创建缠K
#[allow(clippy::too_many_arguments)]
pub fn 创建缠K(
时间戳: i64,
高: f64,
@@ -420,43 +418,41 @@ impl 缠论K线 {
if 之前普K.时间戳 == 当前K线.时间戳 {
// 同时间戳更新
当前K线.序号 = 之前普K.序号;
if 配置.计算指标 {
if 普K序列.len() >= 2 {
if let Some(ref prev_macd) = 普K序列[普K序列.len() - 2].macd {
当前K线.macd = Some(平滑异同移动平均线::增量计算(
prev_macd,
K线取值(
当前K线.开盘价,
当前K线.高,
当前K线.低,
当前K线.收盘价,
&配置.指标计算方式,
),
当前K线.时间戳,
));
}
if let Some(ref prev_rsi) = 普K序列[普K序列.len() - 2].rsi {
当前K线.rsi = Some(相对强弱指数::增量计算(
prev_rsi,
K线取值(
当前K线.开盘价,
当前K线.高,
当前K线.低,
当前K线.收盘价,
&配置.指标计算方式,
),
当前K线.时间戳,
));
}
if let Some(ref prev_kdj) = 普K序列[普K序列.len() - 2].kdj {
当前K线.kdj = Some(随机指标::增量计算(
prev_kdj,
if 配置.计算指标 && 普K序列.len() >= 2 {
if let Some(ref prev_macd) = 普K序列[普K序列.len() - 2].macd {
当前K线.macd = Some(平滑异同移动平均线::增量计算(
prev_macd,
K线取值(
当前K线.开盘价,
当前K线.高,
当前K线.低,
当前K线.收盘价,
当前K线.时间戳,
));
}
&配置.指标计算方式,
),
当前K线.时间戳,
));
}
if let Some(ref prev_rsi) = 普K序列[普K序列.len() - 2].rsi {
当前K线.rsi = Some(相对强弱指数::增量计算(
prev_rsi,
K线取值(
当前K线.开盘价,
当前K线.高,
当前K线.低,
当前K线.收盘价,
&配置.指标计算方式,
),
当前K线.时间戳,
));
}
if let Some(ref prev_kdj) = 普K序列[普K序列.len() - 2].kdj {
当前K线.kdj = Some(随机指标::增量计算(
prev_kdj,
当前K线.高,
当前K线.低,
当前K线.收盘价,
当前K线.时间戳,
));
}
}
普K序列.pop();
@@ -514,7 +510,7 @@ impl 缠论K线 {
if !缠K序列.is_empty() {
let len = 缠K序列.len();
let (左边, 右边) = 缠K序列.split_at_mut(len - 1);
let 之前缠K: Option<&缠论K线> = 左边.last().map(|rc| Arc::as_ref(rc));
let 之前缠K: Option<&缠论K线> = 左边.last().map(Arc::as_ref);
let 最后一个缠K = &*右边[0];
let (新缠K, 模式) = Self::兼并(之前缠K, 最后一个缠K, 当前K线_ref, 配置);
@@ -614,7 +610,7 @@ impl 缠论K线 {
Arc::clone(&缠K序列[idx - 2]),
Some(Arc::clone(&缠K序列[idx - 1])),
));
return (状态, Some(形态));
(状态, Some(形态))
}
/// 截取缠K序列从始到终
@@ -623,12 +619,8 @@ impl 缠论K线 {
始: &缠论K线,
终: &缠论K线,
) -> Option<Vec<Arc<缠论K线>>> {
let 始_idx = 序列
.iter()
.position(|k| Arc::as_ptr(k) == (始 as *const _))?;
let 终_idx = 序列
.iter()
.position(|k| Arc::as_ptr(k) == (终 as *const _))?;
let 始_idx = 序列.iter().position(|k| std::ptr::eq(Arc::as_ptr(k), 始))?;
let 终_idx = 序列.iter().position(|k| std::ptr::eq(Arc::as_ptr(k), 终))?;
Some(序列[始_idx..=终_idx].to_vec())
}
}
chanlun/src/structure/dash_line.rs
+19 -16
View File
@@ -435,8 +435,8 @@ impl 虚线 {
pub fn 计算MACD柱子均值(普K序列: &[Arc<K线>], 实线: &虚线) -> f64 {
let K线序列 = K线::截取rc(
普K序列,
&*实线.文.中.标的K线.read().unwrap(),
&*实线.武.read().unwrap().中.标的K线.read().unwrap(),
&实线.文.中.标的K线.read().unwrap(),
&实线.武.read().unwrap().中.标的K线.read().unwrap(),
);
if K线序列.is_empty() {
return 0.0;
@@ -453,8 +453,8 @@ impl 虚线 {
pub fn 计算MACD柱子均值_阴(普K序列: &[Arc<K线>], 实线: &虚线) -> Option<f64> {
let K线序列 = K线::截取rc(
普K序列,
&*实线.文.中.标的K线.read().unwrap(),
&*实线.武.read().unwrap().中.标的K线.read().unwrap(),
&实线.文.中.标的K线.read().unwrap(),
&实线.武.read().unwrap().中.标的K线.read().unwrap(),
);
let 总: Vec<f64> = K线序列
.iter()
@@ -473,8 +473,8 @@ impl 虚线 {
pub fn 计算MACD柱子均值_阳(普K序列: &[Arc<K线>], 实线: &虚线) -> Option<f64> {
let K线序列 = K线::截取rc(
普K序列,
&*实线.文.中.标的K线.read().unwrap(),
&*实线.武.read().unwrap().中.标的K线.read().unwrap(),
&实线.文.中.标的K线.read().unwrap(),
&实线.武.read().unwrap().中.标的K线.read().unwrap(),
);
let 总: Vec<f64> = K线序列
.iter()
@@ -549,8 +549,8 @@ impl 虚线 {
};
let K线序列 = K线::截取rc(
普K序列,
&*实线.文.中.标的K线.read().unwrap(),
&*实线.武.read().unwrap().中.标的K线.read().unwrap(),
&实线.文.中.标的K线.read().unwrap(),
&实线.武.read().unwrap().中.标的K线.read().unwrap(),
);
let 所有柱子: Vec<f64> = K线序列
.iter()
@@ -583,7 +583,7 @@ impl 虚线 {
if 方向 == 相对方向::向上 {
let 柱子序列: Vec<&Arc<K线>> = 普K序列
.iter()
.filter(|k| k.macd.as_ref().map_or(false, |m| m.MACD柱 > 0.0))
.filter(|k| k.macd.as_ref().is_some_and(|m| m.MACD柱 > 0.0))
.collect();
if 柱子序列.is_empty() {
return [false, false, false];
@@ -603,7 +603,7 @@ impl 虚线 {
.unwrap_or(std::cmp::Ordering::Equal)
})
.unwrap();
let mut 柱对 = vec![Arc::clone(*最高柱子), Arc::clone(最后)];
let mut 柱对 = [Arc::clone(*最高柱子), Arc::clone(最后)];
柱对.sort_by_key(|k| k.时间戳);
if let (Some(m0), Some(m1)) = (柱对[0].macd.as_ref(), 柱对[1].macd.as_ref()) {
if m0.MACD柱 > m1.MACD柱 && 柱对[0].高 < 柱对[1].高 {
@@ -649,7 +649,7 @@ impl 虚线 {
} else {
let 柱子序列: Vec<&Arc<K线>> = 普K序列
.iter()
.filter(|k| k.macd.as_ref().map_or(false, |m| m.MACD柱 < 0.0))
.filter(|k| k.macd.as_ref().is_some_and(|m| m.MACD柱 < 0.0))
.collect();
if 柱子序列.is_empty() {
return [false, false, false];
@@ -670,7 +670,7 @@ impl 虚线 {
.unwrap_or(std::cmp::Ordering::Equal)
})
.unwrap();
let mut 柱对 = vec![Arc::clone(*最高柱子), Arc::clone(最后)];
let mut 柱对 = [Arc::clone(*最高柱子), Arc::clone(最后)];
柱对.sort_by_key(|k| k.时间戳);
if let (Some(m0), Some(m1)) = (柱对[0].macd.as_ref(), 柱对[1].macd.as_ref()) {
if m0.MACD柱 < m1.MACD柱 && 柱对[0].低 > 柱对[1].低 {
@@ -947,10 +947,13 @@ impl 虚线 {
}
}
if !结果 && 意义 && 实线.武.read().unwrap().中.与MACD柱子匹配() {
if Self::武之MACD极值(普K序列, 实线) && 背驰过.len() > 2 {
return (true, "没结果, 极值, 柱子分型匹配, 背驰过大于2次".into());
}
if !结果
&& 意义
&& 实线.武.read().unwrap().中.与MACD柱子匹配()
&& Self::武之MACD极值(普K序列, 实线)
&& 背驰过.len() > 2
{
return (true, "没结果, 极值, 柱子分型匹配, 背驰过大于2次".into());
}
(结果, "".into())
chanlun/src/structure/segment_feat.rs
+1 -1
View File
@@ -173,7 +173,7 @@ impl 线段特征 {
/// 新建特征序列元素
pub fn 新建(虚线序列: Vec<Arc<虚线>>, 线段方向: 相对方向) -> Self {
let 标识 = format!("特征<虚线>");
let 标识 = "特征<虚线>".to_string();
Self::new(标识, 虚线序列, 线段方向)
}
chanlun/src/types/fractal.rs
+1
View File
@@ -92,6 +92,7 @@ impl 分型结构 {
)
}
#[allow(clippy::too_many_arguments)]
fn 分析_内部(
左高: f64,
左低: f64,
chanlun/src/utils/format.rs
+3 -3
View File
@@ -42,7 +42,7 @@ pub fn format_f64_g(value: f64) -> String {
let exp = abs.log10().floor() as i32;
// Python :g 科学计数法边界: exp < -4 或 exp >= p (=6)
if exp < -4 || exp >= 6 {
if !(-4..6).contains(&exp) {
let significand = value / 10_f64.powi(exp);
let s = format!("{:.5}", significand);
let s = s.trim_end_matches('0').trim_end_matches('.');
@@ -57,12 +57,12 @@ pub fn format_f64_g(value: f64) -> String {
}
let s = format!("{:.prec$}", value, prec = 6 - int_digits);
let s = s.trim_end_matches('0');
return s.trim_end_matches('.').to_string();
s.trim_end_matches('.').to_string()
} else {
let leading_zeros = (-exp) as usize;
let s = format!("{:.prec$}", value, prec = leading_zeros + 5);
let s = s.trim_end_matches('0');
return s.trim_end_matches('.').to_string();
s.trim_end_matches('.').to_string()
}
}