exchange.git - Gitblit

			@@ -62,30 +62,30 @@
			}

			// 4. 计算DEA（基于有效DIF数据的EMA）
			List<BigDecimal> deaValues = EMACalculator.calculateEMA(difValues, signalPeriod, true);
			List<BigDecimal> deaValues = EMACalculator.calculateEMA(difValues, signalPeriod, false);

			// 5. 构建并填充结果（仅包含完整的MACD数据）
			// 有效结果数量 = 有效DIF数量 - DEA周期 + 1
			List<PriceData> result = new ArrayList<>(validLength - signalPeriod + 1);
			// 5. 构建并填充结果（包含所有MACD数据）
			List<PriceData> result = new ArrayList<>(deaValues.size());

			// 从DEA开始有效的索引位置开始计算
			for (int i = signalPeriod - 1; i < validLength; i++) {
			// 从第一个DEA值开始构建结果
			for (int i = 0; i < deaValues.size(); i++) {
			int closeIdx = startIdx + i; // 对应原收盘价列表的索引

			// 创建价格数据对象
			PriceData data = new PriceData(closePrices.get(closeIdx));

			// 设置EMA（修复索引计算，使用正确的偏移位置）
			// 设置EMA（使用正确的偏移位置）
			data.setEmaShort(emaShort.get(closeIdx - shortPeriod + 1));
			data.setEmaLong(emaLong.get(closeIdx - longPeriod + 1));

			// 设置DIF、DEA和MACD柱状图
			data.setDif(difValues.get(i));
			data.setDea(deaValues.get(i - signalPeriod + 1)); // 调整DEA的索引位置
			data.setDea(deaValues.get(i)); // DEA索引直接对应
			data.setMacdHist(data.getDif().subtract(data.getDea())); // MACD柱状图 = DIF - DEA

			result.add(data);
			}
			System.out.println(result.get(result.size() -1));

			return new MACDResult(result, startIdx);
			}
			@@ -102,5 +102,195 @@
			// 默认参数：短期周期12，长期周期26，信号周期9
			return calculateMACD(closePrices, 12, 26, 9);
			}

			/**
			* 判断是否出现顶背离
			* <p>
			* 顶背离：价格创新高，但DIF未创新高，且与价格走势背离
			* 增强空头信号可靠性
			*
			* @param closePrices 原始收盘价列表
			* @param macdResult MACD计算结果
			* @return 是否出现顶背离
			*/
			public static boolean isTopDivergence(List<BigDecimal> closePrices, MACDResult macdResult) {
			List<PriceData> macdData = macdResult.getMacdData();
			int startIdx = macdResult.getStartIndex();

			// 确保有足够的数据点进行判断（至少需要2个高点）
			if (macdData.size() < 10) {
			return false;
			}

			// 找到最近的价格高点和对应的DIF值
			int recentPriceHighIdx = findRecentHighIndex(closePrices, startIdx);
			if (recentPriceHighIdx < startIdx + 2) {
			return false;
			}

			// 找到之前的价格高点和对应的DIF值
			int previousPriceHighIdx = findPreviousHighIndex(closePrices, startIdx, recentPriceHighIdx);
			if (previousPriceHighIdx < startIdx) {
			return false;
			}

			// 获取对应位置的DIF值
			int recentDifIdx = recentPriceHighIdx - startIdx;
			int previousDifIdx = previousPriceHighIdx - startIdx;

			// 边界检查
			if (recentDifIdx >= macdData.size() \|\| previousDifIdx >= macdData.size()) {
			return false;
			}

			BigDecimal recentPrice = closePrices.get(recentPriceHighIdx);
			BigDecimal previousPrice = closePrices.get(previousPriceHighIdx);
			BigDecimal recentDif = macdData.get(recentDifIdx).getDif();
			BigDecimal previousDif = macdData.get(previousDifIdx).getDif();

			// 顶背离条件：价格创新高，但DIF未创新高
			return recentPrice.compareTo(previousPrice) > 0 &&
			recentDif.compareTo(previousDif) < 0;
			}

			/**
			* 判断是否出现底背离
			* <p>
			* 底背离：价格创新低，但DIF未创新低，且与价格走势背离
			* 增强多头信号可靠性
			*
			* @param closePrices 原始收盘价列表
			* @param macdResult MACD计算结果
			* @return 是否出现底背离
			*/
			public static boolean isBottomDivergence(List<BigDecimal> closePrices, MACDResult macdResult) {
			List<PriceData> macdData = macdResult.getMacdData();
			int startIdx = macdResult.getStartIndex();

			// 确保有足够的数据点进行判断（至少需要2个低点）
			if (macdData.size() < 10) {
			return false;
			}

			// 找到最近的价格低点和对应的DIF值
			int recentPriceLowIdx = findRecentLowIndex(closePrices, startIdx);
			if (recentPriceLowIdx < startIdx + 2) {
			return false;
			}

			// 找到之前的价格低点和对应的DIF值
			int previousPriceLowIdx = findPreviousLowIndex(closePrices, startIdx, recentPriceLowIdx);
			if (previousPriceLowIdx < startIdx) {
			return false;
			}

			// 获取对应位置的DIF值
			int recentDifIdx = recentPriceLowIdx - startIdx;
			int previousDifIdx = previousPriceLowIdx - startIdx;

			// 边界检查
			if (recentDifIdx >= macdData.size() \|\| previousDifIdx >= macdData.size()) {
			return false;
			}

			BigDecimal recentPrice = closePrices.get(recentPriceLowIdx);
			BigDecimal previousPrice = closePrices.get(previousPriceLowIdx);
			BigDecimal recentDif = macdData.get(recentDifIdx).getDif();
			BigDecimal previousDif = macdData.get(previousDifIdx).getDif();

			// 底背离条件：价格创新低，但DIF未创新低
			return recentPrice.compareTo(previousPrice) < 0 &&
			recentDif.compareTo(previousDif) > 0;
			}

			/**
			* 找到最近的价格高点索引
			*
			* @param prices 价格列表
			* @param startIdx 起始索引
			* @return 最近的价格高点索引
			*/
			private static int findRecentHighIndex(List<BigDecimal> prices, int startIdx) {
			int highIdx = startIdx;
			BigDecimal highPrice = prices.get(startIdx);

			for (int i = startIdx + 1; i < prices.size(); i++) {
			BigDecimal currentPrice = prices.get(i);
			if (currentPrice.compareTo(highPrice) > 0) {
			highPrice = currentPrice;
			highIdx = i;
			}
			}

			return highIdx;
			}

			/**
			* 找到最近的价格低点索引
			*
			* @param prices 价格列表
			* @param startIdx 起始索引
			* @return 最近的价格低点索引
			*/
			private static int findRecentLowIndex(List<BigDecimal> prices, int startIdx) {
			int lowIdx = startIdx;
			BigDecimal lowPrice = prices.get(startIdx);

			for (int i = startIdx + 1; i < prices.size(); i++) {
			BigDecimal currentPrice = prices.get(i);
			if (currentPrice.compareTo(lowPrice) < 0) {
			lowPrice = currentPrice;
			lowIdx = i;
			}
			}

			return lowIdx;
			}

			/**
			* 找到最近价格高点之前的价格高点索引
			*
			* @param prices 价格列表
			* @param startIdx 起始索引
			* @param recentHighIdx 最近的价格高点索引
			* @return 之前的价格高点索引
			*/
			private static int findPreviousHighIndex(List<BigDecimal> prices, int startIdx, int recentHighIdx) {
			int highIdx = startIdx;
			BigDecimal highPrice = prices.get(startIdx);

			for (int i = startIdx + 1; i < recentHighIdx; i++) {
			BigDecimal currentPrice = prices.get(i);
			if (currentPrice.compareTo(highPrice) > 0) {
			highPrice = currentPrice;
			highIdx = i;
			}
			}

			return highIdx;
			}

			/**
			* 找到最近价格低点之前的价格低点索引
			*
			* @param prices 价格列表
			* @param startIdx 起始索引
			* @param recentLowIdx 最近的价格低点索引
			* @return 之前的价格低点索引
			*/
			private static int findPreviousLowIndex(List<BigDecimal> prices, int startIdx, int recentLowIdx) {
			int lowIdx = startIdx;
			BigDecimal lowPrice = prices.get(startIdx);

			for (int i = startIdx + 1; i < recentLowIdx; i++) {
			BigDecimal currentPrice = prices.get(i);
			if (currentPrice.compareTo(lowPrice) < 0) {
			lowPrice = currentPrice;
			lowIdx = i;
			}
			}

			return lowIdx;
			}
			}