麦克风输入电平的对数函数的倒数

Question

我正在尝试编写一个具有对数比例的滑块来控制麦克风RMS阈值。

我已经在下面编写了可能很可怕的函数（数学不是我的强项），但确实可以实现我想要的对数缩放。但是，我现在需要在使用比例尺的条形图中显示RMS电平，因此我需要反转此功能。

const rmsLogarithmicScale = (value, max) => {
    const log = ((100 - (Math.log((1 - value) * 100) / 4.605170185988092) * 100) / 100) * max;
    return log === Infinity ? max : log;
};

console.log(rmsLogarithmicScale(0.5, 0.05)); // Result: 0.007525749891599539
console.log(rmsLogarithmicScale(0.5, 300)); // Result: 45.15449934959723

const rmsLogarithmicScaleInverse = (rms, max) => {
    // I have literally no idea where to start...
}

rmsLogarithmicScaleInverse(0.007525749891599539, 0.05); // Result: 0.5

那里有一位好心的数学家可以帮助我解决这个问题吗？

Answer 1

答案是Java提供的，JavaScript示例在原文下方

这是以中间形式表示的计算的倒数。

（但我希望您在评论中进行讨论-只是添加一下，因为它很有趣。）

public static void main(String[] args) {
    double v = rmsLogScale(0.5,0.05);
    System.out.println("v = " + v);                // prints 0.007525749891599539
    double iv = invRmsLogScale(v, 0.05);
    System.out.println("iv = "+iv);                // 0.499999999999999994

}

static double rmsLogScale(double v, double m) {
    double x1 = (1 - v) * 100.;
    double x2 = Math.log(x1);
    double x3 = x2 / 4.605170185988092;
    double x4 = x3 * 100.;
    double x5 = 100. - x4;
    double x6 = x5 / 100. * m;

    return x6;
}

static double invRmsLogScale(double lg, double m) {
    double x5 = (lg * 100) / m;
    double x4 = (100. - x5);
    double x3 = x4 / 100.;
    double x2 = x3 * 4.605170185988092;
    double x1 = Math.exp(x2);
    double x0 = 1 - ((x1) / 100.);
    return x0;
}

---

JavaScript

const rmsLogScale = (v, m) => {
    const x1 = (1 - v) * 100.0;
    const x2 = Math.log(x1);
    const x3 = x2 / 4.605170185988092;
    const x4 = x3 * 100.0;
    const x5 = 100.0 - x4;
    return x5 / 100.0 * m;
};

const inverseRmsLogScale = (lg, m) => {
    const x5 = (lg * 100) / m;
    const x4 = (100.0 - x5);
    const x3 = x4 / 100.0;
    const x2 = x3 * 4.605170185988092;
    const x1 = Math.exp(x2);
    return 1 - ((x1) / 100.0);
};

console.log(rmsLogScale(0.5, 0.5));
console.log(rmsLogScale(0.5, 300));

console.log(inverseRmsLogScale(rmsLogScale(0.5, 0.5), 0.5));
console.log(inverseRmsLogScale(rmsLogScale(0.3, 300), 300));

Answer 2

@ Bergi建议我尝试简化原始函数后，我以@Andy的样式重写了该函数，并且也设法将其反转。

您应该先简化为const log = -Math.log（1-value）/ Math.log（100）* max; — Bergi

const logScale = (value, max) => {
    const x1 = 1 - value;
    const x2 = -Math.log(x1);
    const x3 = x2 / Math.log(100);
    const x4 = x3 * max;
    return x4;
};

const altInverseRmsLogScale = (lg, max) => {
    const x4 = lg / max;
    const x3 = x4 * Math.log(100);
    const x2 = Math.exp(-x3);
    const x1 = 1 - x2;
    return x1;
};

console.log(logScale(0.7, 300)); // 4.727557716909737
console.log(inverseLogScale(logScale(0.7, 300), 300)); // 0.07000000000000006

Terse版本

const logScale = (value, max) => (-Math.log(1 - value) / Math.log(100)) * max;

const inverseLogScale = (lg, max) => 1 - Math.exp(-(lg / max * Math.log(100)));

Terser版本

const logScale = (value, max) => (-Math.log(1 - value) / Math.log(100)) * max;
const inverseLogScale = (lg, max) => 1 - Math.pow(100, -lg / max);

console.log(logScale(0.6, 300));
console.log(inverseLogScale(logScaleTwo(0.6, 300), 300));