class LevelMapper:
    """等级映射器：将1-99映射到1-100，前缓后陡"""
    
    def __init__(self, method="power", **params):
        """
        初始化映射器
        
        Args:
            method: 映射方法
                - "power": 幂函数
                - "piecewise": 分段函数
                - "log_exp": 对数-指数组合
                - "exponential": 指数函数
            params: 方法参数
        """
        self.method = method
        self.params = params
        
    def map(self, input_value):
        """执行映射"""
        if input_value < 1 or input_value > 99:
            raise ValueError("输入值必须在1-99范围内")
        
        x = (input_value - 1) / 98.0  # 归一化到0-1
        
        if self.method == "power":
            # 幂函数
            power = self.params.get("power", 3.0)
            y = x ** power
        elif self.method == "piecewise":
            # 分段函数
            breakpoint_norm = self.params.get("breakpoint_norm", 0.3)
            if x <= breakpoint_norm:
                # 前期线性
                y = x * 0.3
            else:
                # 后期指数
                fast_x = (x - breakpoint_norm) / (1 - breakpoint_norm)
                y = 0.3 + 0.7 * (math.exp(3 * fast_x) - 1) / (math.exp(3) - 1)
        elif self.method == "log_exp":
            # 对数-指数组合
            steepness = self.params.get("steepness", 0.1)
            t = (x - 0.5) * steepness * 20
            if t < 0:
                y = 0.5 + math.log1p(abs(t)) / 20
            else:
                y = 0.5 + (math.exp(t) - 1) / 20
            y = max(0, min(1, y))
        elif self.method == "exponential":
            # 指数函数
            base = self.params.get("base", 4.0)
            y = (base ** x - 1) / (base - 1)
        else:
            raise ValueError(f"不支持的映射方法: {self.method}")
        
        # 映射到1-100
        return 1 + y * 99


# 使用示例
if __name__ == "__main__":
    print("=== 等级映射器演示 ===\n")
    
    # 创建不同的映射器
    mappers = {
        "幂函数 (power=2.5)": LevelMapper("power", power=2.5),
        "幂函数 (power=3.5)": LevelMapper("power", power=3.5),
        "分段函数 (30%前慢)": LevelMapper("piecewise", breakpoint_norm=0.3),
        "指数函数 (base=5)": LevelMapper("exponential", base=5),
    }
    
    # 测试关键点
    test_points = [1, 10, 20, 30, 40, 50, 60, 70, 80, 90, 99]
    
    for mapper_name, mapper in mappers.items():
        print(f"\n{mapper_name}:")
        for val in test_points:
            result = mapper.map(val)
            print(f"  输入 {val:2d} -> {result:6.2f}")