C++ 双变量as循环计数器

我经常需要编码，这意味着我必须首先通过增加时间变量

t来观察函数的演化，如果不需要（t-t

，则补偿

，因为它的唯一目的似乎是将最后一个值设置为
t==t
，由于不平等性
，它不会被处理。。。；t在for循环条件中

这就是说，除非
N
是二的幂，否则有限差分法对浮点运算不太有效。例如，如果希望以0.1f的步长计算函数，则很可能会错过几个积分点

分支预测可能会跳过条件评估，但在混合浮点操作和流控制操作时也可能会受到惩罚/延迟

由于舍入误差的累积，优化器可能无法轻松确定迭代计数，因此不允许进行某些优化（循环展开，甚至向量化）

可以简单地通过线性插值来减小误差：
t=c*dt
，但不是完美的，因为并非所有情况下都是
（dbl/N）*N==dbl
。实际上，误差应为ε量级。要得到精确的结束值，必须计算
t=（range*N）/N
这一次确保
range*N
不会降低最低有效位。
首先，如果不需要（t-t
补偿
，因为它的唯一目的似乎是将最后一个值设置为
t==t
，由于不平等性
，这将不会被处理。。。；t在for循环条件中

这就是说，除非
N
是二的幂，否则有限差分法对浮点运算不太有效。例如，如果希望以0.1f的步长计算函数，则很可能会错过几个积分点

分支预测可能会跳过条件评估，但在混合浮点操作和流控制操作时也可能会受到惩罚/延迟

由于舍入误差的累积，优化器可能无法轻松确定迭代计数，因此不允许进行某些优化（循环展开，甚至向量化）

可以简单地通过线性插值来减小误差：
t=c*dt
，但不是完美的，因为并非所有情况下都是
（dbl/N）*N==dbl
。实际上，误差应为ε量级。要得到精确的结束值，必须计算
t=（range*N）/N
这一次确保
范围*N
不会丢失最低有效位。
使用新信息，必须将
dt
设置为固定的预定值
（至少对于除最后一步以外的所有步骤），我的建议如下：

double T0 = 0.0;
double T  = 1.0;
int    N  = floor((T - T0)/dt);
double t  = T0;
for (int step_number = 0; step_number < N; ++step_number, t += dt)
{
  t = T0 + step_number * dt;
  do_one_step(t, T, dt);
}
if (t < T)
{
  do_one_step(t, T, T - t);
}

（请注意，这表示
dt=（T-T）/N
，以防您决定以
T
的非零值开始迭代）

或者，如果
N
非常大，则可能会稍微更精确
（因为
t+=dt
一旦
t
变大，就必须有效地对
dt
进行四舍五入）：

int N=7；
双T=1.0；
双dt=T/N；
对于（整数步数=0；步数
带有新信息，即必须将
dt
设置为固定的预定值
（至少对于除最后一步以外的所有步骤），我的建议如下：

double T0 = 0.0;
double T  = 1.0;
int    N  = floor((T - T0)/dt);
double t  = T0;
for (int step_number = 0; step_number < N; ++step_number, t += dt)
{
  t = T0 + step_number * dt;
  do_one_step(t, T, dt);
}
if (t < T)
{
  do_one_step(t, T, T - t);
}

（请注意，这表示
dt=（T-T）/N
，以防您决定以
T
的非零值开始迭代）

或者，如果
N
非常大，则可能会稍微更精确
（因为
t+=dt
一旦
t
变大，就必须有效地对
dt
进行四舍五入）：

int N=7；
双T=1.0；
双dt=T/N；
对于（整数步数=0；步数
Double和floating比较并不容易。看看@LeFlou，我认为这个问题试图确定两个双打是相等还是有点相等。在我的例子中，我只是决定哪一个更大。确实，我认为在操作之后，
dt=T-T
和
t+=dt
则
t
为假。如果
t-t
在舍入误差范围内非常小，则可能需要跳过上一次迭代。这可能不是很有意义。双重比较和浮动比较并不那么容易。看看@LeFlou，我认为这个问题试图确定两个双打是相等还是有点相等。在我的例子中，我只是决定哪一个更大。确实，我认为在操作之后，
dt=T-T
和
t+=dt
则
t
为假。如果
t-t
在舍入误差范围内非常小，则可能需要跳过上一次迭代。这可能没有什么意义。我道歉。我不知道我在想什么，但首先定义
dt
，然后我们可以得出
N
，这一事实在这种情况下很重要。首先我们想到一个
dt
，然后我们得到足够的迭代次数。我一开始就让我们看起来像是被赋予了
N
，但事实并非如此。再次抱歉。循环中的
t+=dt
看起来像一个工件：P。您还提到它必须四舍五入。你能解释一下那句话吗？在什么情况下会发生这种情况？我的推理是：如果说
t
的顺序是1，而
dt
的顺序是
1e-10
，那么在
dt
中仍然会留下大约5个有效数字。这也意味着我们正在执行大约10^10次迭代，这是一个非常重要的数字，比wh大
double T0 = 0.0;
double T  = 1.0;
int    N  = floor((T - T0)/dt);
double t  = T0;
for (int step_number = 0; step_number < N; ++step_number, t += dt)
{
  t = T0 + step_number * dt;
  do_one_step(t, T, dt);
}
if (t < T)
{
  do_one_step(t, T, T - t);
}

int    N  = 7;
double t  = 0.0;
double T  = 1.0;
double dt = (T - t)/N;
for (int step_number = 0; step_number < N; ++step_number, t += dt)
{
  // ... calculations with t, T, dt, etc.
}

int    N  = 7;
double T  = 1.0;
double dt = T/N;
for (int step_number = 0; step_number < N; ++step_number)
{
  double t = T0 + step_number * dt;
  // ... calculations with t, T, dt, etc.
}