Ejemplo n.º 1
0
Archivo: r.py Proyecto: NPSDC/Modeling
def compute_pi3k(egfr_value, erk_value, time_value, initial_values, mfs):
	"""Rules ---
	if egfr is high and erk is low and time is high then pi3k is high
	if egfr is low or erk is high or time is low then pi3k is low"""

	a1_1 = mfs[0][1][initial_values[0] == egfr_value] #egfr_high[egfr == egfr_value]
	a1_2 = mfs[1][0][ initial_values[1] == erk_value] #erk_low[erk == erk_value]
	a1_3 = mfs[3][1][ initial_values[3] == time_value]

	if( a1_1.size == 0):
		a1_1 = mfs[0][1][ find_closest(initial_values[0], egfr_value)]
	if( a1_2.size == 0):
		a1_2 = mfs[1][0][ find_closest(initial_values[1], erk_value)]
	if( a1_3.size == 0):
		a1_3 = mfs[3][1][ find_closest(initial_values[3], time_value)]

	a1 = min(a1_1 , a1_2, a1_3)
	c1 = np.fmin( np.linspace(a1, a1, 100), mfs[2][1])

	a2_1 = mfs[0][0][ initial_values[0] == egfr_value] #egfr_low[egfr == egfr_value]
	a2_2 = mfs[1][1][ initial_values[1] == erk_value] #erk_high[erk == erk_value]
	a2_3 = mfs[3][0][ initial_values[3] == time_value]

	if( a2_1.size == 0):
		a2_1 = mfs[0][0][ find_closest(initial_values[0], egfr_value)]
	if( a2_2.size == 0):
		a2_2 = mfs[1][1][ find_closest(initial_values[1], erk_value)]
	if( a2_3.size == 0):
		a2_3 = mfs[3][0][ find_closest(initial_values[3], time_value)]

	a2 = max(a2_1 , a2_2, a2_3)
	c2 = np.fmin( np.linspace(a2, a2, 100), mfs[2][0] )

	c_com = np.fmax(c1, c2)
	return fuzz.defuzz(initial_values[2], c_com, 'centroid')
Ejemplo n.º 2
0
def newton(B, b, g, x0, eps, kmax, s):
    k = 0
    x = np.copy(x0)
    x1 = np.copy(x0)
    err = eps + 1
    B1 = np.copy(B.toarray())
    while (k < kmax and err > eps):
        k = k + 1
        F = np.fmin(B.dot(x) - b, x - g)
        Fp = csr_matrix(B, copy=True)

        """
        #############
        F1 = np.fmin(np.dot(B1, x1) - b, x1 - g)
        Fp1 = np.eye(len(B1))
        i1 = np.where((np.dot(B1, x1) - b) <= (x1 - g))
        Fp1[i1, :] = B1[i1, :]
        x1 = x1 - np.linalg.solve(Fp1, F1)
        #############
        """

        i = np.where((B.dot(x) - b) > (x - g))
        for i_row in i[0][:]:
            csr_row_set_nz_to_val(Fp, i_row) # set row to identity
        x = x - sparse.linalg.spsolve(Fp, F)
        #x = x - np.linalg.solve(Fp, F)
        err = np.linalg.norm(np.fmin(B.dot(x) - b , x - g), np.inf)
        err1 = np.linalg.norm(np.fmin(np.dot(B1, x1) - b, x1 - g), np.inf)

        #txt = "Scheme (k=" + str(k) + ")"
        #plt.plot(s, x[992:1024], label=txt )
        #plt.show()
    return x
Ejemplo n.º 3
0
def fuzzy_min(x, A, y, B):
    """
    Finds minimum between fuzzy set A in universe x and fuzzy set B in
    universe y.

    Parameters
    ----------
    x : 1d array, length N
        Universe variable for fuzzy set A.
    A : 1d array, length N
        Fuzzy set for universe x.
    y : 1d array, length M
        Universe variable for fuzzy set B.
    B : 1d array, length M
        Fuzzy set for universe y.

    Returns
    -------
    z : 1d array
        Output variable.
    mfz : 1d array
        Fuzzy membership set for variable z.

    Note
    ----
    Uses Zadeh's Extension Principle from Ross, Fuzzy Logic w/Engineering
    Applications, (2010), pp.414, Eq. 12.17.

    """
    # A and x, and B and y, are formed into (MxN) matrices.  The former has
    # identical rows; the latter identical identical columns.
    N = len(B)
    AA = np.dot(np.atleast_2d(A).T, np.ones((1, N)))
    X = np.dot(np.atleast_2d(x).T, np.ones((1, N)))
    M = len(A)
    BB = np.dot(np.ones((M, 1)), np.atleast_2d(B))
    Y = np.dot(np.ones((M, 1)), np.atleast_2d(y))

    # Take the element-wise minimum
    Z = np.fmin(X, Y).ravel()
    Z_index = np.argsort(Z)
    Z = np.sort(Z)

    # Array min() operation
    C = np.fmin(AA, BB).ravel()
    C = C[Z_index]

    # Initialize loop
    z, mfz = np.empty(0), np.empty(0)
    idx = 0

    for i in range(len(C)):
        index = np.nonzero(Z == Z[idx])[0]
        z = np.hstack((z, Z[idx]))
        mfz = np.hstack((mfz, C[index].max()))
        if Z[idx] == Z.max():
            break
        idx = index.max() + 1

    return z, mfz
Ejemplo n.º 4
0
def rule_base(b, f_mat):
    """
    Returns y values of output by clipping by an amount of output activations for output fuzzy subsets
    arguments:
    f_mat - rule_strength matrix
    b     - b[2] , y values of output fuzzy subsets

E / DEL_E|         NM      ||       NS        ||        Z         ||       PS        ||       PM
----------------------------------------------------------------------------------------------------------
    NM   | f_mat[0][0] NM  || f_mat[0][1] NM  ||  f_mat[0][2] NS  || f_mat[0][3] Z   || f_mat[0][4] PS
    NS   | f_mat[1][0] NM  || f_mat[1][1] NM  ||  f_mat[1][2] NS  || f_mat[1][3] PS  || f_mat[1][4] PM
    Z    | f_mat[2][0] NM  || f_mat[2][1] NS  ||  f_mat[2][2] Z   || f_mat[2][3] PS  || f_mat[2][4] PM
    PS   | f_mat[3][0] NM  || f_mat[3][1] NS  ||  f_mat[3][2] PS  || f_mat[3][3] PM  || f_mat[3][4] PM
    PM   | f_mat[4][0] NS  || f_mat[4][1] Z   ||  f_mat[4][2] PS  || f_mat[4][3] PM  || f_mat[4][4] PM

    """
    NM = max(f_mat[0][0], f_mat[0][1], f_mat[1][0], f_mat[1][1], f_mat[2][0], f_mat[3][0])
    b[2][0] = np.fmin(NM, b[2][0])
    NS = max(f_mat[0][2], f_mat[1][2], f_mat[2][1], f_mat[3][1], f_mat[4][0])
    b[2][1] = np.fmin(NS, b[2][1])
    Z = max(f_mat[0][3], f_mat[2][2], f_mat[4][1])
    b[2][2] = np.fmin(Z, b[2][2])
    PS = max(f_mat[0][4], f_mat[1][3], f_mat[2][3], f_mat[3][2], f_mat[4][2])
    b[2][3] = np.fmin(PS, b[2][3])
    PM = max(f_mat[1][4], f_mat[2][4], f_mat[3][4], f_mat[3][3], f_mat[4][3], f_mat[4][4])
    b[2][4] = np.fmin(PM, b[2][4])

    return b[2]
Ejemplo n.º 5
0
Archivo: r.py Proyecto: NPSDC/Modeling
def compute_akt(pi3k_value, time_value, initial_values, mfs):
	"""Rules-
		If pi3k is high and time is high akt is high
		If pi3k is low or time is low then akt is low"""
	a1_1 = mfs[0][1][initial_values[0] == pi3k_value]
	a1_2 = mfs[2][1][initial_values[2] == time_value]

	if( a1_1.size == 0):
		a1_1 = mfs[0][1][ find_closest(initial_values[0], pi3k_value)]
	if( a1_2.size == 0):
		a1_2 = mfs[2][1][ find_closest(initial_values[2], time_value)]

	a1 = min(a1_1, a1_2)
	c1 = np.fmin( np.linspace(a1, a1, 100), mfs[1][1])

	a2_1 = mfs[0][0][initial_values[0] == pi3k_value]
	a2_2 = mfs[2][0][initial_values[2] == time_value]

	if( a2_1.size == 0):
		a2_1 = mfs[0][0][ find_closest(initial_values[0], pi3k_value)]
	if( a2_2.size == 0):
		a2_2 = mfs[2][0][ find_closest(initial_values[2], time_value)]

	a2 = max(a2_1, a2_2)
	c2 = np.fmin( np.linspace(a2, a2, 100), mfs[1][0])

	c_com = np.fmax(c1,c2)
	return fuzz.defuzz( initial_values[1], c_com, 'centroid')
Ejemplo n.º 6
0
	def work(self, input_items, output_items):
		if self.mlimstage:
			for x in xrange(0, len(input_items)):
				try:
					if self.input_blocks[x] is self.null_src:
						continue
				except Exception as e:
					print 'x:%s len(input_items):%s len(input_blocks):%s' % (x, len(input_items), len(self.input_blocks))
					raise e
				ia = input_items[x]
				numpy.fmin(ia, self.limvals[x], ia)
				numpy.multiply(ia, self.mulvals[x], ia)
				input_items[x] = ia

		cur = None
		for x in xrange(0, len(input_items)):
			if self.input_blocks[x] is self.null_src:
				continue
			if cur is None:
				cur = input_items[x]
			else:
				numpy.add(cur, input_items[x], cur)
		bsize = len(output_items[0])
		if cur is None:
			output_items[0][:] = numpy.zeros(bsize, self.dtype)
		else:
			output_items[0][:] = cur
		return bsize
Ejemplo n.º 7
0
 def test_fmin(self):
     from numpy import fmin, array
     nnan, nan, inf, ninf = float('-nan'), float('nan'), float('inf'), float('-inf')
     a = array((complex(ninf, 10), complex(10, ninf),
                complex( inf, 10), complex(10,  inf),
                5+5j, 5-5j, -5+5j, -5-5j,
                0+5j, 0-5j, 5, -5,
                complex(nan, 0), complex(0, nan)), dtype = complex)
     b = [inf]*a.size
     res = [a[0 ], a[1 ], b[2 ], a[3 ],
            a[4 ], a[5 ], a[6 ], a[7 ],
            a[8 ], a[9 ], a[10], a[11],
            b[12], b[13]]
     assert (fmin(a, b) == res).all()
     b = [ninf]*a.size
     res = [b[0 ], b[1 ], b[2 ], b[3 ],
            b[4 ], b[5 ], b[6 ], b[7 ],
            b[8 ], b[9 ], b[10], b[11],
            b[12], b[13]]
     assert (fmin(a, b) == res).all()
     b = [0]*a.size
     res = [a[0 ], b[1 ], b[2 ], b[3 ],
            b[4 ], b[5 ], a[6 ], a[7 ],
            b[8 ], a[9 ], b[10], a[11],
            b[12], b[13]]
     assert (fmin(a, b) == res).all()
Ejemplo n.º 8
0
def periodic_3d_distance(x1, y1, z1, x2, y2, z2, Lbox):
    """
    Function computes the distance between two sets of coordinates 
    with the same number of points, accounting for PBCs. 

    Parameters 
    ------------
    x1, y1, z1 : array_like 
        Length-Npts arrays storing Cartesian coordinates 

    x2, y2, z2 : array_like 
        Length-Npts arrays storing Cartesian coordinates 

    Lbox : float 
        Box length defining the periodic boundary conditions 

    Returns 
    --------
    r : array_like 
        Length-Npts array storing the 3d distance between the input 
        points, accounting for box periodicity. 
    """
    dx = np.fabs(x1 - x2)
    dx = np.fmin(dx, Lbox - dx)
    dy = np.fabs(y1 - y2)
    dy = np.fmin(dy, Lbox - dy)
    dz = np.fabs(z1 - z2)
    dz = np.fmin(dz, Lbox - dz)
    return np.sqrt(dx*dx+dy*dy+dz*dz)
Ejemplo n.º 9
0
def clip_to_window(boxlist, window):
  """Clip bounding boxes to a window.

  This op clips input bounding boxes (represented by bounding box
  corners) to a window, optionally filtering out boxes that do not
  overlap at all with the window.

  Args:
    boxlist: BoxList holding M_in boxes
    window: a numpy array of shape [4] representing the
            [y_min, x_min, y_max, x_max] window to which the op
            should clip boxes.

  Returns:
    a BoxList holding M_out boxes where M_out <= M_in
  """
  y_min, x_min, y_max, x_max = np.array_split(boxlist.get(), 4, axis=1)
  win_y_min = window[0]
  win_x_min = window[1]
  win_y_max = window[2]
  win_x_max = window[3]
  y_min_clipped = np.fmax(np.fmin(y_min, win_y_max), win_y_min)
  y_max_clipped = np.fmax(np.fmin(y_max, win_y_max), win_y_min)
  x_min_clipped = np.fmax(np.fmin(x_min, win_x_max), win_x_min)
  x_max_clipped = np.fmax(np.fmin(x_max, win_x_max), win_x_min)
  clipped = np_box_list.BoxList(
      np.hstack([y_min_clipped, x_min_clipped, y_max_clipped, x_max_clipped]))
  clipped = _copy_extra_fields(clipped, boxlist)
  areas = area(clipped)
  nonzero_area_indices = np.reshape(np.nonzero(np.greater(areas, 0.0)),
                                    [-1]).astype(np.int32)
  return gather(clipped, nonzero_area_indices)
Ejemplo n.º 10
0
def fuzzy_min(x, a, y, b):
    """
    Finds minimum between fuzzy set a in universe x and fuzzy set b in
    universe y.

    Parameters
    ----------
    x : 1d array, length N
        Universe variable for fuzzy set a.
    a : 1d array, length N
        Fuzzy set for universe x.
    y : 1d array, length M
        Universe variable for fuzzy set b.
    b : 1d array, length M
        Fuzzy set for universe y.

    Returns
    -------
    z : 1d array
        Output variable.
    mfz : 1d array
        Fuzzy membership set for variable z.

    Note
    ----
    Uses Zadeh's Extension Principle from Ross, Fuzzy Logic w/Engineering
    Applications, (2010), pp.414, Eq. 12.17.

    """
    # a and x, and b and y, are formed into (MxN) matrices.  The former has
    # identical rows; the latter identical identical columns.
    n = len(b)
    aa = np.dot(np.atleast_2d(a).T, np.ones((1, n)))
    x = np.dot(np.atleast_2d(x).T, np.ones((1, n)))
    m = len(a)
    bb = np.dot(np.ones((m, 1)), np.atleast_2d(b))
    y = np.dot(np.ones((m, 1)), np.atleast_2d(y))

    # Take the element-wise minimum
    zz = np.fmin(x, y).ravel()
    zz_index = np.argsort(zz)
    zz = np.sort(zz)

    # Array min() operation
    c = np.fmin(aa, bb).ravel()
    c = c[zz_index]

    # Initialize loop
    z, mfz = np.empty(0), np.empty(0)
    idx = 0

    for i in range(len(c)):
        index = np.nonzero(zz == zz[idx])[0]
        z = np.hstack((z, zz[idx]))
        mfz = np.hstack((mfz, c[index].max()))
        if zz[idx] == zz.max():
            break
        idx = index.max() + 1

    return z, mfz
Ejemplo n.º 11
0
def adjust(p, method='bonferroni'):
    '''
    Usage:
        pvalues.adjust(p, method='bonferroni')
        returns p-values adjusted using one of several methods.
        p ... numeric vector of p-values (possibly with NAs)
        method ... correction method
            bonferroni: Use Bonferroni method to control the family-wise error rate strictly.
            BH: Use method of Benjamini and Hochberg to control the false discovery rate.
            fdr: same as 'BH'.
    '''
    try:
        p = np.array(p).astype(float)
        n = len(p)
    except ValueError:
        print 'Error: input p-values contain invalid string elements.'
        quit()
    # remove "n.a." values from input vector
    p0 = p
    not_na = ~np.isnan(p)
    p = p[not_na]
    lp = len(p)
    if lp <= 1:
        return p0
    if method == 'bonferroni':
        p0[not_na] = np.fmin(1., n*p)
    elif method == 'BH' or method == 'fdr':
        i = np.arange(lp+1)[:0:-1]
        o = np.argsort(p)[::-1]
        ro = np.argsort(o)
        p0[not_na] = np.fmin(1., np.minimum.accumulate(float(n) / i.astype(float) * p[o]))[ro]
 
    return p0
Ejemplo n.º 12
0
def compute_erk_change(raf_value, time_value, initial_values, mfs):
	"""Rules-
		If raf is high and time is high then positive_change_erk is high
		If raf is high1 and time is low then positive_change_erk is low
		If raf is low then positive_change_erk is low
		If raf is low and time is high then negative_change_erk is high
		If raf is low and time is low then negative_change_erk is low"""

	
	#Antecedent 1
	f = interp1d(initial_values[0][0], mfs[0][1])
	a1_1 = f(raf_value) #raf_high[raf == raf_value]
	f = interp1d(initial_values[2], mfs[2][1])
	a1_2 = f(time_value) #time_high[time == time_value]

	a1 = min(a1_1, a1_2)
	c1 = np.fmin( a1, mfs[1][3]) #mfs[1][3] is positive_change_erk_high

	#Antecedent 2
	f = interp1d(initial_values[0][0], mfs[0][6])
	a2_1 = f(raf_value)
	f = interp1d(initial_values[2], mfs[2][0]) #time_low[time == time_value]
	a2_2 = f(time_value)

	a2 = min(a2_1, a2_2)
	c2 = np.fmin( a2, mfs[1][2]) #mfs[1][2] is positive_change_raf_low

	c_com_positive = np.fmax(c1,c2)

	f = interp1d(initial_values[0][0], mfs[0][0])
	a3 = f(raf_value)
	c3 = np.fmin(a3, mfs[1][2])

	c_com_positive = np.fmax(c_com_positive, c3)
	pos_change = fuzz.defuzz( initial_values[1][1], c_com_positive, 'centroid') #initial_values[1][1] is positive_change_erk

	###Negative Change

	#Antecedent 3
	'''f = interp1d(initial_values[0][0], mfs[0][0])
	a3_1 = f(raf_value) #raf_low[raf == raf_value]
	a3_2 = a1_2 #time_high[time == time_value]

	a3 = min(a3_1,a3_2)
	c3 = np.fmin(a3, mfs[1][5]) #mfs[1][3] is negative_change_erk_high

	#Antecedent 4
	a4_1 = a3_1 #raf_low[raf == raf_value]
	a4_2 = a2_2 #time_low[time == time_value]

	a4 = min(a4_1, a4_2)
	c4 = np.fmin(a4, mfs[1][4]) #mfs[1][4] is negative_change_erk_low

	c_com_negative = np.fmax(c3, c4)
	neg_change = fuzz.defuzz(initial_values[1][2], c_com_negative, 'centroid') #initial_values[1][2] is negative_change_erk'''
	
	#print pos_change, neg_change
	#print pos_change
	return pos_change 
Ejemplo n.º 13
0
    def test_half_ufuncs(self):
        """Test the various ufuncs"""

        a = np.array([0, 1, 2, 4, 2], dtype=float16)
        b = np.array([-2, 5, 1, 4, 3], dtype=float16)
        c = np.array([0, -1, -np.inf, np.nan, 6], dtype=float16)

        assert_equal(np.add(a, b), [-2, 6, 3, 8, 5])
        assert_equal(np.subtract(a, b), [2, -4, 1, 0, -1])
        assert_equal(np.multiply(a, b), [0, 5, 2, 16, 6])
        assert_equal(np.divide(a, b), [0, 0.199951171875, 2, 1, 0.66650390625])

        assert_equal(np.equal(a, b), [False, False, False, True, False])
        assert_equal(np.not_equal(a, b), [True, True, True, False, True])
        assert_equal(np.less(a, b), [False, True, False, False, True])
        assert_equal(np.less_equal(a, b), [False, True, False, True, True])
        assert_equal(np.greater(a, b), [True, False, True, False, False])
        assert_equal(np.greater_equal(a, b), [True, False, True, True, False])
        assert_equal(np.logical_and(a, b), [False, True, True, True, True])
        assert_equal(np.logical_or(a, b), [True, True, True, True, True])
        assert_equal(np.logical_xor(a, b), [True, False, False, False, False])
        assert_equal(np.logical_not(a), [True, False, False, False, False])

        assert_equal(np.isnan(c), [False, False, False, True, False])
        assert_equal(np.isinf(c), [False, False, True, False, False])
        assert_equal(np.isfinite(c), [True, True, False, False, True])
        assert_equal(np.signbit(b), [True, False, False, False, False])

        assert_equal(np.copysign(b, a), [2, 5, 1, 4, 3])

        assert_equal(np.maximum(a, b), [0, 5, 2, 4, 3])
        x = np.maximum(b, c)
        assert_(np.isnan(x[3]))
        x[3] = 0
        assert_equal(x, [0, 5, 1, 0, 6])
        assert_equal(np.minimum(a, b), [-2, 1, 1, 4, 2])
        x = np.minimum(b, c)
        assert_(np.isnan(x[3]))
        x[3] = 0
        assert_equal(x, [-2, -1, -np.inf, 0, 3])
        assert_equal(np.fmax(a, b), [0, 5, 2, 4, 3])
        assert_equal(np.fmax(b, c), [0, 5, 1, 4, 6])
        assert_equal(np.fmin(a, b), [-2, 1, 1, 4, 2])
        assert_equal(np.fmin(b, c), [-2, -1, -np.inf, 4, 3])

        assert_equal(np.floor_divide(a, b), [0, 0, 2, 1, 0])
        assert_equal(np.remainder(a, b), [0, 1, 0, 0, 2])
        assert_equal(np.divmod(a, b), ([0, 0, 2, 1, 0], [0, 1, 0, 0, 2]))
        assert_equal(np.square(b), [4, 25, 1, 16, 9])
        assert_equal(np.reciprocal(b), [-0.5, 0.199951171875, 1, 0.25, 0.333251953125])
        assert_equal(np.ones_like(b), [1, 1, 1, 1, 1])
        assert_equal(np.conjugate(b), b)
        assert_equal(np.absolute(b), [2, 5, 1, 4, 3])
        assert_equal(np.negative(b), [2, -5, -1, -4, -3])
        assert_equal(np.positive(b), b)
        assert_equal(np.sign(b), [-1, 1, 1, 1, 1])
        assert_equal(np.modf(b), ([0, 0, 0, 0, 0], b))
        assert_equal(np.frexp(b), ([-0.5, 0.625, 0.5, 0.5, 0.75], [2, 3, 1, 3, 2]))
        assert_equal(np.ldexp(b, [0, 1, 2, 4, 2]), [-2, 10, 4, 64, 12])
Ejemplo n.º 14
0
    def coord_to_px(self, x, y, latlon=False, rounded=True, check_valid=True):
        """ Convert x,y coordinates into pixel coordinates of raster.

        x,y may be either in native coordinate system of raster or lat/lon.

        Parameters:
            x : float, x coordinate to convert.
            y : float, y coordinate to convert.
            latlon : boolean, default False. Set as True if bounds in lat/lon.
            rounded : if set to True, return the rounded pixel coordinates, otherwise return the float values
            check_valid : bool, if set to True, will check that all pixels are in the valid range. 

        Returns:
            (x_pixel,y_pixel)

        """

        # Convert coordinates to map system if provided in lat/lon and image
        # is projected (rather than geographic)
        if latlon == True and self.proj != None:
            x, y = self.proj(x, y)

        # Shift to the centre of the pixel
        x = np.array(x - self.xres / 2)
        y = np.array(y - self.yres / 2)

        g0, g1, g2, g3, g4, g5 = self.trans
        if g2 == 0:
            xPixel = (x - g0) / float(g1)
            yPixel = (y - g3 - xPixel * g4) / float(g5)
        else:
            xPixel = (y * g2 - x * g5 + g0 * g5 - g2 * g3) / float(g2 * g4 - g1 * g5)
            yPixel = (x - g0 - xPixel * g1) / float(g2)

        # Round if required
        if rounded == True:
            xPixel = np.round(xPixel)
            yPixel = np.round(yPixel)

        if check_valid == False:
            return xPixel, yPixel

        # Check that pixel location is not outside image dimensions
        nx = self.ds.RasterXSize
        ny = self.ds.RasterYSize

        xPixel_new = np.copy(xPixel)
        yPixel_new = np.copy(yPixel)
        xPixel_new = np.fmin(xPixel_new, nx)
        yPixel_new = np.fmin(yPixel_new, ny)
        xPixel_new = np.fmax(xPixel_new, 0)
        yPixel_new = np.fmax(yPixel_new, 0)

        if np.any(xPixel_new != xPixel) or np.any(yPixel_new != yPixel):
            print ("Warning : some points are out of domain for file")

        return xPixel_new, yPixel_new
Ejemplo n.º 15
0
def compute_akt_change(pi3k_value, time_value, initial_values, mfs):
	"""Rules-
		If pi3k is high and time is high then positive_change_akt is high
		If pi3k is high1 and time is low then positive_change_akt is low
		If pi3k is low then positive_change_pi3k is low
		If pi3k is low and time is high then negative_change_akt is high
		If pi3k is low and time is low then negative_change_akt is low"""

	###Positive Change
	#Antecedent 1
	f = interp1d(initial_values[0][0], mfs[0][1])	
	a1_1 = f(pi3k_value) #pi3k_high[pi3k == pi3k_value]
	f = interp1d(initial_values[2], mfs[2][1])
	a1_2 = f(time_value) #time_high[time == time_value]

	a1 = min(a1_1, a1_2)
	c1 = np.fmin(a1, mfs[1][3]) #positive_change_akt is high

	#Antecedent 2
	f = interp1d(initial_values[0][0], mfs[0][6])
	a2_1 = f(pi3k_value) #pi3k_high[pi3k == pi3k_value]
	f = interp1d(initial_values[2], mfs[2][0])
	a2_2 = f(time_value) #time_low[time == time_value]

	a2 = min(a2_1, a2_2)
	c2 = np.fmin( a2, mfs[1][2]) #positive_change_akt is low

	c_com_positive = np.fmax(c1,c2)

	f = interp1d(initial_values[0][0], mfs[0][0])
	a3 = f(pi3k_value)
	c3 = np.fmin(a3, mfs[1][2])
	c_com_positive = np.fmax(c_com_positive, c3)
	pos_change = fuzz.defuzz( initial_values[1][1], c_com_positive, 'centroid') #initial_values[1][1] is positive_change_akt

	###Negative Change

	#Antecedent 3
	'''f = interp1d(initial_values[0][0], mfs[0][0])
	a3_1 = f(pi3k_value) #pi3k_low[pi3k == pi3k_value]
	a3_2 = a1_2 #time_high[time == time_value]

	a3 = min(a3_1, a3_2)
	c3 = np.fmin(a3, mfs[1][5]) #mfs[1][5] is negative_change_akt_high

	#Antecedent 4
	a4_1 = a3_1 #pi3k_low[pi3k == pi3k_value]
	a4_2 = a2_2 #time_low[time == time_value]

	a4 = min(a4_1, a4_2)
	c4 = np.fmin(a4, mfs[1][4]) #mfs[1][4] is negative_change_akt_low

	c_com_negative = np.fmax(c3, c4)
	neg_change = fuzz.defuzz(initial_values[1][2], c_com_negative, 'centroid') #initial_values[1][2] is negative_change_akt'''

	return pos_change 
Ejemplo n.º 16
0
def calaculate_akt(pi3k_mfs, akt_mfs, akt, pi3k_index):
	a1 = pi3k_mfs[0][pi3k_index]
	c1 = np.fmin(a1, akt_mfs[0])
	a2 = pi3k_mfs[1][pi3k_index]
	c2 = np.fmin(a2, akt_mfs[1])
	c_com = np.fmax(c1, c2)
	try:
		akt_val = fuzz.defuzz(akt, c_com, 'centroid')
	except AssertionError as e:
		akt_val = 0
	return akt_val
Ejemplo n.º 17
0
def calculate_egfr(time_mfs, egfr_mfs, egfr, time_index):
	a1 = time_mfs[0][time_index]
	c1 = np.fmin(a1, egfr_mfs[0])
	a2 = time_mfs[1][time_index]
	c2 = np.fmin(a2, egfr_mfs[1])
	c_com = np.fmax(c1, c2)
	try:
		egfr_val = fuzz.defuzz(egfr, c_com, 'centroid')
	except AssertionError as e:
		egfr_val = 0
	return egfr_val
Ejemplo n.º 18
0
def calculate_erk(raf_mfs, erk_mfs, erk, raf_index):
	a1 = raf_mfs[0][raf_index]
	c1 = np.fmin(a1, erk_mfs[0])
	a2 = raf_mfs[1][raf_index]
	c2 = np.fmin(a2, erk_mfs[1])
	c_com = np.fmax(c1, c2)
	try:
		erk_val = fuzz.defuzz(erk, c_com, 'centroid')
	except AssertionError as e:
		erk_val = 0
	return erk_val
Ejemplo n.º 19
0
def test_contrast():
    a = np.r_[0, 0, 0, 0.3, 0.7, 1, 0.9, 0]
    z = contrast(a, 1.8)

    # Legacy slower code which should produce identical result
    p = 1.8
    m = 0.5
    ymin = np.fmin(a, m)
    ymax = np.fmax(a, m)
    w = np.arange(len(a))
    wmax = w[ymax > m]
    wmin = w[ymax <= m]
    ymin = 2 ** (p - 1) * ymin ** p
    ymax = 1 - 2 ** (p - 1) * (1 - ymax) ** p
    ymin[wmax] = 0
    ymax[wmin] = 0

    assert_allclose(z, ymin + ymax)

    # Legacy slower code which should produce identical result
    p = 0.5
    m = 0.5
    z = contrast(a, 0.5)
    ymin = np.fmin(a, m)
    ymax = np.fmax(a, m)
    w = np.arange(len(a))
    wmax = w[ymax > m]
    wmin = w[ymax <= m]
    ymin = 2 ** (p - 1) * ymin ** p
    ymax = 1 - 2 ** (p - 1) * (1 - ymax) ** p
    ymin[wmax] = 0
    ymax[wmin] = 0

    assert_allclose(z, ymin + ymax)

    # Legacy slower code which should produce identical result
    p = 2.
    m = 0.5
    z = contrast(a, 2.)
    ymin = np.fmin(a, m)
    ymax = np.fmax(a, m)
    w = np.arange(len(a))
    wmax = w[ymax > m]
    wmin = w[ymax <= m]
    ymin = 2 ** (p - 1) * ymin ** p
    ymax = 1 - 2 ** (p - 1) * (1 - ymax) ** p
    ymin[wmax] = 0
    ymax[wmin] = 0

    assert_allclose(z, ymin + ymax)
Ejemplo n.º 20
0
def rule_actividad(value, graficar=False):

    # recibe los datos para poder seguir el proceso difuso para encontrar la pertenencia
    # retorna el valor al que pertenece en la clase segun la hora
    mf_actividad = generar_actividad(False)
    mf_calorico = generar_calorico(False)

    # se usa para encontrar los grados de pertenencia del valor, borrificacion
    actividad_nivel_rest = fuzz.interp_membership(mf_actividad['intensity'], mf_actividad['rest'], value)
    actividad_nivel_std = fuzz.interp_membership(mf_actividad['intensity'], mf_actividad['active'], value)
    actividad_nivel_work = fuzz.interp_membership(mf_actividad['intensity'], mf_actividad['workout'], value)

    # regla: si rest -> low
    rest_activation = np.fmin(actividad_nivel_rest, mf_calorico['low'])
    # regla: si active -> std
    active_activation = np.fmin(actividad_nivel_std, mf_calorico['standard'])
    # regla: si workout -> high
    workout_activation = np.fmin(actividad_nivel_work, mf_calorico['high'])

    # deborrificacion
    agregado = np.fmax(rest_activation, np.fmax(active_activation, workout_activation))
    caloric = fuzz.defuzz(mf_calorico['caloric'], agregado, 'centroid')


    # # graficar
    # if graficar:
    #     select_caloric = fuzz.interp_membership(mf_calorico['caloric'], agregado, caloric)
    #     caloric0 = np.zeros_like(mf_calorico['caloric'])
    #     fig, ax0 = plt.subplots(figsize=(8, 3))
    #
    #     ax0.plot(mf_calorico['caloric'], mf_calorico['low'], 'b', linewidth=0.5, linestyle='--', label='Low')
    #     ax0.plot(mf_calorico['caloric'], mf_calorico['standard'], 'g', linewidth=0.5, linestyle='--', label='Standard')
    #     ax0.plot(mf_calorico['caloric'], mf_calorico['high'], 'r', linewidth=0.5, linestyle='--', label='High')
    #     ax0.fill_between(mf_calorico['caloric'], caloric0, agregado, facecolor='Orange', alpha=0.7)
    #     ax0.plot([caloric, caloric], [0, select_caloric], 'k', linewidth=1.5, alpha=0.9)
    #     ax0.set_title('Dish Classification and Result (line)')
    #     ax0.legend()
    #     # Turn off top/right axes
    #     for ax in (ax0,):
    #         ax.spines['top'].set_visible(False)
    #         ax.spines['right'].set_visible(False)
    #         ax.get_xaxis().tick_bottom()
    #         ax.get_yaxis().tick_left()
    #
    #     plt.tight_layout()
    #     #fig.savefig('graphs/result_calorico.png', bbox_inches='tight')
    # 
    return caloric, "caloric"
Ejemplo n.º 21
0
def game_type(player, comp):
    """ A fuzzy algorithm to define the offensiveness and/or 
    defensiveness of the game. Determines how aggressive the fuzzy 
    player is"""

    score_diff = float(player-comp)
    ### Inputs ###
    # Input Variable Domain
    score = np.arange(-21, 21, 1)
    
    # Input membership functions
    score_ahead = fuzz.gaussmf(score, -21, 8.823)
    score_tied = fuzz.gaussmf(score, 0, 9.012)
    score_behind = fuzz.gaussmf(score, 21, 8.823)

    # Fuzzifying the current input
    def score_category(sc):
        score_cat_ahead = fuzz.interp_membership(score, score_ahead, sc)
        score_cat_tied = fuzz.interp_membership(score, score_tied, sc)
        score_cat_behind = fuzz.interp_membership(score, score_behind, sc)
        return dict(ahead = score_cat_ahead, tied = score_cat_tied, behind = score_cat_behind)

    ### Outputs ###
    # Output Variable Domain
    game = np.arange(0, 1, 1)

    # Output membership functions
    game_defensive = fuzz.gaussmf(game, 0, 0.162899)
    game_offensive = fuzz.gauss2mf(game, 0.30291, 0.090976, 1.31, 0.416)

    ### Rules ###
    current_score = score_category(score_diff)

    # Going to make this a hard opponent, so if the score is tied or 
    # if the human is winning, it will play offensively
    rule1 = current_score['ahead']
    rule2 = np.fmax(current_score['tied'], current_score['behind'])

    # Apply implication operator (Mamdami)
    imp1 = np.fmin(rule1, game_defensive)
    imp2 = np.fmin(rule2, game_offensive)

    # Aggregate outputs using max
    aggregate_membership = np.fmax(imp1, imp2)

    # Defuzzify using centroid and return the result
    result_game = fuzz.defuzz(game, aggregate_membership, 'centroid')
    return result_game
Ejemplo n.º 22
0
 def test_complex_nans(self):
     nan = np.nan
     for cnan in [complex(nan, 0), complex(0, nan), complex(nan, nan)]:
         arg1 = np.array([0, cnan, cnan], dtype=np.complex)
         arg2 = np.array([cnan, 0, cnan], dtype=np.complex)
         out = np.array([0, 0, nan], dtype=np.complex)
         assert_equal(np.fmin(arg1, arg2), out)
Ejemplo n.º 23
0
    def get_ry0_distance(self, mesh):
        """
        :param mesh:
            :class:`~openquake.hazardlib.geo.mesh.Mesh` of points to calculate
            Ry0-distance to.
        :returns:
            Numpy array of distances in km.

        See also :meth:`superclass method <.base.BaseSurface.get_ry0_distance>`
        for spec of input and result values.

        This is version specific to the planar surface doesn't make use of the
        mesh
        """
        dst1 = geodetic.distance_to_arc(self.top_left.longitude,
                                        self.top_left.latitude,
                                        (self.strike + 90.) % 360,
                                        mesh.lons, mesh.lats)

        dst2 = geodetic.distance_to_arc(self.top_right.longitude,
                                        self.top_right.latitude,
                                        (self.strike + 90.) % 360,
                                        mesh.lons, mesh.lats)
        # Find the points on the rupture

        # Get the shortest distance from the two lines
        idx = numpy.sign(dst1) == numpy.sign(dst2)
        dst = numpy.zeros_like(dst1)
        dst[idx] = numpy.fmin(numpy.abs(dst1[idx]), numpy.abs(dst2[idx]))
        return dst
Ejemplo n.º 24
0
def cartprod(x, y):
    """
    Cartesian product of two fuzzy membership vectors. Uses ``min()``.

    Parameters
    ----------
    x : 1D array or iterable
        First fuzzy membership vector, of length M.
    y : 1D array or iterable
        Second fuzzy membership vector, of length N.

    Returns
    -------
    z : 2D array
        Cartesian product of ``x`` and ``y``, of shape (M, N).

    """
    # Ensure rank-1 input
    x, y = np.asarray(x).ravel(), np.asarray(y).ravel()

    m, n = len(x), len(y)

    a = np.dot(np.atleast_2d(x).T, np.ones((1, n)))
    b = np.dot(np.ones((m, 1)), np.atleast_2d(y))

    return np.fmin(a, b)
def searchsortednearest(a,v):
    higher_inds = np.fmin(np.searchsorted(a,v), len(a)-1)
    lower_inds = np.fmax(higher_inds-1, 0)
    closer_inds = higher_inds
    lower_is_better = np.abs(a[higher_inds] - v) > np.abs(a[lower_inds] - v)
    closer_inds[lower_is_better] = lower_inds[lower_is_better]
    return closer_inds
Ejemplo n.º 26
0
def maxmin_composition(s, r):
    """
    The max-min composition ``t`` of two fuzzy relation matrices.

    Parameters
    ----------
    s : 2d array, (M, N)
        Fuzzy relation matrix #1.
    r : 2d array, (N, P)
        Fuzzy relation matrix #2.

    Returns
    -------
    T ; 2d array, (M, P)
        Max-min composition, defined by ``T = s o r``.

    """
    if s.ndim < 2:
        s = np.atleast_2d(s)
    if r.ndim < 2:
        r = np.atleast_2d(r).T
    m = s.shape[0]
    p = r.shape[1]
    t = np.zeros((m, p))

    for pp in range(p):
        for mm in range(m):
            t[mm, pp] = (np.fmin(s[mm, :], r[:, pp].T)).max()

    return t
Ejemplo n.º 27
0
def rateOne(file,results="./OverlapResults.csv", methord=slicescore.OverlapCoeff, template=template):
    if os.path.isfile(template):
        data1, header1 = nrrd.read(template)
    else:
        print 'Template file missing!'
        data1 = []
    if not data1==[]:
        ctemplate = xscore.xslice(data1)
        ztemplate = slicescore.zsampleslice(data1)
        ytemplate = slicescore.ysampleslice(data1)
        xtemplate = slicescore.xsampleslice(data1)
        del data1, header1
    r=np.float128(0.0)
    if os.path.isfile(file):
      print "testing:" + os.path.basename(file)
      data2, header2 = nrrd.read(file)
      calignment = xscore.xslice(data2)
      zalignment = slicescore.zsampleslice(data2)
      yalignment = slicescore.ysampleslice(data2)
      xalignment = slicescore.xsampleslice(data2)
      del data2, header2
      r = np.fmin(np.array([xscore.symTest(slicescore.OverlapCoeff,calignment),methord(ctemplate,calignment),methord(ztemplate,zalignment),methord(ytemplate,yalignment),methord(xtemplate,xalignment)]))
      if not results==None:
        with open(results, 'a') as csvfile:
          spamwriter = csv.writer(csvfile)
          spamwriter.writerow([path,r[-1][0],"[Symmetry,Diagonal,Zsample,Ysample,Xsample,Final]score",r[-1][1],r[-1][2],r[-1][3],r[-1][4],r[-1][5],min(r[-1][1:])])
      del xalignment
    return r
Ejemplo n.º 28
0
def deblend(image, peaks, interpolate=False, force_interpolate=False):
    """ Quick and dirty deblender.

    Args
    ----
    @param image        A numpy array representing an image of a blend.
    @param peaks        A list of tuples representing the peak positions of objects in the blend.
    @param interpolate  If at least one component of rot_center is not a half-integer, use GalSim
                        to rotate the image.  This currently doesn't work very well!!!
    @param force_interpolate   Use GalSim to rotate the image, even if rot_center components are
                               half-integer and rotation via numpy array operations is possible.
                               This currently doesn't work very well!!!
    
    @returns templates, template_fractions, children
    
    """
    work_image = image+1.e-20

    # Step 1: Make symmetric templates
    templates = [np.fmin(work_image, rotate(work_image, peak,
                                            interpolate=interpolate,
                                            force_interpolate=force_interpolate))
                 for peak in peaks]

    # Step 2: Calculate relative contribution of each template
    template_sum = np.sum(templates, axis=0)
    template_fractions = [template/template_sum * (template_sum != 0) for template in templates]

    # Step 3: Calculate deblended children
    children = [t * image for t in template_fractions]

    return templates, template_fractions, children
Ejemplo n.º 29
0
def create_visualization_for_pw_single_image(edges, edge_weights, imsz):
    """
    Create visualization for pairwise potentials of a single image, for grid
    graph only.

    The visualization is to transfer pairwise potentials into an image the
    same size as the original image. The process is simple, for each pixel, 
    look at the two edges coming from the north and west then take the maximum
    of the negative edge weights. Then for each pixel we get a number related 
    to the likelihood of an edge at that point, this is used for visualization.

    edges: E*2 edge matrix, E is the number of edges
    edge_weights: E-dimensional vector for edge weights, (edges, edge_weights)
        are generated by one of the get_pw functions
    imsz: size of the image, (H,W)

    return: a visualization image of size H*W
    """
    H, W = imsz

    pw = np.ones(imsz, dtype=np.single) * edge_weights.max()
    pw[:, 1:W] = edge_weights[: H * (W - 1)].reshape(H, W - 1)
    pw[1:H, :] = np.fmin(edge_weights[H * (W - 1) :].reshape(W, H - 1).T, pw[1:H, :])

    return -pw
Ejemplo n.º 30
0
    def get_ry0_distance(self, mesh):
        """
        :param mesh:
            :class:`~openquake.hazardlib.geo.mesh.Mesh` of points to calculate
            Ry0-distance to.
        :returns:
            Numpy array of distances in km.

        See also :meth:`superclass method <.base.BaseSurface.get_ry0_distance>`
        for spec of input and result values.

        This method uses an average strike direction to compute ry0.
        """
        # This computes ry0 by using an average strike direction
        top_edge = self.get_mesh()[0:1]
        mean_strike = self.get_strike()

        dst1 = geodetic.distance_to_arc(top_edge.lons[0, 0],
                                        top_edge.lats[0, 0],
                                        (mean_strike + 90.) % 360,
                                        mesh.lons, mesh.lats)

        dst2 = geodetic.distance_to_arc(top_edge.lons[0, -1],
                                        top_edge.lats[0, -1],
                                        (mean_strike + 90.) % 360,
                                        mesh.lons, mesh.lats)
        # Find the points on the rupture

        # Get the shortest distance from the two lines
        idx = numpy.sign(dst1) == numpy.sign(dst2)
        dst = numpy.zeros_like(dst1)
        dst[idx] = numpy.fmin(numpy.abs(dst1[idx]), numpy.abs(dst2[idx]))

        return dst
Ejemplo n.º 31
0
    print "On a scale of 0 to 10 (10 being nearest), how close is the workplace?"
    dist = float(raw_input())
    dist_level_lo = fuzz.interp_membership(x_dist, dist_lo, dist)
    dist_level_md = fuzz.interp_membership(x_dist, dist_md, dist)
    dist_level_hi = fuzz.interp_membership(x_dist, dist_hi, dist)

    part1 = min(sal_level_hi, min(int_level_hi, dist_level_hi))
    part2 = min(sal_level_hi, min(int_level_hi, dist_level_md))
    part3 = min(sal_level_hi, min(int_level_hi, dist_level_lo))
    part4 = min(sal_level_md, min(int_level_hi, dist_level_hi))
    part5 = min(sal_level_md, min(int_level_hi, dist_level_md))
    part6 = min(sal_level_lo, min(int_level_hi, dist_level_hi))

    active_rule1 = max(part1, part2, part3, part4, part5, part6)
    score_activation_hi = np.fmin(active_rule1, score_hi)

    part1 = min(sal_level_lo, min(int_level_hi, dist_level_md))
    part2 = min(sal_level_md, min(int_level_md, dist_level_hi))
    part3 = min(sal_level_hi, min(int_level_md, dist_level_hi))
    part4 = min(sal_level_hi, min(int_level_md, dist_level_md))
    part5 = min(sal_level_hi, min(int_level_lo, dist_level_hi))
    part6 = min(sal_level_md, min(int_level_hi, dist_level_lo))
    part7 = min(sal_level_md, min(int_level_md, dist_level_md))
    part8 = min(sal_level_md, min(int_level_md, dist_level_lo))
    part9 = min(sal_level_lo, min(int_level_hi, dist_level_lo))

    active_rule2 = max(part1, part2, part3, part4, part5, part6, part7, part8,
                       part9)
    score_activation_md = np.fmin(active_rule2, score_md)
Ejemplo n.º 32
0
 lambda c1, c2: c1.bitwiseOR(c2),
 "bitwise_xor":
 lambda c1, c2: c1.bitwiseXOR(c2),
 "copysign":
 pandas_udf(lambda s1, s2: np.copysign(s1, s2),
            DoubleType()),  # type: ignore
 "float_power":
 pandas_udf(  # type: ignore
     lambda s1, s2: np.float_power(s1, s2), DoubleType()),
 "floor_divide":
 pandas_udf(  # type: ignore
     lambda s1, s2: np.floor_divide(s1, s2), DoubleType()),
 "fmax":
 pandas_udf(lambda s1, s2: np.fmax(s1, s2), DoubleType()),  # type: ignore
 "fmin":
 pandas_udf(lambda s1, s2: np.fmin(s1, s2), DoubleType()),  # type: ignore
 "fmod":
 pandas_udf(lambda s1, s2: np.fmod(s1, s2), DoubleType()),  # type: ignore
 "gcd":
 pandas_udf(lambda s1, s2: np.gcd(s1, s2), DoubleType()),  # type: ignore
 "heaviside":
 pandas_udf(lambda s1, s2: np.heaviside(s1, s2),
            DoubleType()),  # type: ignore
 "hypot":
 F.hypot,
 "lcm":
 pandas_udf(lambda s1, s2: np.lcm(s1, s2), DoubleType()),  # type: ignore
 "ldexp":
 pandas_udf(lambda s1, s2: np.ldexp(s1, s2), DoubleType()),  # type: ignore
 "left_shift":
 pandas_udf(lambda s1, s2: np.left_shift(s1, s2),
Ejemplo n.º 33
0
def ineichen(apparent_zenith,
             airmass_absolute,
             linke_turbidity,
             altitude=0,
             dni_extra=1364.):
    '''
    Determine clear sky GHI, DNI, and DHI from Ineichen/Perez model.

    Implements the Ineichen and Perez clear sky model for global
    horizontal irradiance (GHI), direct normal irradiance (DNI), and
    calculates the clear-sky diffuse horizontal (DHI) component as the
    difference between GHI and DNI*cos(zenith) as presented in [1, 2]. A
    report on clear sky models found the Ineichen/Perez model to have
    excellent performance with a minimal input data set [3].

    Default values for monthly Linke turbidity provided by SoDa [4, 5].

    Parameters
    -----------
    apparent_zenith : numeric
        Refraction corrected solar zenith angle in degrees.

    airmass_absolute : numeric
        Pressure corrected airmass.

    linke_turbidity : numeric
        Linke Turbidity.

    altitude : numeric, default 0
        Altitude above sea level in meters.

    dni_extra : numeric, default 1364
        Extraterrestrial irradiance. The units of ``dni_extra``
        determine the units of the output.

    Returns
    -------
    clearsky : DataFrame (if Series input) or OrderedDict of arrays
        DataFrame/OrderedDict contains the columns/keys
        ``'dhi', 'dni', 'ghi'``.

    See also
    --------
    lookup_linke_turbidity
    pvlib.location.Location.get_clearsky

    References
    ----------
    [1] P. Ineichen and R. Perez, "A New airmass independent formulation for
        the Linke turbidity coefficient", Solar Energy, vol 73, pp. 151-157,
        2002.

    [2] R. Perez et. al., "A New Operational Model for Satellite-Derived
        Irradiances: Description and Validation", Solar Energy, vol 73, pp.
        307-317, 2002.

    [3] M. Reno, C. Hansen, and J. Stein, "Global Horizontal Irradiance Clear
        Sky Models: Implementation and Analysis", Sandia National
        Laboratories, SAND2012-2389, 2012.

    [4] http://www.soda-is.com/eng/services/climat_free_eng.php#c5 (obtained
        July 17, 2012).

    [5] J. Remund, et. al., "Worldwide Linke Turbidity Information", Proc.
        ISES Solar World Congress, June 2003. Goteborg, Sweden.
    '''

    # Dan's note on the TL correction: By my reading of the publication
    # on pages 151-157, Ineichen and Perez introduce (among other
    # things) three things. 1) Beam model in eqn. 8, 2) new turbidity
    # factor in eqn 9 and appendix A, and 3) Global horizontal model in
    # eqn. 11. They do NOT appear to use the new turbidity factor (item
    # 2 above) in either the beam or GHI models. The phrasing of
    # appendix A seems as if there are two separate corrections, the
    # first correction is used to correct the beam/GHI models, and the
    # second correction is used to correct the revised turibidity
    # factor. In my estimation, there is no need to correct the
    # turbidity factor used in the beam/GHI models.

    # Create the corrected TL for TL < 2
    # TLcorr = TL;
    # TLcorr(TL < 2) = TLcorr(TL < 2) - 0.25 .* (2-TLcorr(TL < 2)) .^ (0.5);

    # This equation is found in Solar Energy 73, pg 311. Full ref: Perez
    # et. al., Vol. 73, pp. 307-317 (2002). It is slightly different
    # than the equation given in Solar Energy 73, pg 156. We used the
    # equation from pg 311 because of the existence of known typos in
    # the pg 156 publication (notably the fh2-(TL-1) should be fh2 *
    # (TL-1)).

    # The NaN handling is a little subtle. The AM input is likely to
    # have NaNs that we'll want to map to 0s in the output. However, we
    # want NaNs in other inputs to propagate through to the output. This
    # is accomplished by judicious use and placement of np.maximum,
    # np.minimum, and np.fmax

    # use max so that nighttime values will result in 0s instead of
    # negatives. propagates nans.
    cos_zenith = np.maximum(tools.cosd(apparent_zenith), 0)

    tl = linke_turbidity

    fh1 = np.exp(-altitude / 8000.)
    fh2 = np.exp(-altitude / 1250.)
    cg1 = 5.09e-05 * altitude + 0.868
    cg2 = 3.92e-05 * altitude + 0.0387

    ghi = (np.exp(-cg2 * airmass_absolute * (fh1 + fh2 * (tl - 1))) *
           np.exp(0.01 * airmass_absolute**1.8))
    # use fmax to map airmass nans to 0s. multiply and divide by tl to
    # reinsert tl nans
    ghi = cg1 * dni_extra * cos_zenith * tl / tl * np.fmax(ghi, 0)

    # BncI = "normal beam clear sky radiation"
    b = 0.664 + 0.163 / fh1
    bnci = b * np.exp(-0.09 * airmass_absolute * (tl - 1))
    bnci = dni_extra * np.fmax(bnci, 0)

    # "empirical correction" SE 73, 157 & SE 73, 312.
    bnci_2 = ((1 - (0.1 - 0.2 * np.exp(-tl)) / (0.1 + 0.882 / fh1)) /
              cos_zenith)
    bnci_2 = ghi * np.fmin(np.fmax(bnci_2, 0), 1e20)

    dni = np.minimum(bnci, bnci_2)

    dhi = ghi - dni * cos_zenith

    irrads = OrderedDict()
    irrads['ghi'] = ghi
    irrads['dni'] = dni
    irrads['dhi'] = dhi

    if isinstance(dni, pd.Series):
        irrads = pd.DataFrame.from_dict(irrads)

    return irrads
Ejemplo n.º 34
0
def ci_conservative_generic(X,
                            K,
                            theta_grid,
                            alpha_level,
                            log_likelihood,
                            sample,
                            t,
                            verbose=False):
    L = len(theta_grid)

    # Generate samples from the mixture proposal distribution
    Y = []
    for k in range(K):
        l_k = np.random.randint(L)
        theta_k = theta_grid[l_k]
        Y.append(sample(theta_k))

    # Test statistic at observation
    t_X = t(X)

    # Statistics for the samples from the proposal distribution only
    # need to be calculated once...
    t_Y = np.zeros(K + 1)
    for k in range(K):
        t_Y[k] = t(Y[k])
    I_t_Y_plus = t_Y >= t_X
    I_t_Y_plus[K] = True
    I_t_Y_minus = -t_Y >= -t_X
    I_t_Y_minus[K] = True

    # Probabilities under each component of the proposal distribution
    # only need to be calculated once...
    log_Q_X = np.empty(L)
    log_Q_Y = np.empty((L, K))
    for l in range(L):
        theta_l = theta_grid[l]

        log_Q_X[l] = log_likelihood(X, theta_l)
        for k in range(K):
            log_Q_Y[l, k] = log_likelihood(Y[k], theta_l)
        if verbose:
            print '%.2f: %.2g, %.2g' % \
              (theta_l, np.exp(log_Q_X[l]), np.exp(log_Q_Y[l].max()))
    log_Q_sum_X = logsumexp(log_Q_X)
    log_Q_sum_Y = np.empty(K)
    for k in range(K):
        log_Q_sum_Y[k] = logsumexp(log_Q_Y[:, k])

    # Step over the grid, calculating approximate p-values
    log_p_plus = np.empty(L)
    log_p_minus = np.empty(L)
    for l in range(L):
        theta_l = theta_grid[l]
        log_w_l = np.empty(K + 1)

        # X contribution
        log_w_l[K] = (theta_l * t_X) - log_Q_sum_X

        # Y contribution
        for k in range(K):
            log_w_l[k] = (theta_l * t_Y[k]) - log_Q_sum_Y[k]

        log_p_num_plus = logsumexp(log_w_l[I_t_Y_plus])
        log_p_num_minus = logsumexp(log_w_l[I_t_Y_minus])
        log_p_denom = logsumexp(log_w_l)

        if verbose:
            print '%.2f: %.2g (%.2g, %.2g)' % \
              (theta_l, log_w_l[K], log_w_l[0:K].min(), log_w_l[0:K].max())

        log_p_plus[l] = log_p_num_plus - log_p_denom
        log_p_minus[l] = log_p_num_minus - log_p_denom

    # p_pm = min(1, 2 * min(p_plus, p_minus))
    log_p_pm = np.fmin(0, np.log(2) + np.fmin(log_p_plus, log_p_minus))
    return invert_test(theta_grid, log_p_pm, np.log(alpha_level))
import numpy as np

x = 1.0		#define a float
y = 2.0		#define another float

#exponents and logarithms
print(np.exp(x))		#e^x
print(np.log(x))		#ln x
print(np.log10(x))		#log_10 x
print(np.log2(x))		#log_2 x

#min/max/misc
print(np.fabs(x))		#absolute value as a float
print(np.fmin(x,y))		#min of x and y
print(np.fmax(x,y))		#max of x and y

#populate arrays
n = 100							#define an int
z = np.arange(n,dtype=float)	#getan array [0.0,n-1.]
z *= 2.0*np.pi /float(n-1)		#z = [0,2*pi]
sin_z = np.sin(z)				#get an array sin(z)

#interpolation
print(np.interp(0.75,z,sin_z))	#interpolate sin(0.75)
print(np.sin(0.75))
Ejemplo n.º 36
0
zb_c_y10_0 = 0.2 + 0.1 * np.arange(10)
zb_c_y10_1 = 0.2 + 0.1 * (np.arange(10) + 1)
sz_c_y10 = 0.03 * (1 + 0.5 * (zb_c_y10_0 + zb_c_y10_1))
zbz_y10 = [zb_c_y10_0[0]]
bz_y10 = [0.95 / ccl.growth_factor(cosmo, 1. / (1 + zb_c_y10_0[0]))]
mask_y10 = [0]
lmax_c_y10 = []
for z in 0.5 * (zb_c_y10_0 + zb_c_y10_1):
    bz_y10.append(0.95 / ccl.growth_factor(cosmo, 1. / (1 + z)))
    zbz_y10.append(z)
    mask_y10.append(0)
    #mask_y10.append(1)
    lmax_c_y10.append(
        np.fmin(
            0.75 * 0.6727 * ccl.comoving_radial_distance(cosmo, 1. / (1 + z)),
            5400))
bz_y10.append(0.95 / ccl.growth_factor(cosmo, 1. / (1 + 3.4)))
zbz_y10.append(3.4)
mask_y10.append(0)
bz_y10 = np.array(bz_y10)
zbz_y10 = np.array(zbz_y10)
mask_y10 = np.array(mask_y10)
lmax_c_y10 = np.array(lmax_c_y10)
np.savetxt("bz_clustering_y10.txt",
           np.transpose([zbz_y10, bz_y10, mask_y10]),
           fmt='%lf %lf %d -1')
np.savetxt("bins_clustering_y10.txt",
           np.transpose([zb_c_y10_0, zb_c_y10_1, sz_c_y10, lmax_c_y10]),
           fmt='%.5lf %.5lf %.5lf 0 0 %d',
           header=' [0]z0 [1]zf [2]sigma_z [3]marg_sz [4]marg_bz [5]lmax')
 def set_brake(self, input_brake):
     # Clamp the steering command to valid bounds
     brake = np.fmax(np.fmin(input_brake, 1.0), 0.0)
     self._set_brake = brake
    def update_controls(self):
        ######################################################
        # RETRIEVE SIMULATOR FEEDBACK
        ######################################################
        x = self._current_x
        y = self._current_y
        yaw = self._current_yaw
        v = self._current_speed
        self.update_desired_speed()
        v_desired = self._desired_speed
        t = self._current_timestamp
        waypoints = self._waypoints
        throttle_output = 0
        steer_output = 0
        brake_output = 0

        self.vars.create_var('kp', 0.50)
        self.vars.create_var('ki', 0.30)
        self.vars.create_var('integrator_min', 0.0)
        self.vars.create_var('integrator_max', 10.0)
        self.vars.create_var('kd', 0.13)
        self.vars.create_var('kp_heading', 8.00)
        self.vars.create_var('k_speed_crosstrack', 0.00)
        self.vars.create_var('cross_track_deadband', 0.01)
        self.vars.create_var('x_prev', 0.0)
        self.vars.create_var('y_prev', 0.0)
        self.vars.create_var('yaw_prev', 0.0)
        self.vars.create_var('v_prev', 0.0)
        self.vars.create_var('t_prev', 0.0)
        self.vars.create_var('v_error', 0.0)
        self.vars.create_var('v_error_prev', 0.0)
        self.vars.create_var('v_error_integral', 0.0)

        # Skip the first frame to store previous values properly
        if self._start_control_loop:

            self.vars.v_error = v_desired - v
            self.vars.v_error_integral += self.vars.v_error * \
                                          (t - self.vars.t_prev)
            v_error_rate_of_change      = (self.vars.v_error - self.vars.v_error_prev) /\
                                          (t - self.vars.t_prev)

            # cap the integrator sum to a min/max
            self.vars.v_error_integral = \
                    np.fmax(np.fmin(self.vars.v_error_integral,
                                    self.vars.integrator_max),
                            self.vars.integrator_min)

            throttle_output = self.vars.kp * self.vars.v_error +\
                              self.vars.ki * self.vars.v_error_integral +\
                              self.vars.kd * v_error_rate_of_change

            # Find cross track error (assume point with closest distance)
            crosstrack_error = float("inf")
            crosstrack_vector = np.array([float("inf"), float("inf")])

            ce_idx = self.get_lookahead_index(self._lookahead_distance)
            crosstrack_vector = np.array([waypoints[ce_idx][0] - \
                                         x - self._lookahead_distance*np.cos(yaw),
                                          waypoints[ce_idx][1] - \
                                         y - self._lookahead_distance*np.sin(yaw)])
            crosstrack_error = np.linalg.norm(crosstrack_vector)

            # set deadband to reduce oscillations
            print(crosstrack_error)
            if crosstrack_error < self.vars.cross_track_deadband:
                crosstrack_error = 0.0

            # Compute the sign of the crosstrack error
            crosstrack_heading = np.arctan2(crosstrack_vector[1],
                                            crosstrack_vector[0])
            crosstrack_heading_error = crosstrack_heading - yaw
            crosstrack_heading_error = \
                    (crosstrack_heading_error + self._pi) % \
                    self._2pi - self._pi

            crosstrack_sign = np.sign(crosstrack_heading_error)

            # Compute heading relative to trajectory (heading error)
            # First ensure that we are not at the last index. If we are,
            # flip back to the first index (loop the waypoints)
            if ce_idx < len(waypoints) - 1:
                vect_wp0_to_wp1 = np.array([
                    waypoints[ce_idx + 1][0] - waypoints[ce_idx][0],
                    waypoints[ce_idx + 1][1] - waypoints[ce_idx][1]
                ])
                trajectory_heading = np.arctan2(vect_wp0_to_wp1[1],
                                                vect_wp0_to_wp1[0])
            else:
                vect_wp0_to_wp1 = np.array([
                    waypoints[0][0] - waypoints[-1][0],
                    waypoints[0][1] - waypoints[-1][1]
                ])
                trajectory_heading = np.arctan2(vect_wp0_to_wp1[1],
                                                vect_wp0_to_wp1[0])

            heading_error = trajectory_heading - yaw
            heading_error = \
                    (heading_error + self._pi) % self._2pi - self._pi

            # Compute steering command based on error
            steer_output = heading_error + \
                    np.arctan(self.vars.kp_heading * \
                              crosstrack_sign * \
                              crosstrack_error / \
                              (v + self.vars.k_speed_crosstrack))

            ######################################################
            # SET CONTROLS OUTPUT
            ######################################################
            self.set_throttle(throttle_output)  # in percent (0 to 1)
            self.set_steer(steer_output)  # in rad (-1.22 to 1.22)
            self.set_brake(brake_output)  # in percent (0 to 1)

        self.vars.x_prev = x
        self.vars.y_prev = y
        self.vars.yaw_prev = yaw
        self.vars.v_prev = v
        self.vars.v_error_prev = self.vars.v_error
        self.vars.t_prev = t
 def set_throttle(self, input_throttle):
     # Clamp the throttle command to valid bounds
     throttle = np.fmax(np.fmin(input_throttle, 1.0), 0.0)
     self._set_throttle = throttle
Ejemplo n.º 40
0
 def test_float_nans(self):
     nan = np.nan
     arg1 = np.array([0, nan, nan])
     arg2 = np.array([nan, 0, nan])
     out = np.array([0, 0, nan])
     assert_equal(np.fmin(arg1, arg2), out)
Ejemplo n.º 41
0
def fuzzy_sub(x, a, y, b):
    """
    Subtracts fuzzy set ``b`` from fuzzy set ``a``.

    Parameters
    ----------
    x : 1d array, length N
        Universe variable for fuzzy set ``a``.
    A : 1d array, length N
        Fuzzy set for universe ``x``.
    y : 1d array, length M
        Universe variable for fuzzy set ``b``.
    b : 1d array, length M
        Fuzzy set for universe ``y``.

    Returns
    -------
    z : 1d array
        Output variable.
    mfz : 1d array
        Fuzzy membership set for variable z.

    Notes
    -----
    Uses Zadeh's Extension Principle from Ross, Fuzzy Logic w/Engineering
    Applications, (2010), pp.414, Eq. 12.17.

    If these results are unexpected and your membership functions are convex,
    consider trying the ``skfuzzy.dsw_*`` functions for fuzzy mathematics
    using interval arithmetic via the restricted Dong, Shah, and Wong method.

    """
    # a and x, and b and y, are formed into (MxN) matrices.  The former has
    # identical rows; the latter identical identical columns.
    n = len(b)
    aa = np.dot(np.atleast_2d(a).T, np.ones((1, n)))
    x = np.dot(np.atleast_2d(x).T, np.ones((1, n)))
    m = len(a)
    bb = np.dot(np.ones((m, 1)), np.atleast_2d(b))
    y = np.dot(np.ones((m, 1)), np.atleast_2d(y))

    # Subtract universes
    zz = (x - y).ravel()
    zz_index = np.argsort(zz)
    zz = np.sort(zz)

    # Array min() operation
    c = np.fmin(aa, bb).ravel()
    c = c[zz_index]

    # Initialize loop
    z, mfz = np.empty(0), np.empty(0)
    idx = 0

    for i in range(len(c)):
        index = np.nonzero(zz == zz[idx])[0]
        z = np.hstack((z, zz[idx]))
        mfz = np.hstack((mfz, c[index].max()))
        if zz[idx] == zz.max():
            break
        idx = index.max() + 1

    return z, mfz
Ejemplo n.º 42
0
    def generate_three_dim_multi_type2(self,
                                       num_data,
                                       max_vel,
                                       min_vel,
                                       num_step,
                                       motion_type,
                                       test=False,
                                       visualize=False):
        """sample discretized motions and corresponding place pairs"""
        vel_idx = None
        if not test and motion_type == 'discrete':
            velocity = generate_vel_list_3d(max_vel)
            num_vel = len(velocity)
            if pow(num_vel, num_step) < num_data:
                vel_list = np.asarray(
                    list(itertools.product(np.arange(num_vel),
                                           repeat=num_step)))
                num_vel_list = len(vel_list)

                div, rem = num_data // num_vel_list, num_data % num_vel_list
                vel_idx = np.vstack(
                    (np.tile(vel_list,
                             [div, 1]), vel_list[np.random.choice(num_vel_list,
                                                                  size=rem)]))
                np.random.shuffle(vel_idx)
            else:
                vel_idx = np.random.choice(num_vel, size=[num_data, num_step])

            vel_grid = np.take(velocity, vel_idx, axis=0)
            vel = vel_grid * self.interval_length

            vel_grid_cumsum = np.cumsum(vel_grid, axis=1)
            mu_max = np.fmin(
                self.num_interval,
                np.min(self.num_interval - vel_grid_cumsum, axis=1))
            mu_min = np.fmax(0, np.max(-vel_grid_cumsum, axis=1))
            mu_start = np.expand_dims(np.random.random(size=(num_data, 2)) *
                                      (mu_max - 1 - mu_min) + mu_min,
                                      axis=1)
            # mu_start = np.random.sample(size=[num_data, 2])
            # mu_start = np.expand_dims(np.round(mu_start * (mu_max - mu_min) + mu_min - 0.5), axis=1)
            mu_seq = np.concatenate((mu_start, mu_start + vel_grid_cumsum),
                                    axis=1)
        elif not test:
            if self.shape == "square":
                num_data_sample = num_data
            else:
                raise NotImplementedError

            #theta = np.random.random(size=(num_data_sample, num_step)) * 2 * np.pi - np.pi
            #length = np.sqrt(np.random.random(size=(num_data_sample, num_step))) * (max_vel - min_vel) + min_vel
            #x = length * np.cos(theta)
            #y = length * np.sin(theta)
            #vel_seq = np.concatenate((np.expand_dims(x, axis=-1), np.expand_dims(y, axis=-1)), axis=-1)

            x1 = np.random.standard_normal(size=(num_data_sample, num_step))
            y1 = np.random.standard_normal(size=(num_data_sample, num_step))
            z1 = np.random.standard_normal(size=(num_data_sample, num_step))
            v = np.sqrt(x1**2 + y1**2 + z1**2)
            length = np.cbrt(np.random.random(size=(
                num_data_sample, num_step))) * (max_vel - min_vel) + min_vel

            x = length * x1 / v
            y = length * y1 / v
            z = length * z1 / v
            vel_seq = np.concatenate(
                (np.expand_dims(x, axis=-1), np.expand_dims(
                    y, axis=-1), np.expand_dims(z, axis=-1)),
                axis=-1)

            # from matplotlib import pyplot
            # from mpl_toolkits.mplot3d import Axes3D
            # fig = pyplot.figure()
            # ax = Axes3D(fig)
            # ax.scatter(x[:30000], y[0:30000], z[0:30000])
            # pyplot.show()

            vel_seq_cumsum = np.cumsum(vel_seq, axis=1)
            mu_max = np.fmin(
                self.num_interval - 1,
                np.min(self.num_interval - 1 - vel_seq_cumsum, axis=1))
            mu_min = np.fmax(0, np.max(-vel_seq_cumsum, axis=1))
            start = np.random.random(size=(num_data_sample,
                                           3)) * (mu_max - mu_min) + mu_min
            start = np.expand_dims(start, axis=1)

            mu_seq = np.concatenate((start, start + vel_seq), axis=1)
            vel = vel_seq * self.interval_length
            if self.shape == "circle":
                mu_seq_len = mu_seq * self.interval_length
                select_idx = np.sqrt((mu_seq_len[:, :, 0] - 0.5)**2 +
                                     (mu_seq_len[:, :, 1] - 0.5)**2) > 0.5
                select_idx = np.where(np.sum(select_idx, axis=1) == 0)[0]
                mu_seq = mu_seq[select_idx[:num_data]]
                vel = vel[select_idx[:num_data]]
            elif self.shape == "triangle":
                mu_seq_len = mu_seq * self.interval_length
                x, y = mu_seq_len[:, :, 0], mu_seq_len[:, :, 1]
                select_idx = (x + 2 * y > 1) * (-x + 2 * y < 1)
                select_idx = np.where(
                    np.sum(select_idx, axis=1) == num_step + 1)[0]
                mu_seq = mu_seq[select_idx[:num_data]]
                vel = vel[select_idx[:num_data]]
        else:
            velocity = generate_vel_list_3d(max_vel, min_vel)
            num_vel = len(velocity)
            if visualize:
                mu_start = np.reshape([20, 20, 20], newshape=(1, 1, 1, 3))
                vel_pool = np.where((velocity[:, 0] >= -1)
                                    & (velocity[:, 1] >= -1)
                                    & (velocity[:, 2] >= -1))
                vel_idx = np.random.choice(vel_pool[0],
                                           size=[num_data * 10, num_step])

                vel_grid_cumsum = np.cumsum(np.take(velocity, vel_idx, axis=0),
                                            axis=1)
                mu_seq = np.concatenate(
                    (np.tile(mu_start, [num_data * 10, 1, 1, 1]),
                     vel_grid_cumsum + mu_start),
                    axis=1)
                mu_seq_new, vel_idx_new = [], []
                for i in range(len(mu_seq)):
                    mu_seq_sub = mu_seq[i]
                    if len(np.unique(mu_seq_sub, axis=0)) == len(mu_seq_sub):
                        mu_seq_new.append(mu_seq[i])
                        vel_idx_new.append(vel_idx[i])
                mu_seq, vel_idx = np.stack(mu_seq_new,
                                           axis=0), np.stack(vel_idx_new,
                                                             axis=0)
                mu_seq_rs = np.reshape(mu_seq, [-1, (num_step + 1) * 2])
                select_idx = np.where(
                    np.sum(mu_seq_rs >= self.num_interval, axis=1) ==
                    0)[0][:num_data]
                vel_idx = vel_idx[select_idx]
                mu_seq = mu_seq[select_idx]
                vel = np.take(velocity, vel_idx, axis=0) * self.interval_length
            else:
                vel_idx = np.random.choice(num_vel,
                                           size=[num_data * 20, num_step])
                vel_grid_cumsum = np.cumsum(np.take(velocity, vel_idx, axis=0),
                                            axis=1)
                mu_max = np.fmin(
                    self.num_interval,
                    np.min(self.num_interval - vel_grid_cumsum, axis=1))
                mu_min = np.fmax(0, np.max(-vel_grid_cumsum, axis=1))

                select_idx = np.where(
                    np.sum(mu_max <= mu_min, axis=1) == 0)[0][:num_data]
                vel_idx, vel_grid_cumsum = vel_idx[
                    select_idx], vel_grid_cumsum[select_idx]
                vel_grid = np.take(velocity, vel_idx, axis=0)
                mu_max, mu_min = mu_max[select_idx], mu_min[select_idx]
                mu_start = np.random.sample(size=[num_data, 3])
                mu_start = np.expand_dims(
                    np.round(mu_start * (mu_max - mu_min) + mu_min - 0.5),
                    axis=1)
                mu_seq = np.concatenate((mu_start, mu_start + vel_grid_cumsum),
                                        axis=1)
                vel = vel_grid * self.interval_length

        # sns.distplot(vel, rug=True, hist=False)
        # plt.show()
        assert len(mu_seq) == num_data
        place_seq = {'seq': mu_seq, 'vel': vel, 'vel_idx': vel_idx}
        return place_seq
Ejemplo n.º 43
0
 def K(self, X, X2, target):
     if X2 is None:
         X2 = X
     target += self.variance * np.fmin(X, X2.T)
Ejemplo n.º 44
0
ax1.plot(x_serv, serv_lo, 'b', linewidth=1.5, label='Poor')
ax1.plot(x_serv, serv_md, 'g', linewidth=1.5, label='Acceptable')
ax1.plot(x_serv, serv_hi, 'r', linewidth=1.5, label='Amazing')
ax1.set_title('serve quality')
ax1.legend()

ax2.plot(x_tip, tip_lo, 'b', linewidth=1.5, label='Low')
ax2.plot(x_tip, tip_md, 'g', linewidth=1.5, label='Medium')
ax2.plot(x_tip, tip_hi, 'r', linewidth=1.5, label='High')
ax2.set_title('tip')
ax2.legend()

#应用规则1:服务差或食物质量差->小费低
active_rule1 = np.fmax(qual_level_lo, serv_level_lo)
tip_activation_lo = np.fmin(active_rule1, tip_lo)

#应用规则2:如果服务可以接受,那么小费将是中等
tip_activation_md = np.fmin(serv_level_md, tip_md)

#应用规则3:如果食物质量很好或服务令人满意->小费高
active_rule3 = np.fmax(qual_level_hi, serv_level_hi)
tip_activation_hi = np.fmin(active_rule3, tip_hi)
tip0 = np.zeros_like(x_tip)

#可视化应用规则
fig, ax0 = plt.subplots(figsize=(8, 3))
ax0.fill_between(x_tip, tip0, tip_activation_lo, facecolor='b', alpha=0.7)
ax0.plot(
    x_tip,
    tip_lo,
Ejemplo n.º 45
0
 def _feed_forward_lateral(self):
     temp = self._l * self._waypoints[self._closest_idx, -1]
     if np.abs(temp) >= 1.:
         temp = np.sign(temp)
     return np.fmax(np.fmin(np.arcsin(temp), self._sat_lat_max), self._sat_lat_min) # From -pi/2 to pi/2
Ejemplo n.º 46
0
    def test_half_ufuncs(self):
        """Test the various ufuncs"""

        a = np.array([0, 1, 2, 4, 2], dtype=float16)
        b = np.array([-2, 5, 1, 4, 3], dtype=float16)
        c = np.array([0, -1, -np.inf, np.nan, 6], dtype=float16)

        assert_equal(np.add(a, b), [-2, 6, 3, 8, 5])
        assert_equal(np.subtract(a, b), [2, -4, 1, 0, -1])
        assert_equal(np.multiply(a, b), [0, 5, 2, 16, 6])
        assert_equal(np.divide(a, b), [0, 0.199951171875, 2, 1, 0.66650390625])

        assert_equal(np.equal(a, b), [False, False, False, True, False])
        assert_equal(np.not_equal(a, b), [True, True, True, False, True])
        assert_equal(np.less(a, b), [False, True, False, False, True])
        assert_equal(np.less_equal(a, b), [False, True, False, True, True])
        assert_equal(np.greater(a, b), [True, False, True, False, False])
        assert_equal(np.greater_equal(a, b), [True, False, True, True, False])
        assert_equal(np.logical_and(a, b), [False, True, True, True, True])
        assert_equal(np.logical_or(a, b), [True, True, True, True, True])
        assert_equal(np.logical_xor(a, b), [True, False, False, False, False])
        assert_equal(np.logical_not(a), [True, False, False, False, False])

        assert_equal(np.isnan(c), [False, False, False, True, False])
        assert_equal(np.isinf(c), [False, False, True, False, False])
        assert_equal(np.isfinite(c), [True, True, False, False, True])
        assert_equal(np.signbit(b), [True, False, False, False, False])

        assert_equal(np.copysign(b, a), [2, 5, 1, 4, 3])

        assert_equal(np.maximum(a, b), [0, 5, 2, 4, 3])

        x = np.maximum(b, c)
        assert_(np.isnan(x[3]))
        x[3] = 0
        assert_equal(x, [0, 5, 1, 0, 6])

        assert_equal(np.minimum(a, b), [-2, 1, 1, 4, 2])

        x = np.minimum(b, c)
        assert_(np.isnan(x[3]))
        x[3] = 0
        assert_equal(x, [-2, -1, -np.inf, 0, 3])

        assert_equal(np.fmax(a, b), [0, 5, 2, 4, 3])
        assert_equal(np.fmax(b, c), [0, 5, 1, 4, 6])
        assert_equal(np.fmin(a, b), [-2, 1, 1, 4, 2])
        assert_equal(np.fmin(b, c), [-2, -1, -np.inf, 4, 3])

        assert_equal(np.floor_divide(a, b), [0, 0, 2, 1, 0])
        assert_equal(np.remainder(a, b), [0, 1, 0, 0, 2])
        assert_equal(np.divmod(a, b), ([0, 0, 2, 1, 0], [0, 1, 0, 0, 2]))
        assert_equal(np.square(b), [4, 25, 1, 16, 9])
        assert_equal(np.reciprocal(b),
                     [-0.5, 0.199951171875, 1, 0.25, 0.333251953125])
        assert_equal(np.ones_like(b), [1, 1, 1, 1, 1])
        assert_equal(np.conjugate(b), b)
        assert_equal(np.absolute(b), [2, 5, 1, 4, 3])
        assert_equal(np.negative(b), [2, -5, -1, -4, -3])
        assert_equal(np.positive(b), b)
        assert_equal(np.sign(b), [-1, 1, 1, 1, 1])
        assert_equal(np.modf(b), ([0, 0, 0, 0, 0], b))
        assert_equal(np.frexp(b),
                     ([-0.5, 0.625, 0.5, 0.5, 0.75], [2, 3, 1, 3, 2]))
        assert_equal(np.ldexp(b, [0, 1, 2, 4, 2]), [-2, 10, 4, 64, 12])
Ejemplo n.º 47
0
# Lets suppose highest=97 and average=68
qual_level_lo = fuzz.interp_membership(x_highest, highest_lo, 97)
qual_level_md = fuzz.interp_membership(x_highest, highest_md, 97)
qual_level_hi = fuzz.interp_membership(x_highest, highest_hi, 97)

serv_level_lo = fuzz.interp_membership(x_average, average_lo, 68)
serv_level_md = fuzz.interp_membership(x_average, average_md, 68)
serv_level_hi = fuzz.interp_membership(x_average, average_hi, 68)

# Defining rules , low highest marks and low average.
# The OR operator means we take the maximum of these two.
active_rule1 = np.fmax(qual_level_lo, serv_level_lo)

# membership function with `np.fmin`
tip_activation_lo = np.fmin(active_rule1, cutoff_lo)

# For rule 2 we connect acceptable service to medium cutoff
tip_activation_md = np.fmin(serv_level_md, cutoff_md)

# For rule 3 we connect high highest marks OR high average with high cutoff
active_rule3 = np.fmax(qual_level_hi, serv_level_hi)
tip_activation_hi = np.fmin(active_rule3, cutoff_hi)
tip0 = np.zeros_like(x_cutoff)

# Visualize this
fig, ax0 = plt.subplots(figsize=(8, 3))

ax0.fill_between(x_cutoff, tip0, tip_activation_lo, facecolor='b', alpha=0.7)
ax0.plot(
    x_cutoff,
Ejemplo n.º 48
0
def real_loc_to_pixel_loc(x,y,h,w,xmin,xmax,ymin,ymax):
   assert len(x)==len(y)
   pixel_x=np.fmin((x-xmin)/(xmax-xmin)*w,w-1)
   pixel_y=np.fmin((y-ymin)/(ymax-ymin)*h,h-1)
   return pixel_x.astype(int),pixel_y.astype(int)
Ejemplo n.º 49
0
def graphcut(img, alpha,rect,foreground_gmm,background_gmm,flow_vector, gamma,
             num_iterations=1, num_components=5):

    """
    Given an image, return the partition of the image using customized graphcut 
    as described in the in hand object scanning paper

    Parameters
    ----------
    img:  (m,n,3) uint8 
     The input color image
    alpha : int 
     Integer specifying background or foreground (0 or 1)
    rect : (4, ) float
     A list of 4 elements of (x,y,w,h), which is the zoomed in bounding box of 
     the segment from the previous frame, this is to reduce the amount of 
     computation needed to perform graphcut (Graphcut only computed within the
     region of this rect
    foreground_gmm : an utils.GMM instance
      Gaussian mixture models for the foreground
    background_gmm : an utils.GMM instance
      Gaussian mixture models for the background 
    flow_vector : (m,n) float
      A flow gradient that describe the amount of shifts per pixel between 
      frames
    gamma : int
      A ballancing constant used according to the original graphcut paper

    Returns
    -------
    result: (m,n ) uint8
     A partition of the image where 255 indicates foreground and 0 indicaes background
 
      
    """



   
    img2=img.copy()

    # trim down the cut area to the projected rect estimated from the last frame
    img=img[int(rect[0]):int(rect[0]+rect[2]),int(rect[1]):int(rect[1]+rect[3])]
    alpha=alpha[int(rect[0]):int(rect[0]+rect[2]),int(rect[1]):int(rect[1]+rect[3])]
    flow_vector=flow_vector[int(rect[0]):int(rect[0]+rect[2]),int(rect[1]):int(rect[1]+rect[3])]

    # compute the pairwise smoothness term for both color and optical flow image
    # and choose the smaller of the two 
    user_definite_background = np.where(alpha==0)
    pairwise_energies_1 = compute_smoothness_vectorized(img, neighborhood='eight')
    pairwise_energies_2 = compute_smoothness_vectorized(flow_vector, neighborhood='eight')
    pairwise_energies= np.fmin(pairwise_energies_1, pairwise_energies_2)

    # Get GMM components based on color from the given fgd,bgf model
    pixels = img.reshape((img.shape[0]*img.shape[1], img.shape[2]))
    foreground_components = foreground_gmm.get_component(pixels).reshape((img.shape[0], img.shape[1]))
    background_components = background_gmm.get_component(pixels).reshape((img.shape[0], img.shape[1]))

    # Compute Unary energies for each node (foreground and background energies)
    # graph = create_graph(img)
    node_ids, graph = create_graph(img)
    theta = (background_gmm, foreground_gmm, None, None)
    foreground_energies = get_unary_energy_vectorized(1, foreground_components.reshape((img.shape[0]*img.shape[1], 1))
                                                      , theta, pixels)
    background_energies = get_unary_energy_vectorized(0, background_components.reshape((img.shape[0]*img.shape[1], 1))
                                                      , theta, pixels)
    energy_differences = np.subtract(foreground_energies,background_energies)
    energy_min = np.fmin(foreground_energies, background_energies)
    better_count = np.where(energy_differences<10)
    foreground_energies[better_count] = energy_min[better_count]

    # Assign Unary energy for user defined background
    # Large foreground energy: gamma*9 as used in opencv implementation
    # Small background energy: 0
    foreground_energies = foreground_energies.reshape(alpha.shape)
    background_energies = background_energies.reshape(alpha.shape)
    
    foreground_energies[user_definite_background] = gamma*9
    background_energies[user_definite_background] = 0

    # update graph with the energies
    for h in xrange(img.shape[0]):
        for w in xrange(img.shape[1]):
            index = h*img.shape[1] + w
            # void add_tweights(node_id i, tcaptype cap_source, tcaptype cap_sink);
            # graph.add_tweights(index, foreground_energies[h][w], background_energies[h][w])
            # try:
            #     graph.add_tedge(index, foreground_energies[h][w], background_energies[h][w])
            # except:
            #     print(index, foreground_energies[h][w], background_energies[h][w])
            graph.add_tedge(index, foreground_energies[h][w], round_int(background_energies[h][w]))

    # Compute pairwise weights
    NEIGHBORHOOD = [(-1,0),(+1,0),(0,-1),(0,+1),(-1,-1),(-1,+1),(+1,+1),(+1,-1)]
    src_h = np.tile(np.arange(img.shape[0]).reshape(img.shape[0], 1), (1, img.shape[1]))
    src_w = np.tile(np.arange(img.shape[1]).reshape(1, img.shape[1]), (img.shape[0], 1))
    src_h = src_h.astype(np.int32)
    src_w = src_w.astype(np.int32)

    for i, energy in enumerate(pairwise_energies):
        if i in [1,3,6,7]:
            continue
        height_offset, width_offset = NEIGHBORHOOD[i]

        dst_h = src_h + height_offset
        dst_w = src_w + width_offset

        idx = np.logical_and(np.logical_and(dst_h >= 0, dst_h < img.shape[0]),
                            np.logical_and(dst_w >= 0, dst_w < img.shape[1]))

        src_idx = src_h * img.shape[1] + src_w
        dst_idx = dst_h * img.shape[1] + dst_w

        src_idx = src_idx[idx].flatten()
        dst_idx = dst_idx[idx].flatten()
        weights = energy.astype(np.float32)[idx].flatten()
        weights = gamma*weights

        # graph.add_edge_vectorized(src_idx, dst_idx, weights, weights)
        # graph.add_edge(src_idx, dst_idx, weights, weights)
        graph = add_edge_vectorized(graph, src_idx, dst_idx, weights, weights)
    # perform mincut/maxflow with pymaxflow
    graph.maxflow()
    # partition = graph.what_segment_vectorized()
    partition = graph.get_grid_segments(node_ids)

    partition = partition.reshape(alpha.shape)
    blank=np.zeros(img2.shape[:2])
    blank[int(rect[0]):int(rect[0]+rect[2]),int(rect[1]):int(rect[1]+rect[3]) ]=partition*255
    result = blank.astype(dtype=np.uint8)
 
    return result
Ejemplo n.º 50
0
def HMC(f, num_samples, Lmax, epsilon, x0, verbose=False, option_hmc = 0, mean_approx = None, cov_approx = None):
    D = x0.size
    samples = np.zeros((num_samples, D))
    samples[0] = x0
    logprob, grad = f(x0)

    ## Precompute the rotation matrix if using split HMC or the guiding Hamiltonian
    ## In these cases the potential energy is a quadratic form involving the inverse of the covariance of the approximating Gaussian
    if(option_hmc != 0):
        ## Compute eigenvalues and eigenvectors of the covariance of the Gaussian approximation
        ## These are useful to rotate the coordinates of the harmonic oscillator in D dimensions making the D dynamics independent
        eigen_cov_approx = np.linalg.eig(cov_approx)
        eigenvect_cov_approx = eigen_cov_approx[1]
        eigenval_cov_approx = eigen_cov_approx[0]

        ## omega is the vector of the D angular frequencies sqrt(1/lambda_i) where lambda_i is the ith eigenvalue
        omega = np.zeros(D)
        for i in range(0,D):
            omega[i] = np.sqrt(1/(eigenval_cov_approx[i]))

    accept_count_batch = 0
    accept_count = 0

    for t in range(num_samples-1):

        ## Output acceptance rate every 100 iterations
        if(((t+1) % 100) == 0):
            print("Iteration: ", t+1, "\t Acc Rate: ", 1. * accept_count_batch, "%")
            accept_count_batch = 0

        logprob_t, grad_t = logprob, grad.copy()
        pt = np.random.randn(D)
        Lt = np.random.randint(1, Lmax+1)


        # Standard HMC - begin leapfrogging
        premature_reject = False
        if(option_hmc == 0):
            x = samples[t].copy()
            p = pt + 0.5 * epsilon * grad
            for l in range(Lt):
                x  += epsilon * p
                logprob, grad = f(x)
                if np.any(np.isnan(grad)):
                    premature_reject = True
                    break
                p += epsilon * grad
            p -= 0.5*epsilon * grad
        #leapfrogging done
        if premature_reject:
            print("warning: numerical instability. rejecting this proposal prematurely")
            samples[t+1] = samples[t]
            logprob, grad = logprob_t, grad_t
            continue

        if(option_hmc == 1):
            raise NotImplementedError
        
        if(option_hmc == 2):
            raise NotImplementedError

        log_accept_ratio = logprob - 0.5*p.dot(p) - logprob_t + 0.5*pt.dot(pt)
        logu = np.log(np.random.rand())

        if verbose:
            print('sample number {:<4} steps: {:<3}, eps: {:.2f} logprob: {:.2f} accept_prob: {:.2f}, {} (accepted {:.2%})'.format(t,Lt, epsilon, logprob, np.fmin(1, np.exp(log_accept_ratio)), 'rejecting' if logu>log_accept_ratio else 'accepting', accept_count/(t+1)))
        if logu < log_accept_ratio:
            samples[t+1] = x
            accept_count_batch += 1
            accept_count += 1
        else:
            samples[t+1] = samples[t]
            logprob, grad = logprob_t, grad_t
    return samples, (accept_count*1.0)/num_samples
Ejemplo n.º 51
0
# This is what fuzz.interp_membership exists for!
qual_level_lo = fuzz.interp_membership(x_qual, qual_lo, 6.5)
qual_level_md = fuzz.interp_membership(x_qual, qual_md, 6.5)
qual_level_hi = fuzz.interp_membership(x_qual, qual_hi, 6.5)

serv_level_lo = fuzz.interp_membership(x_serv, serv_lo, 9.8)
serv_level_md = fuzz.interp_membership(x_serv, serv_md, 9.8)
serv_level_hi = fuzz.interp_membership(x_serv, serv_hi, 9.8)

# Now we take our rules and apply them. Rule 1 concerns bad food OR service.
# The OR operator means we take the maximum of these two.
active_rule1 = np.fmax(qual_level_lo, serv_level_lo)

# Now we apply this by clipping the top off the corresponding output
# membership function with `np.fmin`
tip_activation_lo = np.fmin(active_rule1, tip_lo)  # removed entirely to 0

# For rule 2 we connect acceptable service to medium tipping
tip_activation_md = np.fmin(serv_level_md, tip_md)

# For rule 3 we connect high service OR high food with high tipping
active_rule3 = np.fmax(qual_level_hi, serv_level_hi)
tip_activation_hi = np.fmin(active_rule3, tip_hi)
tip0 = np.zeros_like(x_tip)

"""
.. image:: PLOT2RST.current_figure

Rule aggregation
----------------
Ejemplo n.º 52
0
    def deltamz(self, mz_value):
        "computes the theorical maximum resolution in m/z at m/z location"

        mz = np.fmin(mz_value, HighestMass)
        return 0.5 * (self.itomz(self.mztoi(mz) - 1) -
                      self.itomz(self.mztoi(mz) + 1))
Ejemplo n.º 53
0
 def dK_dtheta(self, dL_dK, X, X2, target):
     if X2 is None:
         X2 = X
     target += np.sum(np.fmin(X, X2.T) * dL_dK)
Ejemplo n.º 54
0
 def And(cond1, cond2):
     return fmin(cond1, cond2)
Ejemplo n.º 55
0
 def fun(x, shape):
     from numpy import fmin, fmax
     x = fmax(0, fmin(255, x * 255))
     return x.reshape(shape)
Ejemplo n.º 56
0
def predict(price_input, distance_input, rating_input):
    # R1: If the price is cheap, distance is close, rating is good, then consider going.
    r1_x1 = fuzz.interp_membership(price, cheap, price_input)
    r1_x2 = fuzz.interp_membership(distance, close, distance_input)
    r1_x3 = fuzz.interp_membership(rating, good, rating_input)
    fire_r1 = min(r1_x1, r1_x2, r1_x3)
    # R2: If the price is cheap, distance is medium, rating is good, then consider going.
    r2_x1 = fuzz.interp_membership(price, cheap, price_input)
    r2_x2 = fuzz.interp_membership(distance, medium_distance, distance_input)
    r2_x3 = fuzz.interp_membership(rating, good, rating_input)
    fire_r2 = min(r2_x1, r2_x2, r2_x3)
    # R3: if the price is expensive, distance is far, rating is bad, then consider not going.
    r3_x1 = fuzz.interp_membership(price, expensive, price_input)
    r3_x2 = fuzz.interp_membership(distance, far, distance_input)
    r3_x3 = fuzz.interp_membership(rating, bad, rating_input)
    fire_r3 = min(r3_x1, r3_x2, r3_x3)
    # R4: If the price is expensive, distance is far, rating is moderate, then consider not going.
    r4_x1 = fuzz.interp_membership(price, expensive, price_input)
    r4_x2 = fuzz.interp_membership(distance, far, distance_input)
    r4_x3 = fuzz.interp_membership(rating, moderate, rating_input)
    fire_r4 = min(r4_x1, r4_x2, r4_x3)
    # R5: If the price is expensive, distance is medium, rating is bad, then consider not going.
    r5_x1 = fuzz.interp_membership(price, expensive, price_input)
    r5_x2 = fuzz.interp_membership(distance, medium_distance, distance_input)
    r5_x3 = fuzz.interp_membership(rating, bad, rating_input)
    fire_r5 = min(r5_x1, r5_x2, r5_x3)
    # R6: If the price is medium, distance is close, rating is good, then consider going.
    r6_x1 = fuzz.interp_membership(price, medium_price, price_input)
    r6_x2 = fuzz.interp_membership(distance, close, distance_input)
    r6_x3 = fuzz.interp_membership(rating, good, rating_input)
    fire_r6 = min(r6_x1, r6_x2, r6_x3)
    # R7: If the price is medium, distance is far, rating is bad, then consider not going.
    r7_x1 = fuzz.interp_membership(price, medium_price, price_input)
    r7_x2 = fuzz.interp_membership(distance, far, distance_input)
    r7_x3 = fuzz.interp_membership(rating, bad, rating_input)
    fire_r7 = min(r7_x1, r7_x2, r7_x3)
    # R8: If the price is medium, distance is far, rating is moderate, then consider not going.
    r8_x1 = fuzz.interp_membership(price, medium_price, price_input)
    r8_x2 = fuzz.interp_membership(distance, far, distance_input)
    r8_x3 = fuzz.interp_membership(rating, moderate, rating_input)
    fire_r8 = min(r8_x1, r8_x2, r8_x3)
    # R9: If the price is medium, distance is medium, rating is bad, then consider not going.
    r9_x1 = fuzz.interp_membership(price, medium_price, price_input)
    r9_x2 = fuzz.interp_membership(distance, medium_distance, distance_input)
    r9_x3 = fuzz.interp_membership(rating, bad, rating_input)
    fire_r9 = min(r9_x1, r9_x2, r9_x3)
    # R10: If the price is medium, distance is medium, rating is good, then consider going.
    r10_x1 = fuzz.interp_membership(price, medium_price, price_input)
    r10_x2 = fuzz.interp_membership(distance, medium_distance, distance_input)
    r10_x3 = fuzz.interp_membership(rating, good, rating_input)
    fire_r10 = min(r10_x1, r10_x2, r10_x3)

    rule_1_clip = np.fmin(fire_r1, will_go)
    rule_2_clip = np.fmin(fire_r2, will_go)
    rule_3_clip = np.fmin(fire_r3, not_go)
    rule_4_clip = np.fmin(fire_r4, not_go)
    rule_5_clip = np.fmin(fire_r5, not_go)
    rule_6_clip = np.fmin(fire_r6, will_go)
    rule_7_clip = np.fmin(fire_r7, not_go)
    rule_8_clip = np.fmin(fire_r8, not_go)
    rule_9_clip = np.fmin(fire_r9, not_go)
    rule_10_clip = np.fmin(fire_r10, will_go)

    # Aggregate all rules
    temp1 = np.fmax(rule_1_clip, rule_2_clip)
    temp2 = np.fmax(temp1, rule_3_clip)
    temp3 = np.fmax(temp2, rule_4_clip)
    temp4 = np.fmax(temp3, rule_5_clip)
    temp5 = np.fmax(temp4, rule_6_clip)
    temp6 = np.fmax(temp5, rule_7_clip)
    temp7 = np.fmax(temp6, rule_8_clip)
    temp8 = np.fmax(temp7, rule_9_clip)
    output = np.fmax(temp8, rule_10_clip)

    # Defuzzification
    try:
        going_predict = fuzz.defuzz(label, output, 'centroid')
        if args.graph:
            fire_going = fuzz.interp_membership(label, output, going_predict)
            label_0 = np.zeros_like(label)
            fig, ax0 = plt.subplots(figsize=(8, 3))
            ax0.plot(label, will_go, 'g', linestyle='--')
            ax0.plot(label, not_go, 'r', linestyle='--')
            ax0.fill_between(label,
                             label_0,
                             output,
                             facecolor='Orange',
                             alpha=0.5)
            ax0.plot([going_predict, going_predict], [0, fire_going],
                     'k',
                     linewidth=2.5,
                     alpha=0.9)
            ax0.get_xaxis().tick_bottom()
            ax0.get_yaxis().tick_left()
            ax0.set_xlim([min(label), max(label)])
            ax0.set_ylim([0, 1])
            plt.xlabel('Possibility of Going to the Restaurant')
            plt.ylabel('membership degree')
            plt.title('Restaurant ')
            plt.show()
        return going_predict
    except AssertionError:
        return -1
Ejemplo n.º 57
0
  def evaluate(self, cart_coords, hmat=None, ivals=None):
    """
      Compute the value of the dihedral angle.

#
#

      Parameters
      ----------
      cart_coords: (N, 3) array
                   Atomic positions in Cartesian coordinates, where N is the
                   number of atoms in the system.
      ivals: (2,) array, optional
             The index of the left and right point used to calculate
             the dihedral angle. The indices have to be from 1 to the number
             of the corresponding points.

      Return
      ------
      distance: float
                Dihedral angle in radians.

    Example
    -------

    1
     \\
      2---3
           \\
            4

    >>> d = Dihedral([1], [2,3], [4])
    >>> v = d.evaluate(coords) # Compute 1--2--3--4 angle

     1       6
      \\     /
    2--4---5
      /     \\
     3       7

    >>> d = Dihedral([1,2,3], [4,5], [6,7])
    >>> v = d.evaluate(coords) # Compute 1--4--5--6 angle
    >>> v = d.evaluate(coords, ivals=[3,1]) # Compute 3--4--5--6 angle

    >>> d = Dihedral([1,2,3], [4,5], [6,7], ivals=[1,2])
    >>> v = d.evaluate(coords) # Compute 1--4--5--7 angle
    >>> v = d.evaluate(coords, ivals=[3,1]) # Compute 3--4--5--6 angle
    """

    if not ivals is None:
      self._ivals = list(ivals)
      if len(self._ivals) != 2:
        raise Exception('Two "ivals" are needed')

    # Get dihedral axis and vectors
    ivecs = [self._iaxis] + [(self._iaxis[0], self._ivals[0]-1),
                             (self._iaxis[1], self._ivals[1]+len(self._left)+1)]
    axis, v1, v2 = self.get_vectors(ivecs, cart_coords, hmat)

    # Compute normal vectors
    n1, n2 = np.cross(axis, v1), np.cross(axis, v2)
    n1, n2 = n1/npl.norm(n1), n2/npl.norm(n2)

    # Compute angle
    angl = np.sum(n1*n2)
    angl = np.fmin(np.fmax(-1,angl),1.)
    angl = np.arccos(angl)
    if np.sum(np.cross(n1, n2)*axis) > 0:
      angl *= -1

    return angl
Ejemplo n.º 58
0
# calculate membership function values
participants_value_low = fuzz.interp_membership(participants, participants_low, input_participants)
participants_value_medium = fuzz.interp_membership(participants, participants_medium, input_participants)
participants_value_high = fuzz.interp_membership(participants, participants_high, input_participants)

available_slots_value_low = fuzz.interp_membership(available_slots, available_slots_low, input_available_slots)
available_slots_value_medium = fuzz.interp_membership(available_slots, available_slots_medium, input_available_slots)
available_slots_value_high = fuzz.interp_membership(available_slots, available_slots_high, input_available_slots)

test_difficulty_value_low = fuzz.interp_membership(test_difficulty, test_difficulty_low, input_test_difficulty)
test_difficulty_value_medium = fuzz.interp_membership(test_difficulty, test_difficulty_medium, input_test_difficulty)
test_difficulty_value_high = fuzz.interp_membership(test_difficulty, test_difficulty_high, input_test_difficulty)

# apply rules
value_rule_1 = np.fmax(np.fmax(participants_value_high, available_slots_value_low), test_difficulty_value_high)
value_rule_2 = np.fmin(np.fmin(1 - participants_value_high, 1 - test_difficulty_value_high), 1 - available_slots_value_low)
value_rule_3 = np.fmax(test_difficulty_value_low, np.fmax(1 - participants_value_high, 1 - available_slots_value_low))

acceptance_probability_value_low = np.fmin(value_rule_1, acceptance_probability_low)
acceptance_probability_value_medium = np.fmin(value_rule_2, acceptance_probability_medium)
acceptance_probability_value_high = np.fmin(value_rule_3, acceptance_probability_high)

# plot rule values
acceptance_probability_zero = np.zeros_like(acceptance_probability)

fig, ax0 = plt.subplots(figsize=(8, 3))

ax0.fill_between(acceptance_probability, acceptance_probability_zero, acceptance_probability_value_low, facecolor='b',
                 alpha=0.5)
ax0.plot(acceptance_probability, acceptance_probability_low, 'b', linewidth=0.5, linestyle='--', )
ax0.fill_between(acceptance_probability, acceptance_probability_zero, acceptance_probability_value_medium,
Ejemplo n.º 59
0
def approximate_time_remaining_until_walk(hours_passed_after_pee,
                                          crying_intensity):
    last_time_peed_raw = int(hours_passed_after_pee)
    crying_intensity_raw = int(crying_intensity)

    if last_time_peed_raw < 0:
        raise ValueError('Last time peed must be greater than 0')

    if crying_intensity_raw < 0 or crying_intensity_raw > 10:
        raise ValueError(
            'Crying intensity must be greater than 0 and less than or equals than 10'
        )

    if last_time_peed_raw > 10:
        exit('now')

    last_time_peed_range = np.arange(0, 11, 0.1)
    crying_intensity_range = np.arange(0, 11, 0.1)

    last_time_peed_now_function = fuzz.zmf(last_time_peed_range, 0, 1.5)
    last_time_peed_couple_of_hours_function = fuzz.gaussmf(
        last_time_peed_range, 0.75, 2.9)
    last_time_peed_many_hours_function = fuzz.smf(last_time_peed_range, 2.8,
                                                  4.5)

    crying_intensity_none_function = fuzz.zmf(crying_intensity_range, 0, 1.5)
    crying_intensity_slight_function = fuzz.gauss2mf(crying_intensity_range,
                                                     0.5, 0.6, 0.8, 1.7)
    crying_intensity_medium_function = fuzz.gaussmf(crying_intensity_range,
                                                    1.6, 4.5)
    crying_intensity_high_function = fuzz.smf(crying_intensity_range, 5, 7.9)

    walk_after_how_much_time_range = np.arange(0, 5, 0.1)
    walk_now_function = fuzz.zmf(walk_after_how_much_time_range, 0, 0.5)
    walk_after_a_while_function = fuzz.gaussmf(walk_after_how_much_time_range,
                                               0.4, 0.8)
    walk_later_function = fuzz.gaussmf(walk_after_how_much_time_range, 0.6,
                                       1.9)
    walk_after_couple_of_hours_function = fuzz.smf(
        walk_after_how_much_time_range, 2.3, 3.8)

    def convert_last_time_peed(last_time_peed_in_hours):
        now = fuzz.interp_membership(last_time_peed_range,
                                     last_time_peed_now_function,
                                     last_time_peed_in_hours)
        couple_of_hours = fuzz.interp_membership(
            last_time_peed_range, last_time_peed_couple_of_hours_function,
            last_time_peed_in_hours)
        many_hours = fuzz.interp_membership(
            last_time_peed_range, last_time_peed_many_hours_function,
            last_time_peed_in_hours)
        return [now, couple_of_hours, many_hours]

    def convert_crying_intensity(crying_intensity):
        none = fuzz.interp_membership(crying_intensity_range,
                                      crying_intensity_none_function,
                                      crying_intensity)
        slight = fuzz.interp_membership(crying_intensity_range,
                                        crying_intensity_slight_function,
                                        crying_intensity)
        medium = fuzz.interp_membership(crying_intensity_range,
                                        crying_intensity_medium_function,
                                        crying_intensity)
        high = fuzz.interp_membership(crying_intensity_range,
                                      crying_intensity_high_function,
                                      crying_intensity)
        return [none, slight, medium, high]

    last_time_peed_converted = convert_last_time_peed(last_time_peed_raw)
    crying_intensity_converted = convert_crying_intensity(crying_intensity_raw)

    rules = [
        np.fmax(last_time_peed_converted[-1], crying_intensity_converted[-1]),
        np.fmin(
            last_time_peed_converted[0],
            np.fmax(crying_intensity_converted[1],
                    crying_intensity_converted[0])),
        np.fmin(last_time_peed_converted[1], crying_intensity_converted[0]),
        np.fmin(last_time_peed_converted[1], crying_intensity_converted[2]),
        np.fmin(last_time_peed_converted[1], crying_intensity_converted[1])
    ]

    walk_now = np.fmin(rules[0], walk_now_function)
    walk_after_a_while = np.fmin(rules[-2], walk_after_a_while_function)
    walk_later = np.fmin(rules[-1], walk_later_function)
    walk_after_couple_of_hours = np.fmin(rules[1],
                                         walk_after_couple_of_hours_function)

    aggregated = np.fmax(
        walk_now,
        np.fmax(walk_after_a_while,
                np.fmax(walk_later, walk_after_couple_of_hours)))
    result = fuzz.defuzz(walk_after_how_much_time_range, aggregated,
                         'centroid')

    return result
Ejemplo n.º 60
0
def subset_minibatch(dat, offset, batch_size):
    rg = np.arange(offset, offset + batch_size)
    rg = np.fmin(rg, dat['X'].shape[0] - 1)
    return {x: y[rg, :] for x, y in dat.items()}