对于1< = N< = 1000000000,我需要计算2N mod 1000000007,它必须非常快！
我目前的做法是：

ull power_of_2_mod(ull n) {
    ull result = 1;
    if (n <= 63) {
        result <<= n;
        result = result % 1000000007;
    }
    else {
        ull one = 1;
        one <<= 63;
        while (n > 63) {
            result = ((result % 1000000007) * (one % 1000000007)) % 1000000007;
            n -= 63;
        }

        for (int i = 1; i <= n; ++i) {
            result = (result * 2) % 1000000007;
        }

    }

    return result;
}

但它似乎不够快.任何的想法？

检查 exponentiation by squaring和 modular exponentiation的二进制方法

我正在制作一些与渐变相关的类型/功能的小集合以供将来使用.我想确保至少有两个过程：ColorBetween和ColorsBetween.我可能只想获得任意两种颜色(ColorsBetween)之间的TColor数组,我可能只需要知道两种颜色之间的百分比(ColorBetween)的一个颜色值.

我已经在下面完成了它.除此之外,我有两个核心问题：

>如何按给定百分比计算每个RGB通道的中间颜色？ (见下文我有[???])
>完成我正在做的事情的最快方法是什么(保持两个不同的功能)？

这是代码：

uses
  Windows,Messages,SysUtils,Classes,Graphics,Controls,Forms,StrUtils,StdCtrls,Math;

type
  TColorArray = array of TColor;

implementation

function ColorsBetween(const ColorA,ColorB: TColor; const Count: Integer): TColorArray;
var
  X: Integer; //Loop counter
begin
  SetLength(Result,Count);
  for X:= 0 to Count - 1 do 
    Result[X]:= ColorBetween(ColorA,ColorB,Round((X / Count) * 100)); //Correct?
end;

function ColorBetween(const ColorA,ColorB: TColor; const Percent: Single): TColor;
var
  R1,G1,B1: Byte;
  R2,G2,B2: Byte;
begin
  R1:= GetRValue(ColorA);
  G1:= GetGValue(ColorA);
  B1:= GetBValue(ColorA);
  R2:= GetRValue(ColorB);
  G2:= GetGValue(ColorB);
  B2:= GetBValue(ColorB);
  Result:= RGB(
    EnsureRange(([???]),255),EnsureRange(([???]),255)
  );
end;

编辑：更改百分比：整数百分比：单一以获得更平滑的效果 – 不限于100个可能的值.

听起来你想要更换你的???同

Round((R1*Percent + R2*(100-Percent))/100.0)

代码中的EnsureRange不是必需的,因为此函数必须返回0到255范围内的值,前提是Percent在0到100的范围内.我想我会将EnsureRange应用于百分比(强制它进入范围0.0到100.0)和然后使用以下代码：

Result := RGB(
  Round((R1*Percent + R2*(100-Percent))/100.0),Round((G1*Percent + G2*(100-Percent))/100.0),Round((B1*Percent + B2*(100-Percent))/100.0),);

第一个函数返回第一个颜色为ColorA的数组.也许你会更好用这个：

for X:= 0 to Count - 1 do
  Result[X]:= ColorBetween(ColorA,(X+1) / (Count+1) * 100.0);

这在数组的两端提供相同的行为.或许你想要包括ColorA和ColorB.然后你会用：

X / (Count-1) * 100.0

但是如果你这样做,请记住Count必须大于1,否则你将除以零.那个nevers工作了!!

不要担心性能.毫无疑问,代码可以稍快一点,但它肯定不会成为瓶颈.您将采用这些颜色并与它们一起绘制.与这些简单的例程相比,这将消耗更多的资源.

最后一点. RGB空间中的插值对于人眼来说看起来不是特别平滑或线性的.使用浮点百分比无法回避这一事实.为了在查看时获得最佳效果,您需要在不同的颜色空间中进行插值.

计算数字有效位数的最快方法是什么？

我有以下功能,它可以工作,但由于字符串操作很慢.

/**
 * Count the number of significant digits of a number.
 *
 * For example:
 *   2.34 returns 3
 *   0.0034 returns 2
 *   120.5e+3 returns 4
 *
 * @param {Number} value
 * @return {Number} The number of significant digits
 */
function digits (value) {
  return value
      .toExponential()
      .replace(/e[\+\-0-9]*$/,'')  // remove exponential notation
      .replace( /^0\.?0*|\./,'')    // remove decimal point and leading zeros
      .length
};

有更快的方法吗？

更新：此处列出了测试正确运行的断言：

assert.equal(digits(0),0);
assert.equal(digits(2),1);
assert.equal(digits(1234),4);
assert.equal(digits(2.34),3);
assert.equal(digits(3000),1);
assert.equal(digits(0.0034),2);
assert.equal(digits(120.5e50),4);
assert.equal(digits(1120.5e+50),5);
assert.equal(digits(120.52e-50),5);
assert.equal(digits(Math.PI),16);

我自己的方法对于数字(0)失败,我通过添加一个？到第二个正则表达式.

这是一种更加数学化的方式来做同样的操作(看起来明显更快)

JSPerf比较了三种实现方式

准确的整数n< - 每个http://ecma262-5.com/ELS5_HTML.htm#Section_8.5(2 ^ 53)
将浮点数转换为字符串,然后强制转换为int(通过删除小数,因此应用类似的规则)

var log10 = Math.log(10);
function getSignificantDigitCount(n) {
    n = Math.abs(String(n).replace(".","")); //remove decimal and make positive
    if (n == 0) return 0;
    while (n != 0 && n % 10 == 0) n /= 10; //kill the 0s at the end of n

    return Math.floor(Math.log(n) / log10) + 1; //get number of digits
}