[LNT] Python 3 support: Replace `raise E, V` with `raise E(V)`

[hubert.reinterpretcast]

Summary

Mechanically changed raise E, V to raise E(V). Split out from D67535.

This patch covers the files found to be affected when running tests (without result submission).

[hubert.reinterpretcast]

• Add spaces around operators on lines touched

[thopre]

LGTM

lnt/trunk/lnt/external/stats/stats.py

 print stats.amean.__doc__ or whatever.
 """
 
     def __init__(self, *tuples):
         self._dispatch = {}
         for func, types in tuples:
             for t in types:
                 if t in self._dispatch:
-                    raise ValueError, "can't have two dispatches on "+str(t)
+                    raise ValueError("can't have two dispatches on " + str(t))
                 self._dispatch[t] = func
 
     def __call__(self, arg1, *args, **kw):
         if type(arg1) not in self._dispatch:
-            raise TypeError, "don't know how to dispatch %s arguments" %  type(arg1)
+            raise TypeError("don't know how to dispatch %s arguments" % type(arg1))
         return apply(self._dispatch[type(arg1)], (arg1,) + args, kw)
 
 
 ##########################################################################
 ########################   LIST-BASED FUNCTIONS   ########################
 ##########################################################################
 
 ### Define these regardless
for j in range(k):
             t2 = 0.5*v[j]*(n[j]-1.0)
             t3 = (n[j]-1.0)*(n[j]-2.0)
             nargs[j][i] = (t1-t2) / float(t3)
     check = 1
     for j in range(k):
         if v[j] - mean(nargs[j]) > TINY:
             check = 0
     if check != 1:
-        raise ValueError, 'Problem in obrientransform.'
+        raise ValueError('Problem in obrientransform.')
     else:
         return nargs
 
 
 def lsamplevar (inlist):
     """
 Returns the variance of the values in the passed list using
 N for the denominator (i.e., DESCRIBES the sample variance only).

 probability value.  Taken from Heiman's Basic Statistics for the Behav.
 Sci (2nd), p.195.
 
 Usage:   lpearsonr(x,y)      where x and y are equal-length lists
 Returns: Pearson's r value, two-tailed p-value
 """
     TINY = 1.0e-30
     if len(x) != len(y):
-        raise ValueError, 'Input values not paired in pearsonr.  Aborting.'
+        raise ValueError('Input values not paired in pearsonr.  Aborting.')
     n = len(x)
     x = map(float,x)
     y = map(float,y)
     xmean = mean(x)
     ymean = mean(y)
     r_num = n*(summult(x,y)) - sum(x)*sum(y)
     r_den = math.sqrt((n*ss(x) - square_of_sums(x))*(n*ss(y)-square_of_sums(y)))
     r = (r_num / r_den)  # denominator already a float

 Calculates a Spearman rank-order correlation coefficient.  Taken
 from Heiman's Basic Statistics for the Behav. Sci (1st), p.192.
 
 Usage:   lspearmanr(x,y)      where x and y are equal-length lists
 Returns: Spearman's r, two-tailed p-value
 """
     TINY = 1e-30
     if len(x) != len(y):
-        raise ValueError, 'Input values not paired in spearmanr.  Aborting.'
+        raise ValueError('Input values not paired in spearmanr.  Aborting.')
     n = len(x)
     rankx = rankdata(x)
     ranky = rankdata(y)
     dsq = sumdiffsquared(rankx,ranky)
     rs = 1 - 6*dsq / float(n*(n**2-1))
     t = rs * math.sqrt((n-2) / ((rs+1.0)*(1.0-rs)))
     df = n-2
     probrs = betai(0.5*df,0.5,df/(df+t*t))  # t already a float
 # probability values for rs are from part 2 of the spearman function in
 # Numerical Recipies, p.510.  They are close to tables, but not exact. (?)
     return rs, probrs
 
 
 def lpointbiserialr(x,y):
     """
 Calculates a point-biserial correlation coefficient and the associated
 probability value.  Taken from Heiman's Basic Statistics for the Behav.
 Sci (1st), p.194.
 
 Usage:   lpointbiserialr(x,y)      where x,y are equal-length lists
 Returns: Point-biserial r, two-tailed p-value
 """
     TINY = 1e-30
     if len(x) != len(y):
-        raise ValueError, 'INPUT VALUES NOT PAIRED IN pointbiserialr.  ABORTING.'
+        raise ValueError('INPUT VALUES NOT PAIRED IN pointbiserialr.  ABORTING.')
     data = pstat.abut(x,y)
     categories = pstat.unique(x)
     if len(categories) != 2:
-        raise ValueError, "Exactly 2 categories required for pointbiserialr()."
+        raise ValueError("Exactly 2 categories required for pointbiserialr().")
     else:   # there are 2 categories, continue
         codemap = pstat.abut(categories,range(2))
         recoded = pstat.recode(data,codemap,0)
         x = pstat.linexand(data,0,categories[0])
         y = pstat.linexand(data,0,categories[1])
         xmean = mean(pstat.colex(x,1))
         ymean = mean(pstat.colex(y,1))
         n = len(data)
def llinregress(x,y):
     """
 Calculates a regression line on x,y pairs.  
 
 Usage:   llinregress(x,y)      x,y are equal-length lists of x-y coordinates
 Returns: slope, intercept, r, two-tailed prob, sterr-of-estimate
 """
     TINY = 1.0e-20
     if len(x) != len(y):
-        raise ValueError, 'Input values not paired in linregress.  Aborting.'
+        raise ValueError('Input values not paired in linregress.  Aborting.')
     n = len(x)
     x = map(float,x)
     y = map(float,y)
     xmean = mean(x)
     ymean = mean(y)
     r_num = float(n*(summult(x,y)) - sum(x)*sum(y))
     r_den = math.sqrt((n*ss(x) - square_of_sums(x))*(n*ss(y)-square_of_sums(y)))
     r = r_num / r_den

 printed to the screen.  If printit='filename', the results are output to
 'filename' using the given writemode (default=append).  Returns t-value,
 and prob.
 
 Usage:   lttest_rel(a,b,printit=0,name1='Sample1',name2='Sample2',writemode='a')
 Returns: t-value, two-tailed prob
 """
     if len(a) != len(b):
-        raise ValueError, 'Unequal length lists in ttest_rel.'
+        raise ValueError('Unequal length lists in ttest_rel.')
     x1 = mean(a)
     x2 = mean(b)
     v1 = var(a)
     v2 = var(b)
     n = len(a)
     cov = 0
     for i in range(len(a)):
         cov = cov + (a[i]-x1) * (b[i]-x2)
"""
     rankx = ranked[0:n1]       # get the x-ranks
     ranky = ranked[n1:]        # the rest are y-ranks
     u1 = n1*n2 + (n1*(n1+1))/2.0 - sum(rankx)  # calc U for x
     u2 = n1*n2 - u1                            # remainder is U for y
     bigu = max(u1,u2)
     smallu = min(u1,u2)
     T = math.sqrt(tiecorrect(ranked))  # correction factor for tied scores
     if T == 0:
-        raise ValueError, 'All numbers are identical in lmannwhitneyu'
+        raise ValueError('All numbers are identical in lmannwhitneyu')
     sd = math.sqrt(T*n1*n2*(n1+n2+1)/12.0)
     z = abs((bigu-n1*n2/2.0) / sd)  # normal approximation for prob calc
     return smallu, 1.0 - zprob(z)
 
 
 def ltiecorrect(rankvals):
     """
 Corrects for ties in Mann Whitney U and Kruskal Wallis H tests.  See
def lwilcoxont(x,y):
     """
 Calculates the Wilcoxon T-test for related samples and returns the
 result.  A non-parametric T-test.
 
 Usage:   lwilcoxont(x,y)
 Returns: a t-statistic, two-tail probability estimate
 """
     if len(x) != len(y):
-        raise ValueError, 'Unequal N in wilcoxont.  Aborting.'
+        raise ValueError('Unequal N in wilcoxont.  Aborting.')
     d=[]
     for i in range(len(x)):
         diff = x[i] - y[i]
         if diff != 0:
             d.append(diff)
     count = len(d)
     absd = map(abs,d)
     absranked = rankdata(absd)
"""
     for i in range(len(args)):
         rsums.append(sum(args[i])**2)
         rsums[i] = rsums[i] / float(n[i])
     ssbn = sum(rsums)
     totaln = sum(n)
     h = 12.0 / (totaln*(totaln+1)) * ssbn - 3*(totaln+1)
     df = len(args) - 1
     if T == 0:
-        raise ValueError, 'All numbers are identical in lkruskalwallish'
+        raise ValueError('All numbers are identical in lkruskalwallish')
     h = h / float(T)
     return h, chisqprob(h,df)
 
 
 def lfriedmanchisquare(*args):
     """
 Friedman Chi-Square is a non-parametric, one-way within-subjects
 ANOVA.  This function calculates the Friedman Chi-square test for repeated
 measures and returns the result, along with the associated probability
 value.  It assumes 3 or more repeated measures.  Only 3 levels requires a
 minimum of 10 subjects in the study.  Four levels requires 5 subjects per
 level(??).
 
 Usage:   lfriedmanchisquare(*args)
 Returns: chi-square statistic, associated p-value
 """
     k = len(args)
     if k < 3:
-        raise ValueError, 'Less than 3 levels.  Friedman test not appropriate.'
+        raise ValueError('Less than 3 levels.  Friedman test not appropriate.')
     n = len(args[0])
     data = apply(pstat.abut,tuple(args))
     for i in range(len(data)):
         data[i] = rankdata(data[i])
     ssbn = 0
     for i in range(k):
         ssbn = ssbn + sum(args[i])**2
     chisq = 12.0 / (k*n*(k+1)) * ssbn - 3*n*(k+1)

 
 where a,b>0 and B(a,b) = G(a)*G(b)/(G(a+b)) where G(a) is the gamma
 function of a.  The continued fraction formulation is implemented here,
 using the betacf function.  (Adapted from: Numerical Recipies in C.)
 
 Usage:   lbetai(a,b,x)
 """
     if (x<0.0 or x>1.0):
-        raise ValueError, 'Bad x in lbetai'
+        raise ValueError('Bad x in lbetai')
     if (x==0.0 or x==1.0):
         bt = 0.0
     else:
         bt = math.exp(gammln(a+b)-gammln(a)-gammln(b)+a*math.log(x)+b*
                       math.log(1.0-x))
     if (x<(a+1.0)/(a+b+2.0)):
         return bt*betacf(a,b,x)/float(a)
     else:
def lsummult (list1,list2):
     """
 Multiplies elements in list1 and list2, element by element, and
 returns the sum of all resulting multiplications.  Must provide equal
 length lists.
 
 Usage:   lsummult(list1,list2)
 """
     if len(list1) != len(list2):
-        raise ValueError, "Lists not equal length in summult."
+        raise ValueError("Lists not equal length in summult.")
     s = 0
     for item1,item2 in pstat.abut(list1,list2):
         s = s + item1*item2
     return s
 
 
 def lsumdiffsquared(x,y):
     """
"""
      if limits is None:
          return mean(a)
      assert isinstance(limits, (list, tuple, N.ndarray)), "Wrong type for limits in atmean"
      if inclusive[0]:         lowerfcn = N.greater_equal
      else:               lowerfcn = N.greater
      if inclusive[1]:         upperfcn = N.less_equal
      else:               upperfcn = N.less
      if limits[0] > N.maximum.reduce(N.ravel(a)) or limits[1] < N.minimum.reduce(N.ravel(a)):
-         raise ValueError, "No array values within given limits (atmean)."
+         raise ValueError("No array values within given limits (atmean).")
      elif limits[0] is None and limits[1] is not None:
          mask = upperfcn(a,limits[1])
      elif limits[0] is not None and limits[1] is None:
          mask = lowerfcn(a,limits[0])
      elif limits[0] is not None and limits[1] is not None:
          mask = lowerfcn(a,limits[0])*upperfcn(a,limits[1])
      s = float(N.add.reduce(N.ravel(a*mask)))
      n = float(N.add.reduce(N.ravel(mask)))
"""
      if limits is None or limits == [None, None]:
          return avar(a)
      assert isinstance(limits, (list, tuple, N.ndarray)), "Wrong type for limits in atvar"
      if inclusive[0]:    lowerfcn = N.greater_equal
      else:               lowerfcn = N.greater
      if inclusive[1]:    upperfcn = N.less_equal
      else:               upperfcn = N.less
      if limits[0] > N.maximum.reduce(N.ravel(a)) or limits[1] < N.minimum.reduce(N.ravel(a)):
-         raise ValueError, "No array values within given limits (atvar)."
+         raise ValueError("No array values within given limits (atvar).")
      elif limits[0] is None and limits[1] is not None:
          mask = upperfcn(a,limits[1])
      elif limits[0] is not None and limits[1] is None:
          mask = lowerfcn(a,limits[0])
      elif limits[0] is not None and limits[1] is not None:
          mask = lowerfcn(a,limits[0])*upperfcn(a,limits[1])
 
      a = N.compress(mask,a)  # squish out excluded values
if limits is None or limits == [None, None]:
          n = float(len(N.ravel(a)))
          limits = [min(a)-1, max(a)+1]
      assert isinstance(limits, (list, tuple, N.ndarray)), "Wrong type for limits in atsem"
      if inclusive[0]:         lowerfcn = N.greater_equal
      else:               lowerfcn = N.greater
      if inclusive[1]:         upperfcn = N.less_equal
      else:               upperfcn = N.less
      if limits[0] > N.maximum.reduce(N.ravel(a)) or limits[1] < N.minimum.reduce(N.ravel(a)):
-         raise ValueError, "No array values within given limits (atsem)."
+         raise ValueError("No array values within given limits (atsem).")
      elif limits[0] is None and limits[1] is not None:
          mask = upperfcn(a,limits[1])
      elif limits[0] is not None and limits[1] is None:
          mask = lowerfcn(a,limits[0])
      elif limits[0] is not None and limits[1] is not None:
          mask = lowerfcn(a,limits[0])*upperfcn(a,limits[1])
      term1 = N.add.reduce(N.ravel(a*a*mask))
      n = float(N.add.reduce(N.ravel(mask)))
for j in range(k):
             t2 = 0.5*v[j]*(n[j]-1.0)
             t3 = (n[j]-1.0)*(n[j]-2.0)
             nargs[j][i] = (t1-t2) / float(t3)
     check = 1
     for j in range(k):
         if v[j] - mean(nargs[j]) > TINY:
             check = 0
     if check != 1:
-        raise ValueError, 'Lack of convergence in obrientransform.'
+        raise ValueError('Lack of convergence in obrientransform.')
     else:
         return N.array(nargs)
 
 
  def asamplevar (inarray,dimension=None,keepdims=0):
     """
 Returns the sample standard deviation of the values in the passed
 array (i.e., using N).  Dimension can equal None (ravel array first),

  def acovariance(X):
     """
 Computes the covariance matrix of a matrix X.  Requires a 2D matrix input.
 
 Usage:   acovariance(X)
 Returns: covariance matrix of X
 """
     if len(X.shape) != 2:
-        raise TypeError, "acovariance requires 2D matrices"
+        raise TypeError("acovariance requires 2D matrices")
     n = X.shape[0]
     mX = amean(X,0)
     return N.dot(N.transpose(X),X) / float(n) - N.multiply.outer(mX,mX)
 
 
  def acorrelation(X):
     """
 Computes the correlation matrix of a matrix X.  Requires a 2D matrix input.

 
 Usage:   apointbiserialr(x,y)      where x,y are equal length arrays
 Returns: Point-biserial r, two-tailed p-value
 """
     TINY = 1e-30
     categories = pstat.aunique(x)
     data = pstat.aabut(x,y)
     if len(categories) != 2:
-        raise ValueError, "Exactly 2 categories required (in x) for pointbiserialr()."
+        raise ValueError("Exactly 2 categories required (in x) for pointbiserialr().")
     else:   # there are 2 categories, continue
         codemap = pstat.aabut(categories,N.arange(2))
         recoded = pstat.arecode(data,codemap,0)
         x = pstat.alinexand(data,0,categories[0])
         y = pstat.alinexand(data,0,categories[1])
         xmean = amean(pstat.acolex(x,1))
         ymean = amean(pstat.acolex(y,1))
         n = len(data)
Usage:   attest_rel(a,b,dimension=None,printit=0,
                     name1='Samp1',name2='Samp2',writemode='a')
 Returns: t-value, two-tailed p-value
 """
     if dimension is None:
         a = N.ravel(a)
         b = N.ravel(b)
         dimension = 0
     if len(a) != len(b):
-        raise ValueError, 'Unequal length arrays.'
+        raise ValueError('Unequal length arrays.')
     x1 = amean(a,dimension)
     x2 = amean(b,dimension)
     v1 = avar(a,dimension)
     v2 = avar(b,dimension)
     n = a.shape[dimension]
     df = float(n-1)
     d = (a-b).astype('d')
 
"""
     rankx = ranked[0:n1]       # get the x-ranks
     ranky = ranked[n1:]        # the rest are y-ranks
     u1 = n1*n2 + (n1*(n1+1))/2.0 - sum(rankx)  # calc U for x
     u2 = n1*n2 - u1                            # remainder is U for y
     bigu = max(u1,u2)
     smallu = min(u1,u2)
     T = math.sqrt(tiecorrect(ranked))  # correction factor for tied scores
     if T == 0:
-        raise ValueError, 'All numbers are identical in amannwhitneyu'
+        raise ValueError('All numbers are identical in amannwhitneyu')
     sd = math.sqrt(T*n1*n2*(n1+n2+1)/12.0)
     z = abs((bigu-n1*n2/2.0) / sd)  # normal approximation for prob calc
     return smallu, 1.0 - azprob(z)
 
 
  def atiecorrect(rankvals):
     """
 Tie-corrector for ties in Mann Whitney U and Kruskal Wallis H tests.
def awilcoxont(x,y):
     """
 Calculates the Wilcoxon T-test for related samples and returns the
 result.  A non-parametric T-test.
 
 Usage:   awilcoxont(x,y)     where x,y are equal-length arrays for 2 conditions
 Returns: t-statistic, two-tailed p-value
 """
     if len(x) != len(y):
-        raise ValueError, 'Unequal N in awilcoxont.  Aborting.'
+        raise ValueError('Unequal N in awilcoxont.  Aborting.')
     d = x-y
     d = N.compress(N.not_equal(d,0),d) # Keep all non-zero differences
     count = len(d)
     absd = abs(d)
     absranked = arankdata(absd)
     r_plus = 0.0
     r_minus = 0.0
     for i in range(len(absd)):
"""
     for i in range(len(args)):
         rsums.append(sum(args[i])**2)
         rsums[i] = rsums[i] / float(n[i])
     ssbn = sum(rsums)
     totaln = sum(n)
     h = 12.0 / (totaln*(totaln+1)) * ssbn - 3*(totaln+1)
     df = len(args) - 1
     if T == 0:
-        raise ValueError, 'All numbers are identical in akruskalwallish'
+        raise ValueError('All numbers are identical in akruskalwallish')
     h = h / float(T)
     return h, chisqprob(h,df)
 
 
  def afriedmanchisquare(*args):
     """
 Friedman Chi-Square is a non-parametric, one-way within-subjects
 ANOVA.  This function calculates the Friedman Chi-square test for
 repeated measures and returns the result, along with the associated
 probability value.  It assumes 3 or more repeated measures.  Only 3
 levels requires a minimum of 10 subjects in the study.  Four levels
 requires 5 subjects per level(??).
 
 Usage:   afriedmanchisquare(*args)   args are separate arrays for 2+ conditions
 Returns: chi-square statistic, associated p-value
 """
     k = len(args)
     if k < 3:
-        raise ValueError, '\nLess than 3 levels.  Friedman test not appropriate.\n'
+        raise ValueError('\nLess than 3 levels.  Friedman test not appropriate.\n')
     n = len(args[0])
     data = apply(pstat.aabut,args)
     data = data.astype(N.float_)
     for i in range(len(data)):
         data[i] = arankdata(data[i])
     ssbn = asum(asum(args,1)**2)
     chisq = 12.0 / (k*n*(k+1)) * ssbn - 3*n*(k+1)
     return chisq, achisqprob(chisq,k-1)

 here, using the betacf function.  (Adapted from: Numerical Recipies in
 C.)  Can handle multiple dimensions.
 
 Usage:   abetai(a,b,x,verbose=1)
 """
     TINY = 1e-15
     if isinstance(a, N.ndarray):
         if asum(N.less(x, 0) + N.greater(x, 1)) != 0:
-            raise ValueError, 'Bad x in abetai'
+            raise ValueError('Bad x in abetai')
     x = N.where(N.equal(x,0),TINY,x)
     x = N.where(N.equal(x,1.0),1-TINY,x)
 
     bt = N.where(N.equal(x,0)+N.equal(x,1), 0, -1)
     exponents = ( gammln(a+b)-gammln(a)-gammln(b)+a*N.log(x)+b*
                   N.log(1.0-x) )
     # 746 (below) is the MAX POSSIBLE BEFORE OVERFLOW
     exponents = N.where(N.less(exponents,-740),-740,exponents)