全部问题

 private int SubStractPage()
 {
    
     Image image = CaptureScreen(976, 766, 0, 0, size2);
   
     image.Save(@"C:\ImageTests\screen.jpg", ImageFormat.Jpeg);


     using (Tesseract tesseract = new Tesseract(@"C:\langs", "eng", OcrEngineMode.TesseractLstmCombined))
     {
         tesseract.SetImage(new Image<Bgr, byte>(@"C:\ImageTests\screen.jpg"));
         tesseract.Recognize();
         
         string pages = tesseract.GetUTF8Text().Replace(" ", "");
        
         if( pages.Length == 1 || pages.Length == 0)
         {
             MessageBox.Show(pages);
             return 0;
         }
         else
         {
             if (pages.Length < 10)
             {
            
                 MessageBox.Show(pages);
                 return Convert.ToInt32(pages[pages.Length - 1].ToString()) - 1;
             }
             else 
             {

                 MessageBox.Show(pages);

                 return Convert.ToInt32((pages[pages.Length - 2].ToString() + pages[pages.Length - 1].ToString())) - 1;
             }
         }
        

     }
 }

该方法获取屏幕截图，然后成功从 tesseract 变量的屏幕截图中检索文本。然后我只是在页面中输入没有空格的数字。然后我返回页码最后一位数字或页码最后两位数字的值。但最终，即使页面在返回之前不为 null，也会变为 Null 并引发错误。这和什么有关系呢？

我正在编写一个小型图像转换器，需要将矢量图像（在本例中为 svg）转换为光栅图像，我开始实现并陷入了贝塞尔曲线。

处理曲线的函数：

void precompute_binomial_coefficients(std::vector<std::vector<double>>& binomial_coefficients, uint32_t n) 
{
    binomial_coefficients.resize(n + 1, std::vector<double>(n + 1, 0.0));
    for (uint32_t i = 0; i <= n; ++i) 
    {
        binomial_coefficients[i][0] = 1.0;
        for (uint32_t j = 1; j <= i; ++j) 
        {
            binomial_coefficients[i][j] = binomial_coefficients[i - 1][j - 1] + binomial_coefficients[i - 1][j];
        }
    }
}

double basis(const std::vector<std::vector<double>>& binomial_coefficients, uint32_t i, uint32_t n, double t) 
{
    if (i > n - 1)
    {
        throw std::out_of_range("Index i is out of range for binomial coefficients");
    }
    return binomial_coefficients[n - 1][i] * std::pow(t, i) * std::pow(1 - t, n - 1 - i);
}

std::pair<int, int> bezier(const std::vector<std::pair<int, int>>& control_points, const std::vector<std::vector<double>>& binomial_coefficients, double t) 
{
    uint32_t n = control_points.size();
    if (n == 0) 
    {
        throw std::invalid_argument("Control points vector is empty");
    }
    double x = 0.0;
    double y = 0.0;
    double temp;

    for (uint32_t i = 0; i < n; ++i) 
    {
        temp = basis(binomial_coefficients, i, n, t);
        x += control_points[i].first * temp;
        y += control_points[i].second * temp;
    }
    return std::make_pair(static_cast<int>(std::ceil(x)), static_cast<int>(std::ceil(y)));
}

void DrawBezierCurve(Image& image_, const std::vector<std::pair<int, int>>& control_points, const Color& color) 
{
    if (control_points.empty())
    {
        return;
    }

    uint32_t n = control_points.size();
    std::vector<std::vector<double>> binomial_coefficients;
    precompute_binomial_coefficients(binomial_coefficients, n - 1);

    double step = 0.01;

    for (double t = 0.0; t <= 1.0; t += step) 
    {
        std::pair<int, int> current_point = bezier(control_points, binomial_coefficients, t);
        if (current_point.first >= 0 && current_point.first < image_.GetWidth() && current_point.second >= 0 && current_point.second < image_.GetHeight()) 
        {
            image_.SetPixel(current_point.first, current_point.second, color);
        }
    }
}

画线功能：

 void DrawLine(Image& image_, int x1_, int y1_, int x2_, int y2_, const Color& color_)
 {
     int dx = abs(x2_ - x1_);
     int dy = abs(y2_ - y1_);
     int sx = (x1_ < x2_) ? 1 : -1;
     int sy = (y1_ < y2_) ? 1 : -1;
     int err = dx - dy;

     while (true)
     {
         if (x1_ >= 0 && x1_ < image_.GetWidth() && y1_ >= 0 && y1_ < image_.GetHeight())
         {
             image_.SetPixel(x1_, y1_, color_);
         }

         if (x1_ == x2_ && y1_ == y2_)
         {
             break;
         }

         int e2 = 2 * err;

         if (e2 > -dy)
         {
             err -= dy;
             x1_ += sx;
         }

         if (e2 < dx)
         {
             err += dx;
             y1_ += sy;
         }
     }
 }

转换后，线条不会被平滑，而是简单地笔直，穿过控制点。做错了什么？

假设有 2 个随机数的乘积，每个随机数的长度为 10 到 16 个字符：

1 - 6545134143
2 - 3272567071

在 PHP 8+ 版本中正常工作时，会产生小数点后 14 位的 Float 类型数字：

6545134143 * 3272567071 = 2.1419390471659606E+19

如果通过 GMP 执行相同的操作，您已经获得了所需的小数点后完整位数的数字：

gmp_strval(gmp_mul(6545134143 , 3272567071)) = 21419390471659605153

请注意，对于 GMP，结尾不会四舍五入（从 5 到 6），而是完整呈现 - 605153。

完成运算后，您需要找出这个长数字除以数字 4294967296 的余数，该数字是通过数字与超出标准 64 位整数和 14 个字符的标准精度相乘得到的。

如果您通过 gmp_mod() 执行此操作，那么您将得到您所需要的 - 816336033。我的猜测是，这是某种将这个巨大数字转换为 32 位格式的尝试，因为它与格式非常相似 (& 0xFFFFFFFF) 。

实际上，问题是这样的 - 考虑到 PHP 可能的数值范围的所有细微差别和限制（我们正在谈论 x64 8.3） - 是否有可能以某种方式避免这种巨大的乘法，从整数除法中获得相同的余数（指的是数字本身，而不是特定操作的结果）？我尝试将每个数字分别除以 4294967296，然后将所得余数相乘，但所有数字都归结为 14 位数字，结果纯粹是无意义的。还有一种假设认为这可以通过操纵数字系统来实现......

我想用纯 PHP 来完成它，因为理论上它比调用 GMP 扩展更快，并且在几百万次操作的距离上它应该节省很多秒......

我尝试通过配置将精度移至 16 和 -1 - 结果完全为零，这个词根本没有任何变化。请帮忙和指教）

有两个exe文件，是否可以创建这样一个您启动的文件，并且它同时启动两个exe？

有必要创建一种算法来查找将自然数分解为自然数之和（至少 2）的方法数。

这个算法应该是一个特定的函数，它将一个自然数（2及以上）作为输入，并输出将该数分解为自然数之和（至少2）的方法数。

例如，对于数字 6，有 4 种方法：

6 = 6 = 2 + 4 = 3 + 3 = 2 + 2 + 2

我不需要束缚于特定的编程语言，重要的只是算法。

求和分解可以用图来表示，例如：

图上有 6 个顶点，每个顶点可以连接另外 2 个顶点（但至少 1 个），但不能关闭链：

因此，该函数将采用以下值：

f(1) = 0,

f(2) = 1,

f(3) = 1,

f(4) = 2,

f(5) = 2,

f(6) = 4,

f(7) = 4,

f(8) = 7,

f(9) = 8,

f(10) = 12,

<...>。

我也有兴趣了解序列的极限或函数相邻值之间关系序列的极限。

目前我知道如何计算连接所有顶点的方法数量，连接顶点以使图分为两部分，以及连接顶点以使图分为3部分。