相关疑难解决方法(0)

我需要创建一个优化函数来计算Math.pow(a,b)%c; 在Javascript中;
计算小数字时没有问题:
Math.pow(2345,123) % 1234567;
但是如果你试图计算:
Math.pow(2345678910, 123456789) % 1234567;
由于Math.pow()函数结果不能计算"大"数字,你会得到不正确的结果;
我的解决方案是:

function powMod(base, pow, mod){
    var i, result = 1;
    for ( i = 0; i < pow; i++){
        result *= base;
        result %= mod;
    }
return result;

虽然需要大量的时间来计算;
有可能以某种方式优化它或找到更合理的方式来计算Math.pow(a,b)%c; 对于"大"数字？(我写的是"大",因为他们不是真正的大事);

我必须编写一段代码，通过米勒-拉宾素性测试确定一个数字是否为素数。

代码在这里：

#include <iostream>\n#include <time.h>\n#include <cmath>\n#include <stdio.h>  \n\nusing namespace std;\n\nint main()\n{\n    srand(time(0));\n    int m, r, st, a, x, t,st2;\n    cout << "\xd0\x92\xd0\xb2\xd0\xb5\xd0\xb4\xd0\xb8\xd1\x82\xd0\xb5 \xd1\x87\xd0\xb8\xd1\x81\xd0\xbb\xd0\xbe m: ";\n    cin >> m;\n    cout << "\xd0\x92\xd0\xb2\xd0\xb5\xd0\xb4\xd0\xb8\xd1\x82\xd0\xb5 \xd1\x87\xd0\xb8\xd1\x81\xd0\xbb\xd0\xbe r: ";\n    cin >> r;\n    t = m - 1;\n    st = 0;\n\n    while (t % 2 == 0)\n    {\n        st = st + 1;\n        t = t / 2;\n    }\n\n    for (int i = 0; i < r; i++)\n    {\n        a = rand() % (m …

我正在研究实现基于整数的幂函数pow(int,int)的最有效方法.

这是他们得到的答案.

我试图让它适用于C#,但我正在将int与bool和所有其他东西进行比较...而且我无法弄清楚他们为什么要比较而且1这不是那个意思和真实吗？有什么意义呢.它看起来效率不高.

 int ipow(int base, int exp) 
 { 
     int result = 1; 
     while (exp) 
     { 
         if (exp & 1) 
             result *= base; 
         exp >>= 1; 
         base *= base; 
     } 

return result; 

}

我在比较中做exp ==但是1仍然在那里,我不知道我是否需要它.

有人知道"if(exp&1)"中的1是什么吗？或者如果我需要它？我看不出用途.

可能重复:
实现基于整数的幂函数pow(int,int)的最有效方法

我知道这个问题很简单,但我的要求是我要计算x来驱动x,其中x是一个非常大的数字,以尽可能最佳的方式.我不是一个数学极客,因此需要一些帮助来找出最好的方法.

在java中,我们可以使用BigInteger但是如何优化代码？任何具体的优化方法？

另外使用递归会得到x的大值,会使代码变慢并且容易出现堆栈溢出错误吗？

例如:457474575加权457474575

任何人都可以帮我找到一个有效的代码来找到10个电源x？

 private int power(int base, int exp)
{
    int result = 1;
    while (exp != 0)
    {
        if ((exp & 1) == 1)
            result *= base;
        exp >>= 1;
        base *= base;
    }

    return result;
}

来自这里的代码来源,但我正在寻找一种输入可能是3.14(双倍)的方法.我也不能使用任何库函数.功率可以是实数.所以它不仅仅是一个简单的整数算法,我们可以通过Squaring的Exponentiation找到它.

function c1()
        x::UInt64 = 0
        while x<= (10^8 * 10)
                x+=1
        end
end

function c2()
        x::UInt64 = 0
        while x<= (10^9)
                x+=1
        end
end

function c3()
        x::UInt64 = 0
        y::UInt64 = 10^8 * 10
        while x<= y
                x+=1
        end
end

function c4()
        x::UInt64 = 0
        y::UInt64 = 10^9
        while x<= y
                x+=1
        end
end

应该是一样的吧？

@time c1()

0.019102 seconds (40.99 k allocations: 2.313 MiB)

@time c1()

0.000003 seconds (4 allocations: 160 bytes)

@time c2()

9.205925 seconds (47.89 k allocations: 2.750 …

我想高效地生成一个随机的，（封闭的）范围内唯一（非重复）整数的样本，[0, rnd_max]该范围内的每个数字都可以选择，并且每个样本均与样本权重相关（权重越大，越可能应该是选择了这个数字，weight[i] / sum(weight[not_taken])如果样本中还没有被选择的话，那么接下来就应该精确选择该数字）。

我看到C ++ std::discrete_distribution可以生成随机加权整数，但是如果我使用C ++ 生成随机加权整数并丢弃重复的整数，则当所取样本相对于可能范围的长度而言较大时，将会有很多失败的样本已经被采用，导致程序效率极低。我不清楚弗洛伊德（Floyd）的算法是否对样本权重的情况进行了扩展（https://math.stackexchange.com/questions/178690/whats-the-proof-of-correctness-for-robert-floyds-algorithm-选择一个罪）-我个人无法想到一个。

例如，也可以使用std::discrete_distribution将权重降低到零，或执行部分加权随机播放，例如此答案：C ++。加权的std :: shuffle-但在该答案中，std::discrete_distribution每次迭代都会重新生成，因此运行时间变为二次方（它需要循环遍历每次传递给它的权重）。

想知道对于C ++中唯一整数而言，什么是有效的加权随机样本，它对于变化的样本大小（例如，在可用范围内从1％到90％的样本数量）会很好地起作用。

#include <vector>
#include <random>
#include <algorithm>

int main()
{
    size_t rnd_max = 1e5;
    size_t ntake = 1e3;

    unsigned int seed = 12345;
    std::mt19937 rng(seed);
    std::gamma_distribution<double> rgamma(1.0, 1.0);
    std::vector<double> weights(rnd_max);
    for (double &w : weights) w = rgamma(rng);

    std::vector<int> chosen_sample(ntake);
    // sampler goes here...

    return 0;
}

我不断收到错误“不能在 math.Pow 的参数中使用 (type int) 作为 float64 类型，不能在 math.Pow 的参数中使用 x (type int) 作为 float64 类型，无效操作：math.Pow(a, x ) % n (float64 和 int 类型不匹配) "

func pPrime(n int) bool {
    var nm1 int = n - 1
    var x int = nm1/2
    a := 1;
    for  a < n {
        if  (math.Pow(a, x)) % n == nm1 {
            return true
        }
    }
    return false
}

#include <stdio.h> 
#include <math.h>

int main()
{
    int loop, place_value=0, c = 5;
    for(loop = 0; loop < c; loop++)
    {
        place_value = 0;
        place_value = pow(10, loop);
        printf("%d \n", place_value);
    }
    return 0;
}

这段代码给出

10 
99 
1000 
9999 

为什么第 3 行和第 5 行分别是 99 和 9999 而不是 100 和 10000？

正常求电时，给出正确答案。

#include <stdio.h>
#include <math.h>

int main()
{
  printf ("%d", (int) pow (10,3 ));
  return 0;
}

1000

在 C 语言中，我想知道是否有一种“最佳”方法来计算半整数幂。简而言之，问题是计算 x^(n/2) （假设n是奇数且相当小，并且x是一个浮点数）。sqrt(pow(x, n))和之间的性能/准确性是否存在重大差异pow(x, 0.5 * n)？或者甚至反过来：pow(sqrt(x), n)。

是否有其他一些实现来处理半整数的这种特定情况？

我的第一个想法是，您只需pow在一次调用中使用和计算整个过程，但我觉得浮点舍入和我失去了问题的一些精度，因为这显然是一半-整数。pow我想如果你使用整数幂并让sqrt处理 (1/2) 部分，也许会有更好的错误性能。

我还注意到 GSL 有计算小整数幂的函数；将这些功能结合起来会sqrt比仅仅使用更好吗pow？

我对 C 科学编程还很陌生，所以我不确定我会去哪里寻找类似的实现，而且 Google 还没有真正发现任何东西。