新版仿ok交易所-后端
1
zj
2025-06-18 2ee9dbc37cbe186e98e5ca458033ba517b981d0d
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
package com.yami.trading.service.impl;
 
import com.yami.trading.service.StrongLevelCalculationService;
import org.springframework.stereotype.Service;
 
import java.math.BigDecimal;
import java.math.RoundingMode;
 
/**
 * @program: trading-order-master
 * @description:
 * @create: 2025-01-15 16:12
 **/
@Service
public class StrongLevelCalculationServiceImpl implements StrongLevelCalculationService {
 
    /**
     * 多仓强平价格计算 多仓预估强平价 =(保证金余额-面值 *|张数|*开仓均价)/(面值*张数|*(维持保证金率+手续费率 -1));
     * @param marginBalance 保证金余额
     * @param faceValue 合约面值
     * @param contractQuantity 合约张数
     * @param openingPrice 开仓均价
     * @param maintenanceMarginRate 维持保证金率
     * @param feeRate 手续费率
     * @return
     */
    @Override
    public double calculateLiquidationPrice (double marginBalance, double faceValue, double contractQuantity,
                                             double openingPrice, double maintenanceMarginRate, double feeRate){
        // 计算分子部分
        double numerator = marginBalance - (faceValue * contractQuantity * openingPrice);
 
        // 计算分母部分
        double denominator = faceValue * contractQuantity * (maintenanceMarginRate + feeRate - 1);
 
        // 计算强平价
        double result = numerator / denominator;
        if (result < 0) {
            return 0;
        }
        return new BigDecimal(result).setScale(2, RoundingMode.HALF_UP).doubleValue();
    }
 
 
    /**
     *  空仓强平价格计算   空仓预估强平价 =(保证金余额+面值 *|张数|*开仓均价)/(面值*|张数|*(维持金率+王续费率 +1))
     * @param marginBalance 保证金余额
     * @param faceValue 合约面值
     * @param contractQuantity 合约张数
     * @param openingPrice 开仓均价
     * @param maintenanceMarginRate 维持保证金率
     * @param feeRate 手续费率
     * @return
     */
    @Override
    public double calculateEmptyLiquidationPrice (double marginBalance, double faceValue, double contractQuantity,
                                                  double openingPrice, double maintenanceMarginRate, double feeRate){
        // 计算分子部分
        double numerator = marginBalance + (faceValue * contractQuantity * openingPrice);
 
        // 计算分母部分
        double denominator = faceValue * contractQuantity * (maintenanceMarginRate + feeRate + 1);
 
        // 计算空仓预估强平价
        double result = numerator / denominator;
        if (result < 0) {
            return 0;
        }
        return new BigDecimal(result).setScale(2, RoundingMode.HALF_UP).doubleValue();
    }
 
 
 
    /**
     *
     * @param earnestMoney 保证金
     * @param level 杠杆
     * @param faceValue 面值
     * @param recentQuotation 最新价格
     * @return 合约张数  张数=可用保证金*杠杆倍数/(面值*最新成交价)
     */
    @Override
    public double countSheets(double earnestMoney, int level, double faceValue, double recentQuotation){
        double result = earnestMoney * level / (faceValue * recentQuotation);
 
        BigDecimal bd = new BigDecimal(result).setScale(2, RoundingMode.DOWN);
 
        return bd.doubleValue();
    }
 
 
 
 
    public static void main(String[] args) {
        // 给定参数
        double marginBalance = 10; // 保证金余额
        double faceValue = 0.01; // 合约面值(固定面值不能调整)
        double contractQuantity = 0.5; // 合约张数  张数=可用保证金*杠杆倍数/(面值*最新成交价)
        double openingPrice = 97016.4; // 开仓均价
        double maintenanceMarginRate = 0.004; // 维持保证金率(固定不变)
        double feeRate = 0.0005; // 手续费率  根据实际设置
 
        // 计算强平价
        double liquidationPrice = demoA(marginBalance, faceValue, contractQuantity,
                openingPrice, maintenanceMarginRate, feeRate);
 
        // 输出结果
        System.out.println("多仓预估强平价: " + liquidationPrice);
 
        // 计算空仓预估强平价
        double liquidationPrice2 = demoB(marginBalance, faceValue, contractQuantity,
                openingPrice, maintenanceMarginRate, feeRate);
 
        // 输出结果
        System.out.println("空仓预估强平价: " + liquidationPrice2);
    }
 
    public static double demoA (double marginBalance, double faceValue, double contractQuantity,
                                                    double openingPrice, double maintenanceMarginRate, double feeRate){
        // 计算分子部分
        double numerator = marginBalance - (faceValue * contractQuantity * openingPrice);
 
        // 计算分母部分
        double denominator = faceValue * contractQuantity * (maintenanceMarginRate + feeRate - 1);
 
        // 计算强平价
        double result = numerator / denominator;
        if (result < 0) {
            return 0;
        }
        return new BigDecimal(result).setScale(2, RoundingMode.HALF_UP).doubleValue();
    }
 
 
    /**
     *  空仓强平价格计算   空仓预估强平价 =(保证金余额+面值 *|张数|*开仓均价)/(面值*|张数|*(维持金率+王续费率 +1))
     * @param marginBalance 保证金余额
     * @param faceValue 合约面值
     * @param contractQuantity 合约张数
     * @param openingPrice 开仓均价
     * @param maintenanceMarginRate 维持保证金率
     * @param feeRate 手续费率
     * @return
     */
    public static double demoB (double marginBalance, double faceValue, double contractQuantity,
                                                         double openingPrice, double maintenanceMarginRate, double feeRate){
        // 计算分子部分
        double numerator = marginBalance + (faceValue * contractQuantity * openingPrice);
 
        // 计算分母部分
        double denominator = faceValue * contractQuantity * (maintenanceMarginRate + feeRate + 1);
 
        // 计算空仓预估强平价
        double result = numerator / denominator;
        if (result < 0) {
            return 0;
        }
        return new BigDecimal(result).setScale(2, RoundingMode.HALF_UP).doubleValue();
    }
 
}