1def gibbs_phase_rule(components, phases):
2    """
3    使用吉布斯相规则计算自由度
4    
5    参数：
6        components (int): 系统中的组分数量
7        phases (int): 系统中的相数量
8        
9    返回：
10        int: 自由度
11    """
12    if components <= 0 or phases <= 0:
13        raise ValueError("组分和相必须是正整数")
14        
15    degrees_of_freedom = components - phases + 2
16    return degrees_of_freedom
17
18# 示例用法
19try:
20    c = 3  # 三组分系统
21    p = 2  # 两个相
22    f = gibbs_phase_rule(c, p)
23    print(f"一个具有{c}个组分和{p}个相的系统具有{f}个自由度。")
24    
25    # 边界情况：负自由度
26    c2 = 1
27    p2 = 4
28    f2 = gibbs_phase_rule(c2, p2)
29    print(f"一个具有{c2}个组分和{p2}个相的系统具有{f2}个自由度（在物理上不可能）。")
30except ValueError as e:
31    print(f"错误: {e}")
32

1/**
2 * 使用吉布斯相规则计算自由度
3 * @param {number} components - 系统中的组分数量
4 * @param {number} phases - 系统中的相数量
5 * @returns {number} 自由度
6 */
7function calculateDegreesOfFreedom(components, phases) {
8    if (!Number.isInteger(components) || components <= 0) {
9        throw new Error("组分必须是正整数");
10    }
11    
12    if (!Number.isInteger(phases) || phases <= 0) {
13        throw new Error("相必须是正整数");
14    }
15    
16    return components - phases + 2;
17}
18
19// 示例用法
20try {
21    const components = 2;
22    const phases = 1;
23    const degreesOfFreedom = calculateDegreesOfFreedom(components, phases);
24    console.log(`一个具有${components}个组分和${phases}个相的系统具有${degreesOfFreedom}个自由度。`);
25    
26    // 水的三相点示例
27    const waterComponents = 1;
28    const triplePointPhases = 3;
29    const triplePointDoF = calculateDegreesOfFreedom(waterComponents, triplePointPhases);
30    console.log(`水在三相点（${waterComponents}个组分，${triplePointPhases}个相）具有${triplePointDoF}个自由度。`);
31} catch (error) {
32    console.error(`错误: ${error.message}`);
33}
34

1public class GibbsPhaseRuleCalculator {
2    /**
3     * 使用吉布斯相规则计算自由度
4     * 
5     * @param components 系统中的组分数量
6     * @param phases 系统中的相数量
7     * @return 自由度
8     * @throws IllegalArgumentException 如果输入无效
9     */
10    public static int calculateDegreesOfFreedom(int components, int phases) {
11        if (components <= 0) {
12            throw new IllegalArgumentException("组分必须是正整数");
13        }
14        
15        if (phases <= 0) {
16            throw new IllegalArgumentException("相必须是正整数");
17        }
18        
19        return components - phases + 2;
20    }
21    
22    public static void main(String[] args) {
23        try {
24            // 二元共晶系统示例
25            int components = 2;
26            int phases = 3;
27            int degreesOfFreedom = calculateDegreesOfFreedom(components, phases);
28            System.out.printf("一个具有%d个组分和%d个相的系统具有%d个自由度。%n", 
29                             components, phases, degreesOfFreedom);
30            
31            // 三元系统示例
32            components = 3;
33            phases = 2;
34            degreesOfFreedom = calculateDegreesOfFreedom(components, phases);
35            System.out.printf("一个具有%d个组分和%d个相的系统具有%d个自由度。%n", 
36                             components, phases, degreesOfFreedom);
37        } catch (IllegalArgumentException e) {
38            System.err.println("错误: " + e.getMessage());
39        }
40    }
41}
42

1#include <iostream>
2#include <stdexcept>
3
4/**
5 * 使用吉布斯相规则计算自由度
6 * 
7 * @param components 系统中的组分数量
8 * @param phases 系统中的相数量
9 * @return 自由度
10 * @throws std::invalid_argument 如果输入无效
11 */
12int calculateDegreesOfFreedom(int components, int phases) {
13    if (components <= 0) {
14        throw std::invalid_argument("组分必须是正整数");
15    }
16    
17    if (phases <= 0) {
18        throw std::invalid_argument("相必须是正整数");
19    }
20    
21    return components - phases + 2;
22}
23
24int main() {
25    try {
26        // 示例1：水-盐系统
27        int components = 2;
28        int phases = 2;
29        int degreesOfFreedom = calculateDegreesOfFreedom(components, phases);
30        std::cout << "一个具有" << components << "个组分和" 
31                  << phases << "个相的系统具有" << degreesOfFreedom 
32                  << "个自由度。" << std::endl;
33        
34        // 示例2：复杂系统
35        components = 4;
36        phases = 3;
37        degreesOfFreedom = calculateDegreesOfFreedom(components, phases);
38        std::cout << "一个具有" << components << "个组分和" 
39                  << phases << "个相的系统具有" << degreesOfFreedom 
40                  << "个自由度。" << std::endl;
41    } catch (const std::exception& e) {
42        std::cerr << "错误: " << e.what() << std::endl;
43        return 1;
44    }
45    
46    return 0;
47}
48