夹紧到"easy"数字

Clamping to "easy" numbers

本文关键字：easy 数字      更新时间：2023-10-16

我正在尝试制作一个绘图应用程序，我使用Desmos作为基础。

我正在努力的是Desmos处理坐标轴细分的方式。当你放大或缩小时，刻度总是在"简单"的数字上，比如5、100、1000等。所以我的问题是:一个人如何用任何程度的缩放来简化他们的比例?

BTW:使用c++

我本来打算写一篇关于如何实现这一点的描述，但后来我意识到代码可能比解释更容易。

最重要的一步:精确定义"简单"数字的含义

示例#1:1,2,4,8,16,32,64,128，…， 1073741824，…

这些是2的幂。因此，一个简单的ceil(log(x)/log(2.0))将解决它。

示例#2:1,2,5,10,20,50,100,200,500,1000,2000,5000,10000，…

有一个2的幂的混合，以及它的一些倍数。让我们仔细看看。

  • 其中的一个子集可以被描述为10的幂。
    • 将配方改为ceil(log(x)/log(10.0))即可解决。
  • 对于每一个十次幂，其与2.0和5.0的倍数也是"易简单数"。
    • 在每次迭代中，在检查十次幂值之后，还要检查两个倍数。
<标题> 代码

下面的代码只是用来解释这个概念。这是不高效的——一个高效的版本应该使用对数在O(1)时间内得到结果。

#include <iostream>
#include <vector>
#include <limits>
#include <stdexcept>
#include <algorithm>
using namespace std;
double getNiceAxisLength(double value, double baseLength, double step, const std::vector<double>& subSteps)
{
    typedef std::vector<double>::const_iterator VecDoubleIter;
    if (value < 0.0)
    {
        throw std::invalid_argument("Error: value must be non-negative. Take absolute value if necessary.");
    }
    if (baseLength <= 0.0)
    {
        throw std::invalid_argument("Error: baseLength must be positive.");
    }
    if (step <= 1.0)
    {
        throw std::invalid_argument("Error: step must be strictly greater than 1.");
    }
    for (VecDoubleIter iter = subSteps.begin(); iter != subSteps.end(); ++iter)
    {
        double subStep = *iter;
        if (subStep <= 1.0 || subStep >= step)
        {
            throw std::invalid_argument("Error: each subStep must be strictly greater than 1, and strictly smaller than step.");
        }
    }
    // make ascending.
    std::vector<double> sortedSubSteps(subSteps.begin(), subSteps.end());
    std::sort(sortedSubSteps.begin(), sortedSubSteps.end());
    if (value <= baseLength)
    {
        return baseLength;
    }
    double length = baseLength;
    double terminateLength = numeric_limits<double>::max() / step;
    while (length < terminateLength)
    {
        for (VecDoubleIter iter = sortedSubSteps.begin(); iter != sortedSubSteps.end(); ++iter)
        {
            double subStep = *iter;
            if (value <= length * subStep)
            {
                return (length * subStep);
            }
        }
        double nextLength = length * step;
        if (value <= nextLength)
        {
            return nextLength;
        }
        length = nextLength;
    }
    return baseLength;
}
int main()
{
    double baseLength = 1.0;
    double step = 10.0;
    std::vector<double> subSteps;
    subSteps.push_back(2.5);
    subSteps.push_back(5);
    for (int k = 0; k < 1000; k += ((k >> 2) + 1))
    {
        double value = k;
        double result = getNiceAxisLength(value, baseLength, step, subSteps);
        cout << "k: " << value << " result: " << result << endl;
    }
    cout << "Hello world!" << endl;
    return 0;
}
<标题> 输出
k: 0 result: 1
k: 1 result: 1
k: 2 result: 2.5
k: 3 result: 5
k: 4 result: 5
k: 6 result: 10
k: 8 result: 10
k: 11 result: 25
k: 14 result: 25
k: 18 result: 25
k: 23 result: 25
k: 29 result: 50
k: 37 result: 50
k: 47 result: 50
k: 59 result: 100
k: 74 result: 100
k: 93 result: 100
k: 117 result: 250
k: 147 result: 250
k: 184 result: 250
k: 231 result: 250
k: 289 result: 500
k: 362 result: 500
k: 453 result: 500
k: 567 result: 1000
k: 709 result: 1000
k: 887 result: 1000
Hello world!

<子> Hello world !

相关文章：