标签: nested-loops

我想知道当验证结束条件(不同于正确的迭代次数)时是否可以在C++中结束for循环.例如:

for (int i = 0; i < maxi; ++i)
    for (int j = 0; j < maxj; ++j)
        // But if i == 4 < maxi AND j == 3 < maxj, 
        // then jump out of the two nested loops.

我知道这可能在Perl中使用下一个LABEL或最后一个LABEL调用和标记的块,是否可以在C++中执行它或者我应该使用while循环？

谢谢.

假设我有这个嵌套循环

for (int a=1; a<MAX_A; ++a)
  for (int b=1; b<MAX_B; ++b)
    for (int c=1; c<MAX_C; ++c)
    {
       do_something(a, b ,c);
    }

我在代码的各个部分重用了这个循环,改变了函数do_something.每次前三行重写都很无聊.例如,在python中我会创建一个生成器来返回迭代器(1, 1, 1), (1, 1, 2), ...或类似的东西itertools.product.

在c ++中,我唯一想到的解决方案就是定义一个宏.还有更好的东西吗？

是否有可能编写一个Common Lisp宏来获取维度和变量列表,一个体(迭代),并创建由列表指定的嵌套循环组成的代码？

就是这样的:

(nested-loops '(2 5 3) '(i j k) whatever_loop_body)

应扩大到

(loop for i from 0 below 2 do
  (loop for j from 0 below 5 do
    (loop for k from 0 below 3 do
      whatever_loop_body)))

跟进

正如怀远正确指出的那样,我必须知道在编译时传递给宏的参数.如果你真的需要我的功能,请看下面.

如果你对宏有好处,那就选择6502的递归解决方案,真是太棒了.

我已经完成了类似的问题搜索,我对我应该做什么有一个模糊的想法:矢量化一切或使用apply()家庭.但我是R编程的初学者,上述两种方法都令人困惑.

这是我的源代码:

x<-rlnorm(100,0,1.6)
j=0
k=0
i=0
h=0
lambda<-rep(0,200)
sum1<-rep(0,200)
constjk=0
wj=0
wk=0
for (h in 1:200)
{
   lambda[h]=2+h/12.5
   N=ceiling(lambda[h]*max(x))
   for (j in 0:N)
   {
      wj=(sum(x<=(j+1)/lambda[h])-sum(x<=j/lambda[h]))/100
      for (k in 0:N)
      {
         constjk=dbinom(k, j + k, 0.5)
         wk=(sum(x<=(k+1)/lambda[h])-sum(x<=k/lambda[h]))/100
         sum1[h]=sum1[h]+(lambda[h]/2)*constjk*wk*wj
      }
   }
}

让我解释一下.我想收集200个sum1值(这是第一个循环),并且对于每个sum1值,它是总和(lambda[h]/2)*constjk*wk*wj,因此是其他两个循环.最乏味的是N随h变化,所以我不知道如何对j循环和k循环进行矢量化.但是当然我可以使用lambda<-seq()和矢量化h循环N<-ceiling(),这是我能做的最好的.有没有办法进一步简化代码？

对于给定的输入N,所包含的语句执行了多少次？

for i in 1 … N loop
  for j in 1 … i loop
    for k in 1 … j loop
      sum = sum + i ;
    end loop;
  end loop;
end loop;

任何人都可以找到一个简单的方法或公式来做到这一般.请解释.

我的代码如下所示(与原始版本相比,它有点简化版本,但它仍然反映了问题).

require(VGAM)

Median.sum  = vector(mode="numeric", length=75) 
AA.sum      = vector(mode="numeric", length=75)                                                    
BB.sum      = vector(mode="numeric", length=75)                   
Median      = array(0, dim=c(75 ,3)) 
AA          = array(0, dim=c(75 ,3))                                                    
BB          = array(0, dim=c(75 ,3))                              

y.sum     = vector(mode="numeric", length=100000)
y         = array(0, dim=c(100000,3))
b.size    = vector(mode="numeric", length=3) 
c.size    = vector(mode="numeric", length=3) 


for (h in 1:40)
{
  for (j in 1:75)
  {  
    for (i in 1:100000)
    {
      y.sum[i] = 0

      for (f in 1:3)
      {
        b.size[f] = rbinom(1, 30, 0.9)
        c.size[f] = 30 - rbinom(1, 30, 0.9) …

parfor是在几个"工人"之间分配密集计算的独立迭代的便捷方式.一个有意义的限制是parfor-loops不能嵌套,并且总是,这就是那里和那里类似问题的答案.

为什么跨越循环边界的并行化是如此理想

考虑以下代码,其中迭代在允许4个工作者的机器上占用大量可变时间.两个循环迭代超过6个值,显然难以在4个中共享.

for row = 1:6
    parfor col = 1:6
        somefun(row, col);
    end
end

选择内部循环似乎是一个好主意,parfor因为单个调用somefun比外部循环的迭代更可变.但是如果每个调用的运行时间somefun非常相似怎么办？如果运行时有趋势并且我们有三个嵌套循环怎么办？这些问题经常出现,人们走向极端.

组合循环所需的模式

理想情况下,somefun运行所有对row和col,并且工人应该忙,不管哪个迭代正在变化.解决方案应该是这样的

parfor p = allpairs(1:6, 1:6)
    somefun(p(1), p(2));
end

不幸的是,即使我知道它的内置函数创建一个矩阵的所有组合row和col,MATLAB将与错误抱怨一个PARFOR语句的范围必须是行向量.然而,for不会抱怨和很好地迭代列.一个简单的解决方法是创建该矩阵,然后使用parfor以下内容对其进行索引:

p = allpairs(1:6, 1:6);
parfor k = 1:size(pairs, 2)
    row = p(k, 1);
    col = p(k, 2);
    somefun(row, col);
end

什么是内置函数代替allpairs …

我有一个对象的对象,我用vue传递,我这样做是为了运行:

 <ul>
    <li v-for="subjects in questions">
        <li v-for="question in subjects">
            @{{ question }}
        </li>
    </li>
</ul>

但我收到这个错误:

属性或方法"主题"未在实例上定义,但在呈现期间引用.确保在数据选项中声明反应数据属性.(在根实例中找到)

如何在vue中运行嵌套循环？

我有一个多维数组（result），应该由一些嵌套循环填充。函数fun()是一个复杂且耗时的函数。我想以并行方式填充数组元素，因此我可以使用系统的所有处理能力。这是代码：

import numpy as np


def fun(x, y, z):
    # time-consuming computation...
    # ...

    return output


dim1 = 10
dim2 = 20
dim3 = 30

result = np.zeros([dim1, dim2, dim3])

for i in xrange(dim1):
    for j in xrange(dim2):
        for k in xrange(dim3):
            result[i, j, k] = fun(i, j, k)

我的问题是“我是否可以并行化此代码？如果可以，如何？”

我正在使用Windows 10 64位和python 2.7。

如果可以的话，请通过更改我的代码来提供您的解决方案。谢谢！

我有一个类似的清单：

[[16777230, 0], [16777226, 1], [16777252, 2], [16777246, 0]]

我想在 python 中为我的操作在循环（嵌套循环）中创建一个循环，这样内循环将始终从外循环的下一个元素开始。

例如，外循环将在每次迭代中遍历列表中从索引 0 到 3 的所有元素。但在外循环的第一次迭代中，内循环将从索引 1 开始并在索引 3 处结束。那么，在外循环的第二次迭代中，内循环应该遍历索引2到索引3。 依此类推... 外循环的最后一次迭代应该使内循环从索引n遍历到索引n，基本上只有最后一个元素，在本例中为索引 3 到索引 3。

问题是我在遍历时删除了列表的元素。因此，它在使用范围函数进行遍历时会产生列表索引超出范围等问题。

如何构建这些内循环和外循环？

我试过这个，但似乎不起作用：

for sub_list1 in yx:
    index_sl1 = yx.index(sub_list1)
    for sub_list2 in yx[index_sl1+1:]:
        Operations...

帮助将不胜感激。谢谢！！