Change range() to xrange() everywhere.

BBChop/source/BBChop.py

@@ -55,7 +55,7 @@ def greedyStrat(counts,locPrior,likelihoodsObj,dag):
 # would be expected to improve next gain in entropy.
 
 def nearlyGreedyStrat(counts,locPrior,likelihoodsObj,dag):
-    dlocs=[i for i in range(len(counts)) if counts[i][1]]
+    dlocs=[i for i in xrange(len(counts)) if counts[i][1]]
     (currEntropy,entropyResults,findProbs)=entropiesFast(counts,locPrior,likelihoodsObj,dag)
     (next,nextE)=findMin(entropyResults)
     if len(dlocs):

BBChop/source/cse.py

@@ -42,7 +42,7 @@ def doCalc(self,values,comb,nil):
 
         temp=copy.copy(values)
 
-        for i in range(self.numVals,len(self.subExps)):
+        for i in xrange(self.numVals,len(self.subExps)):
             if self.subExps[i] is None:
                 temp.append(values[i])
             elif self.subExps[i] is -1:
@@ -130,7 +130,7 @@ def getExp(self,l):
     # given a list of expressions, return an object which can calculate them
 
     def getExpList(self,expList):
-        return expListCalc([ self.getExp(toSortedList(expList[i])) for i in range(len(expList))],self)
+        return expListCalc([ self.getExp(toSortedList(expList[i])) for i in xrange(len(expList))],self)
 
 
 # This object holds the locations of the wanted expressions in the temporary
@@ -149,7 +149,7 @@ def __init__(self,expList,cse):
 
     def doCalc(self,values,comb,nil):
         temp=self.cse.doCalc(values,comb,nil)
-        res = [temp[self.expList[i]] for i in range(len(self.expList))]
+        res = [temp[self.expList[i]] for i in xrange(len(self.expList))]
         return res
 
 

BBChop/source/dag.py

@@ -100,22 +100,22 @@ def __init__(self,parents,N):
         sys.stdout.flush()
         self.parents=parents
 
-        children=[[] for i in range(N)]
+        children=[[] for i in xrange(N)]
 
 
-        for i in range(N):
+        for i in xrange(N):
             for p in parents[i]:
                 children[p].append(i)
 
         self.children=children
 
         # a linear stretch ends if a node has multiple children or its child has multiple parents
-        self.linearEnd=  [len(children[i])!=1 or len(parents[children[i][0]])!=1 for i in range(N)] 
+        self.linearEnd=  [len(children[i])!=1 or len(parents[children[i][0]])!=1 for i in xrange(N)] 
         # a linear stretch starts if a node has multiple parents or its parent has multiple children
-        self.linearStart=[len(parents[i])!=1 or len(children[parents[i][0]])!=1 for i in range(N)]
+        self.linearStart=[len(parents[i])!=1 or len(children[parents[i][0]])!=1 for i in xrange(N)]
 
-        loc=[set([i]) for i in range(N)]
-        empty=[set() for i in range(N)]
+        loc=[set([i]) for i in xrange(N)]
+        empty=[set() for i in xrange(N)]
         locE=listCond(self.linearEnd,loc,empty)
         locS=listCond(self.linearStart,loc,empty)
 
@@ -130,11 +130,6 @@ def __init__(self,parents,N):
         self.cseUpto = cse.CommonSubExpressions(N)
         self.cseAfter = cse.CommonSubExpressions(N)
 
-        def toSortedList(x):
-            x=list(x)
-            x.sort()
-            return x
-
         self.uptoExpr =  self.cseUpto.getExpList(self.multiUpto) 
         self.AfterExpr = self.cseAfter.getExpList(self.multiAfter)
 
@@ -163,7 +158,7 @@ def combAfterUnique(self,values,comb):
     def combUptoLinear(self,values,comb):
         res=[comb([])]*len(values)
 
-        for i in range(len(values)):
+        for i in xrange(len(values)):
             if not self.linearStart[i]:
                 res[i]=comb([comb([values[j],res[j]]) for j in self.parents[i]])
         return res
@@ -172,7 +167,7 @@ def combUptoLinear(self,values,comb):
     def combAfterLinear(self,values,comb):
         res=[comb([])]*len(values)
 
-        for i in reversed(range(len(values))):
+        for i in reversed(xrange(len(values))):
             if not self.linearEnd[i]:
                 res[i]=comb([comb([values[j],res[j]]) for j in self.children[i]])
         return res
@@ -203,7 +198,7 @@ def getParents(self,loc):
     def combUpto(self,values,comb):
         res=[comb([])]*len(values)
 
-        for i in range(len(values)):
+        for i in xrange(len(values)):
             res[i]=comb([comb([values[j],res[j]]) for j in self.parents[i]])
         return res
 
@@ -212,7 +207,7 @@ def combUpto(self,values,comb):
     def combAfter(self,values,comb):
         res=[comb([])]*len(values)
 
-        for i in reversed(range(len(values))):
+        for i in reversed(xrange(len(values))):
             res[i]=comb([comb([values[j],res[j]]) for j in self.children[i]])
         return res
 
@@ -235,7 +230,7 @@ def sumOther(self,values,sumUpto=None,sumAfter=None):
 
 dag=persistentMemo.memo(dagX)
 
-# like dag, but assumes linear order
+# like dagX, but assumes linear order
 class listDag(absDag):
 
     def getParents(self,loc):
@@ -283,7 +278,7 @@ def sumOther(self,values):
 
 
 def linearTestDag(N):
-    parents=['%d %d' %(a+1,a) for a in range(N-1)]
+    parents=['%d %d' %(a+1,a) for a in xrange(N-1)]
     parents[:0]='0'
     return dag(parents,N)
 

BBChop/source/dagRead.py

@@ -102,7 +102,7 @@ def read(inputFile):
 
     # which node id is where
     dagLocs={}
-    for i in range(len(identifiers)):
+    for i in xrange(len(identifiers)):
         dagLocs[identifiers[i]]=i
 
 

BBChop/source/evidence.py

@@ -43,7 +43,7 @@ def entropies(counts,locPrior,likelihoodsObj,dag):
 
     if debug: print "ac",counts
 
-    for i in range(len(locProbs)):
+    for i in xrange(len(locProbs)):
         testFound=copy.copy(counts)
         testNotFound=copy.copy(counts)
 
@@ -97,7 +97,7 @@ def entropiesFast(counts,locPrior,likelihoodsObj,d):
     findProbs=[]
 
 
-    for i in range(len(locPrior)): 
+    for i in xrange(len(locPrior)): 
 
         (findProb,renyLksFoundTot,renyLksNFoundTot,evDProb,NfoundNorm)=lk[i]
         findProbs.append(findProb)

BBChop/source/likelihoods.py

@@ -97,7 +97,7 @@ def singleRate(counts,locPrior,dag):
     gsFound=[]
     gsNFound=[]
     gtot=0
-    for i in range(len(counts)):
+    for i in xrange(len(counts)):
         gi=g(preds[i],Ts[i]  ,Ds[i]  ,locPrior[i])
         gf=g(preds[i],Ts[i]  ,Ds[i]+1,locPrior[i])
         gn=g(preds[i],Ts[i]+1,Ds[i],  locPrior[i])
@@ -131,9 +131,9 @@ def multiRate(counts,locPrior,dag):
     ts=[ti for (ti,di) in counts]
     ds=[di for (ti,di) in counts]
 
-    betas1=[Beta(ds[i]+1,  ts[i]+1  ) for i in range(len(locPrior))]
-    betasF=[Beta(ds[i]+1+1,ts[i]+1  ) for i in range(len(locPrior))]
-    betasN=[Beta(ds[i]+1,  ts[i]+1+1) for i in range(len(locPrior))]
+    betas1=[Beta(ds[i]+1,  ts[i]+1  ) for i in xrange(len(locPrior))]
+    betasF=[Beta(ds[i]+1+1,ts[i]+1  ) for i in xrange(len(locPrior))]
+    betasN=[Beta(ds[i]+1,  ts[i]+1+1) for i in xrange(len(locPrior))]
 
     betas=dag.prodAfter(betas1)
     betas=listMul(betas,betas1)
@@ -154,7 +154,7 @@ def multiRate(counts,locPrior,dag):
     gsFound=[]
     gsNFound=[]
     gtot=0
-    for i in range(len(counts)):
+    for i in xrange(len(counts)):
         gi=gMulti(preds[i],betas[i],      locPrior[i])
         gtot+=gi
         gs.append(gi)

BBChop/source/listUtils.py

@@ -37,12 +37,12 @@ def findMax(alist):
     return (w,p)
 
 def listComb(comb,*args):
-    r=range(len(args[0]))
+    r=xrange(len(args[0]))
 
     return [comb([arg[i] for arg in args]) for i in r]
 
 def listComb1(op,comb,first,*args):
-    r=range(len(args[0]))
+    r=xrange(len(args[0]))
 
     return [op(first[i],comb([arg[i] for arg in args])) for i in r]
 
@@ -67,4 +67,4 @@ def cond(c,a,b):
         return b
 
 def listCond(c,a,b):
-    return [cond(c[i],a[i],b[i]) for i in range(len(c))]
+    return [cond(c[i],a[i],b[i]) for i in xrange(len(c))]

BBChop/source/miscMath.py

@@ -93,16 +93,16 @@ def pe(f,ds,ts,r,i):
     if dx>0:
         return 0
     p=1.0
-    for x in range(i,len(ds)):
+    for x in xrange(i,len(ds)):
         p=p*f(ds[x],ds[x]+ts[x],r) 
     return p
 
 
 #FIXME why is t1(nD)==t1(binD)?
 def t1(f,ds,ts,r):
-    pl=[pe(f,ds,ts,r,x) for x in range(len(ds))]
+    pl=[pe(f,ds,ts,r,x) for x in xrange(len(ds))]
     pt=sum(pl)
-    return [pl[x]/pt for x in range(len(ds))]
+    return [pl[x]/pt for x in xrange(len(ds))]
 
 
 def powList(l,p):