Example #1
0
def triangularPut(m1d, upper=1, lower=0):
    """Returns 2D masked array with elements of the given 1D array in the strictly upper (lower) triangle.
    Elements of the 1D array should be ordered according to the upper triangular part of the 2D matrix.
    The lower triangular part (if requested) equals to the transposed upper triangular part.
    If upper == lower == 1 a symetric matrix is returned.
    """
    assert upper in [0,1] and lower in [0,1], "[0|1] expected for upper / lower"
    m1d = MA.asarray(m1d)
    assert MA.rank(m1d) == 1, "1D masked array expected"
    m2dShape0 = math.ceil(math.sqrt(2*m1d.shape[0]))
    assert m1d.shape[0] == m2dShape0*(m2dShape0-1)/2, "the length of m1d does not correspond to n(n-1)/2"
    if upper:
        if lower:
            mask = Numeric.fromfunction(lambda i,j: i==j, (m2dShape0, m2dShape0))
        else:
            mask = Numeric.fromfunction(lambda i,j: i>=j, (m2dShape0, m2dShape0))
    else:
        if lower:
            mask = Numeric.fromfunction(lambda i,j: i<=j, (m2dShape0, m2dShape0))
        else:
            mask = Numeric.ones((m2dShape0, m2dShape0))

    m2d = MA.ravel(MA.zeros((m2dShape0, m2dShape0), m1d.dtype.char))
    condUpperTriang = Numeric.fromfunction(lambda i,j: i<j, (m2dShape0, m2dShape0))
    putIndices = Numeric.compress(Numeric.ravel(condUpperTriang), Numeric.arange(0, m2dShape0**2, typecode=Numeric.Int))
    MA.put(m2d, putIndices, m1d)
    m2d = MA.reshape(m2d, (m2dShape0, m2dShape0))
    m2d = MA.where(condUpperTriang, m2d, MA.transpose(m2d))
    return MA.array(m2d, mask=Numeric.logical_or(mask, MA.getmaskarray(m2d)))
def arc_by_radian(x, y, height, radian_range, thickness, gaussian_width):
    """
    Radial arc with Gaussian fall-off after the solid ring-shaped
    region with the given thickness, with shape specified by the
    (start,end) radian_range.
    """

    # Create a circular ring (copied from the ring function)
    radius = height/2.0
    half_thickness = thickness/2.0

    distance_from_origin = sqrt(x**2+y**2)
    distance_outside_outer_disk = distance_from_origin - radius - half_thickness
    distance_inside_inner_disk = radius - half_thickness - distance_from_origin

    ring = 1.0-bitwise_xor(greater_equal(distance_inside_inner_disk,0.0),greater_equal(distance_outside_outer_disk,0.0))

    sigmasq = gaussian_width*gaussian_width

    if sigmasq==0.0:
        inner_falloff = x*0.0
        outer_falloff = x*0.0
    else:
        with float_error_ignore():
            inner_falloff = exp(divide(-distance_inside_inner_disk*distance_inside_inner_disk, 2.0*sigmasq))
            outer_falloff = exp(divide(-distance_outside_outer_disk*distance_outside_outer_disk, 2.0*sigmasq))

    output_ring = maximum(inner_falloff,maximum(outer_falloff,ring))

    # Calculate radians (in 4 phases) and cut according to the set range)

    # RZHACKALERT:
    # Function float_error_ignore() cannot catch the exception when
    # both dividend and divisor are 0.0, and when only divisor is 0.0
    # it returns 'Inf' rather than 0.0. In x, y and
    # distance_from_origin, only one point in distance_from_origin can
    # be 0.0 (circle center) and in this point x and y must be 0.0 as
    # well. So here is a hack to avoid the 'invalid value encountered
    # in divide' error by turning 0.0 to 1e-5 in distance_from_origin.
    distance_from_origin += where(distance_from_origin == 0.0, 1e-5, 0)

    with float_error_ignore():
        sines = divide(y, distance_from_origin)
        cosines = divide(x, distance_from_origin)
        arcsines = arcsin(sines)

    phase_1 = where(logical_and(sines >= 0, cosines >= 0), 2*pi-arcsines, 0)
    phase_2 = where(logical_and(sines >= 0, cosines <  0), pi+arcsines,   0)
    phase_3 = where(logical_and(sines <  0, cosines <  0), pi+arcsines,   0)
    phase_4 = where(logical_and(sines <  0, cosines >= 0), -arcsines,     0)
    arcsines = phase_1 + phase_2 + phase_3 + phase_4

    if radian_range[0] <= radian_range[1]:
        return where(logical_and(arcsines >= radian_range[0], arcsines <= radian_range[1]),
                     output_ring, 0.0)
    else:
        return where(logical_or(arcsines >= radian_range[0], arcsines <= radian_range[1]),
                     output_ring, 0.0)
Example #3
0
def arc_by_radian(x, y, height, radian_range, thickness, gaussian_width):
    """
    Radial arc with Gaussian fall-off after the solid ring-shaped
    region with the given thickness, with shape specified by the
    (start,end) radian_range.
    """

    # Create a circular ring (copied from the ring function)
    radius = height/2.0
    half_thickness = thickness/2.0

    distance_from_origin = sqrt(x**2+y**2)
    distance_outside_outer_disk = distance_from_origin - radius - half_thickness
    distance_inside_inner_disk = radius - half_thickness - distance_from_origin

    ring = 1.0-bitwise_xor(greater_equal(distance_inside_inner_disk,0.0),greater_equal(distance_outside_outer_disk,0.0))

    sigmasq = gaussian_width*gaussian_width

    if sigmasq==0.0:
        inner_falloff = x*0.0
        outer_falloff = x*0.0
    else:
        with float_error_ignore():
            inner_falloff = exp(divide(-distance_inside_inner_disk*distance_inside_inner_disk, 2.0*sigmasq))
            outer_falloff = exp(divide(-distance_outside_outer_disk*distance_outside_outer_disk, 2.0*sigmasq))
            
    output_ring = maximum(inner_falloff,maximum(outer_falloff,ring))

    # Calculate radians (in 4 phases) and cut according to the set range)

    # RZHACKALERT:
    # Function float_error_ignore() cannot catch the exception when
    # both dividend and divisor are 0.0, and when only divisor is 0.0
    # it returns 'Inf' rather than 0.0. In x, y and
    # distance_from_origin, only one point in distance_from_origin can
    # be 0.0 (circle center) and in this point x and y must be 0.0 as
    # well. So here is a hack to avoid the 'invalid value encountered
    # in divide' error by turning 0.0 to 1e-5 in distance_from_origin.
    distance_from_origin += where(distance_from_origin == 0.0, 1e-5, 0)

    with float_error_ignore():
        sines = divide(y, distance_from_origin)
        cosines = divide(x, distance_from_origin)
        arcsines = arcsin(sines)

    phase_1 = where(logical_and(sines >= 0, cosines >= 0), 2*pi-arcsines, 0)
    phase_2 = where(logical_and(sines >= 0, cosines <  0), pi+arcsines,   0)
    phase_3 = where(logical_and(sines <  0, cosines <  0), pi+arcsines,   0)
    phase_4 = where(logical_and(sines <  0, cosines >= 0), -arcsines,     0)
    arcsines = phase_1 + phase_2 + phase_3 + phase_4

    if radian_range[0] <= radian_range[1]:
        return where(logical_and(arcsines >= radian_range[0], arcsines <= radian_range[1]),
                     output_ring, 0.0)
    else:
        return where(logical_or(arcsines >= radian_range[0], arcsines <= radian_range[1]),
                     output_ring, 0.0)
Example #4
0
 def contactsDiff(self, ref, cutoff=None):
     """
     Number of different B{residue-residue} contacts in this and
     reference complex.
     
     @param ref: to compare this one with
     @type  ref: Complex
     @param cutoff: maximal atom-atom distance, None .. previous setting
     @type  cutoff: float
     
     @return: number of contacts different in this and refererence complex.
     @rtype: int
     """
     both = N.logical_or( self.resContacts(cutoff), ref.resContacts(cutoff))
     return N.sum(N.sum(both)) - self.contactsShared( ref, cutoff )
Example #5
0
    def contactsOverlap(self, ref, cutoff=None):
        """
        Fraction of overlapping B{residue-residue} contacts between this and
        reference complex.
        
        @param ref: reference complex
        @type  ref: Complex
        @param cutoff: maximal atom-atom distance, None .. previous setting
        @type  cutoff: float
        
        @return: fraction of contacts shared between this and ref
                 (normalized to number of all contacts)
        @rtype: float
        """
        equal = N.logical_and(self.resContacts( cutoff=cutoff ),
                            ref.resContacts( cutoff=cutoff ) )
        total = N.logical_or( self.resContacts(cutoff),
                              ref.resContacts(cutoff) )

        return N.sum(N.sum( equal )) * 1.0 / N.sum(N.sum( total ))
Example #6
0
 def ttest_rsmplA(self, ma3d, callback):
     """conducts related samples t-test on individual examples wrt factor A (variables, ma3d axis 1);
     returns Numeric array of p-values in shape (1, numExamples).
     """
     ps = -1*Numeric.ones((ma3d.shape[0],), Numeric.Float)
     for eIdx in range(ma3d.shape[0]):
         a = ma3d[eIdx][0]
         b = ma3d[eIdx][1]
         cond = Numeric.logical_not(Numeric.logical_or(MA.getmaskarray(a), MA.getmaskarray(b)))
         a = Numeric.asarray(MA.compress(cond, a))
         b = Numeric.asarray(MA.compress(cond, b))
         if len(a) >= 2:
             try:
                 ps[eIdx] = scipy.stats.ttest_rel(a,b)[1]
             except Exception, inst:
                 print "Warning: %s" % str(inst)
                 print "Example %i:\n%s\n%s\n" % (eIdx, str(a), str(b))
                 ps[eIdx] = 1.0
         else:
             print "Warning: removing example %i:\n%s\n%s\n" % (eIdx, str(a), str(b))
             ps[eIdx] = 1.0
         callback()
Example #7
0
    assert Numeric.allclose(X, Y)
    print "Raw reduce using pypar.LAND OK"    
    
  pypar.raw_reduce(testArray, X, pypar.BAND, 0, 0)
  if myid == 0:
    Y = Numeric.ones(N)*255  #Neutral element for &   
    for i in range(numproc):
      Y = Numeric.bitwise_and(Y, Numeric.array(range(N))*(i+1))
    assert Numeric.allclose(X, Y)
    print "Raw reduce using pypar.BAND OK"    

  pypar.raw_reduce(testArray, X, pypar.LOR, 0, 0)
  if myid == 0:  
    Y = Numeric.zeros(N)    
    for i in range(numproc):
      Y = Numeric.logical_or(Y, Numeric.array(range(N))*(i+1))  
    assert Numeric.allclose(X, Y)
    print "Raw reduce using pypar.LOR OK"    
  
  pypar.raw_reduce(testArray, X, pypar.BOR, 0, 0)
  if myid == 0:
    Y = Numeric.zeros(N)   #Neutral element for |   
    for i in range(numproc):
      Y = Numeric.bitwise_or(Y, Numeric.array(range(N))*(i+1))
    assert Numeric.allclose(X, Y)
    print "Raw reduce using pypar.BOR OK"    

  pypar.raw_reduce(testArray, X, pypar.LXOR, 0, 0)
  if myid == 0:  
    Y = Numeric.zeros(N)    
    for i in range(numproc):
Example #8
0
def logical_unary_or(m1, m2):
    el = Numeric.logical_or(m1.filled(0), m2.filled(0))
    mask = Numeric.logical_and(MA.getmaskarray(m1), MA.getmaskarray(m2))
    return MA.array(el, mask=mask)    
Example #9
0
    def __init__(self, centers, radii, gridSpacing, gridOrigin, gridSize):
        import numpy.oldnumeric as Numeric
        self.grid = Numeric.zeros(gridSize, Numeric.UnsignedInt8)
        self.origin = gridOrigin
        self.spacing = gridSpacing
        self.minSpacing = min(gridSpacing)
        self.positions = []
        self.sphereMasks = {}
        #i=0
        for p in centers:
            self.positions.append([
                int(round((p[0] - gridOrigin[0]) / gridSpacing[0])),
                int(round((p[1] - gridOrigin[1]) / gridSpacing[1])),
                int(round((p[2] - gridOrigin[2]) / gridSpacing[2]))
            ])
            #print i, p, self.positions[-1]
            #i += 1
        for r in radii:
            dr = round(r / self.minSpacing)
            if not self.sphereMasks.has_key(dr):
                self.sphereMasks[dr] = SphereMask(dr)

        largeMap = self.grid
        lx, ly, lz = largeMap.shape
        from numpy.oldnumeric import logical_or
        i = 0
        for p, r in zip(self.positions, radii):
            #print i
            smallMap = self.sphereMasks[round(r / self.minSpacing)].grid
            offx = smallMap.shape[0] / 2
            offy = smallMap.shape[0] / 2
            offz = smallMap.shape[0] / 2
            #print 'off', offx, offy, offz
            px1 = p[0] - offx
            px2 = p[0] + offx + 1
            py1 = p[1] - offy
            py2 = p[1] + offy + 1
            pz1 = p[2] - offz
            pz2 = p[2] + offz + 1
            ox = oy = oz = 0
            ex, ey, ez = smallMap.shape
            lx, ly, lz = largeMap.shape

            #print 'p1', px1, py1, pz1
            #print 'p2', px2, py2, pz2
            #print 'dims', lx, ly, lz

            if px2 < 0 or py2 < 0 or py2 < 0 or px1 > lx or py1 > ly or py1 > lz:
                print 'discreteSpheres: WARNING: sphere %d outside grid, it is skipped', i
                continue
            if px1 < 0:
                ox = -px1
                px1 = 0
            if py1 < 0:
                oy = -py1
                py1 = 0
            if pz1 < 0:
                oz = -pz1
                pz1 = 0
            if px2 > lx:
                ex = lx - px2
                px2 = lx
            if py2 > ly:
                ey = ly - py2
                py2 = ly
            if pz2 > lz:
                ez = lz - pz2
                pz2 = lx

            #print 'o', ox, oy, oz
            #print 'e', ex, ey, ez

            submap = largeMap[px1:px2, py1:py2, pz1:pz2]
            #print 'submap shape', submap.shape
            largeMap[px1:px2, py1:py2,
                     pz1:pz2] = logical_or(submap, smallMap[ox:ex, oy:ey,
                                                            oz:ez])
            i += 1
    def __init__(self, centers, radii, gridSpacing, gridOrigin,
                 gridSize):
        import numpy.oldnumeric as Numeric
        self.grid = Numeric.zeros(gridSize, Numeric.UnsignedInt8)
        self.origin = gridOrigin
        self.spacing = gridSpacing
        self.minSpacing = min(gridSpacing)
        self.positions = []
        self.sphereMasks = {}
        #i=0
        for p in centers:
            self.positions.append( [
                int(round((p[0]-gridOrigin[0])/gridSpacing[0])),
                int(round((p[1]-gridOrigin[1])/gridSpacing[1])),
                int(round((p[2]-gridOrigin[2])/gridSpacing[2])) ] )
            #print i, p, self.positions[-1]
            #i += 1
        for r in radii:
            dr = round(r/self.minSpacing)
            if not self.sphereMasks.has_key(dr):
                self.sphereMasks[dr] = SphereMask( dr )

        largeMap = self.grid
        lx, ly, lz = largeMap.shape
        from numpy.oldnumeric import logical_or
        i=0
        for p, r in zip(self.positions, radii):
            #print i
            smallMap = self.sphereMasks[round(r/self.minSpacing)].grid
            offx = smallMap.shape[0]/2
            offy = smallMap.shape[0]/2
            offz = smallMap.shape[0]/2
            #print 'off', offx, offy, offz
            px1 = p[0]-offx
            px2 = p[0]+offx+1
            py1 = p[1]-offy
            py2 = p[1]+offy+1
            pz1 = p[2]-offz
            pz2 = p[2]+offz+1
            ox = oy = oz = 0
            ex,ey,ez = smallMap.shape
            lx,ly,lz = largeMap.shape

            #print 'p1', px1, py1, pz1
            #print 'p2', px2, py2, pz2
            #print 'dims', lx, ly, lz

            if px2<0 or py2<0 or py2<0 or px1>lx or py1>ly or py1>lz:
                print 'discreteSpheres: WARNING: sphere %d outside grid, it is skipped', i
                continue
            if px1<0:
                ox = -px1
                px1 = 0
            if py1<0:
                oy = -py1
                py1 = 0
            if pz1<0:
                oz = -pz1
                pz1 = 0
            if px2>lx:
                ex = lx-px2
                px2 = lx
            if py2>ly:
                ey = ly-py2
                py2 = ly
            if pz2>lz:
                ez = lz-pz2
                pz2 = lx

            #print 'o', ox, oy, oz
            #print 'e', ex, ey, ez
            
            submap = largeMap[px1:px2, py1:py2, pz1:pz2]
            #print 'submap shape', submap.shape
            largeMap[px1:px2, py1:py2, pz1:pz2] = logical_or(
                submap, smallMap[ox:ex, oy:ey, oz:ez]) 
            i += 1